Copy page

Guides

Advanced Searching Guide

The _advanced parameter family lets you express filters that the bare title, description, location, and organization parameters can't - things like "AI roles but not marketing", "Germany excluding Berlin and Munich", or "every University except Harvard". All four parameters share the same Boolean search-expression syntax (&, |, !, <->, grouping with (), prefix matching with :*).

The bare parameters accept Google-style natural-language input - spaces between terms behave as AND, double-quoted substrings are exact phrases, and a leading - excludes a term. The _advanced parameters trade convenience for power and precision: instead of inferring intent from spacing, you write the Boolean expression explicitly, and the parser is strict about syntax (no implicit AND between bare words, balanced parentheses required, every operator must have operands).

Available parameters

Parameter	What it searches	Notes
title_advanced	Job title	If title is also passed, title_advanced wins.
description_advanced	Title and description combined	Matches in either field count. Pair with title_advanced if you also need a term in the title specifically. Expensive on time_frame=6m.
location_advanced	locations_derived	Same naming rules as location - full English names, no abbreviations. See Nuances of Location Search.
organization_advanced	Organization name	Matches the source-supplied name, not org_linkedin_name.

Operators

Operator	Meaning	Example
&	AND - both must match anywhere	senior & engineer
|	OR - either may match	python | rust
!	NOT - exclude	engineer & !staff
<->	FOLLOWED BY - adjacent words in order (phrase)	machine <-> learning
<N>	FOLLOWED BY with distance N (N-1 words between)	data <2> scientist matches data lead scientist
'...'	Single-quoted phrase - shorthand for <-> between each word	'machine learning' equivalent to machine <-> learning
(...)	Grouping	(python | rust) & senior
:*	Prefix match	manag:* matches manager, management, managing, ...

Single-quoted phrases are the most readable way to express adjacency. 'senior engineer' is equivalent to senior <-> engineer, and word order matters - 'engineer senior' returns a different result set than 'senior engineer'.

Good to know

A few practical behaviours worth keeping in mind when writing expressions:

• Search is case-insensitive. Python and python match the same rows.
• Concatenated spellings are matched separately from spaced ones. OpenAI (no space) and Open AI (with space) are not equivalent. To catch both, list them explicitly: OpenAI | 'Open AI'.

URL-encoding

Operator characters need to be URL-encoded in the request URL or they'll be mis-parsed:

Character	Encoded
&	%26 (otherwise treated as a query-string separator - the most common pitfall)
|	%7C (recommended; most clients accept it raw)
!	%21 (recommended)
< / >	%3C / %3E
space	%20 or +

Example: (python | rust) & !staff becomes:

Code
?title_advanced=%28python%20%7C%20rust%29%20%26%20%21staff

Most HTTP clients and SDKs will URL-encode parameters automatically when you build the request from a key-value object.

title_advanced

Code
(AI | 'machine learning' | robotics) & !marketing

AI/ML/robotics roles, excluding any marketing titles. 'machine learning' matches the phrase in that order.

Code
senior & (python | rust) & !staff

Senior IC roles in either stack, excluding staff-engineer titles.

Code
project <-> manag:*

Matches project manager, project management, project managing, ... manag:* covers any word starting with manag. Note that the single-quoted form ('project manager') doesn't support prefix matching, so use <-> when you need :*.

Code
'data engineer' | 'data scientist' | 'analytics engineer'

Phrase match for any of three role names.

description_advanced

description_advanced runs against the title and description combined. A term anywhere in either field will match.

Code
'remote work' & (equity | 'stock options') & !contractor

Roles mentioning the phrase "remote work" and some form of equity comp, excluding contractor postings.

Code
(kubernetes | k8s) & terraform & aws

DevOps roles touching all three technologies in the job text.

If you need a term to appear specifically in the title (not just the description), combine it with title_advanced:

Code
title_advanced=senior & engineer
description_advanced=golang | 'go programming'

location_advanced

The same full-name convention as location applies (United States, not US; London, England, United Kingdom, not London, UK). See Nuances of Location Search for the full structure.

Multi-word place names like "New York" are matched as separate words. Use a single-quoted phrase (or <->) to require adjacency, or & if you just want both words present anywhere in the location string.

Code
'United States' & !California

US-wide search excluding California.

Code
Germany & !(Berlin | Munich)

Germany excluding two cities.

Code
'New York' | 'San Francisco' | Boston

Multi-city search across three US cities.

Code
'United Kingdom' & !London

UK excluding London. Pair with the full-name convention to avoid accidentally excluding "London, Ontario, Canada" - because UK rows usually contain england/scotland/etc in their location string, a stricter version is England & !London.

organization_advanced

Code
University & !Harvard

Every employer with "University" in its name except Harvard.

Code
(Microsoft | Google | Apple)

Match any of the three.

Code
OpenAI | 'Open AI'

Catches the company under either spelling - OpenAI (no space) and Open AI (with space) are matched differently, so list both to be safe.

Combining _advanced parameters

All four _advanced parameters can be combined in a single request and are ANDed together at the query level. Each individual parameter still uses its own Boolean expression internally.

Code
title_advanced=(engineer | developer) & !manager
location_advanced='United States' & !California
organization_advanced=!(Amazon | Meta | Google)
description_advanced=remote & (equity | 'stock options')

Engineer or developer (but not manager) roles, in the US excluding California, at companies that aren't Amazon/Meta/Google, mentioning remote work and equity comp.

Precedence rules

• _advanced always wins over the bare parameter. If you pass both title=Software Engineer and title_advanced=python | rust, the bare title is ignored.
• Within a single expression, & binds tighter than | (standard Boolean precedence), so a | b & c means a | (b & c). Use parentheses whenever you mix the two.
• ! binds tighter than & and |, so !a & b means (!a) & b.

Common patterns

Exclude a category of titles: wrap the unwanted terms with !(...) and AND it onto your positive match.

Code
(engineer | developer) & !(intern | junior | 'entry level')

Loose phrase + strict requirement: use a phrase to broaden recall, then AND a required keyword to keep precision.

Code
('full stack' | fullstack) & (typescript | javascript)

Prefix family: use :* when you want to catch every word starting with the same letters (manage, manager, management, ...). Single-quoted phrases don't support :*, so fall back to <-> here:

Code
develop:* & !test:*
project <-> manag:*

Multi-spelling fallbacks for compound brand/term names: concatenated and space-separated spellings are matched differently, so list both.

Code
OpenAI | 'Open AI'
fullstack | 'full stack'
ecommerce | 'e commerce'