# 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](/documentation/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'`.

:::warning{title="No bare spaces in `_advanced` expressions"}

Unlike the bare `title`/`description`/`location` parameters (which treat a space as AND), `_advanced` requires an explicit operator between every pair of terms. `title_advanced=software engineer` will return a `400`. Use one of:

- `software & engineer` - both anywhere in the title
- `software <-> engineer` - exact phrase, in that order
- `'software engineer'` - same as above, more readable

:::

## 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:

```
?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`

```
(AI | 'machine learning' | robotics) & !marketing
```
AI/ML/robotics roles, excluding any marketing titles. `'machine learning'` matches the phrase in that order.

```
senior & (python | rust) & !staff
```
Senior IC roles in either stack, excluding staff-engineer titles.

```
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 `:*`.

```
'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.

```
'remote work' & (equity | 'stock options') & !contractor
```
Roles mentioning the phrase "remote work" and some form of equity comp, excluding contractor postings.

```
(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`:

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

:::warning{title="`description_advanced` is expensive on `time_frame=6m`"}

Description search has to scan many more rows on the 6-month backfill window. If a query times out, simplify it, lower `limit`, or shrink the window with `date_posted_gte` / `date_posted_lt`. On `active-jb`, `description` / `description_advanced` are **not** supported on `time_frame=6m` at all and will return a `400`.

:::

## `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](/documentation/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.

```
'United States' & !California
```
US-wide search excluding California.

```
Germany & !(Berlin | Munich)
```
Germany excluding two cities.

```
'New York' | 'San Francisco' | Boston
```
Multi-city search across three US cities.

```
'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`

```
University & !Harvard
```
Every employer with "University" in its name except Harvard.

```
(Microsoft | Google | Apple)
```
Match any of the three.

```
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.

```
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.

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

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

```
('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:

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

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

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