# SearchLeads complete API guide — staging
API base: https://ttzqldekaizydrdmirpn.supabase.co/functions/v1




## Your first request

Create an [API key](/api-keys) with the `search` scope, then send a small request to find matching prospects. Returned people records use export credits; each page is an API call.

The examples on this page already use this environment's API host. Replace only the API-key placeholder with the full key shown when you create it.

| Environment | API base |
| --- | --- |
| Production | `https://pro.searchleads.co/functions/v1` |
| Staging | `https://ttzqldekaizydrdmirpn.supabase.co/functions/v1` |

API keys, search IDs, permissions, credits, and datasets belong to one environment. Keep every call in a workflow on the same API base.

For an AI client, use **Copy for AI**, [the complete text guide](/llms-full.txt), or [the public JSON input contract](/developers/api-docs/agent-contract.json). These contain all public field contracts without requiring JavaScript. Authenticated capabilities remain authoritative for the key owner's current access.



```bash title="Terminal"
curl -X POST "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/people-search" \
  -H "Content-Type: application/json" \
  -H "x-searchleads-api-key: sl_live_your_full_api_key_here" \
  -d '{
    "searchType": "people",
    "textFilters": { "contact.keyword": "sales" },
    "page": 0,
    "size": 1
  }'
```



```javascript title="search.js"
const response = await fetch(
  'https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/people-search',
  {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-searchleads-api-key': process.env.SEARCHLEADS_API_KEY,
    },
    body: JSON.stringify({
      searchType: 'people',
      textFilters: { 'contact.keyword': 'sales' },
      page: 0,
      size: 1,
    }),
  },
);
if (!response.ok) throw new Error(`Search failed: ${response.status}`);
const data = await response.json();
console.log(data.results.content);
```



```python title="search.py"
import json
import os
from urllib.request import Request, urlopen

request = Request(
    'https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/people-search',
    method='POST',
    headers={
        'Content-Type': 'application/json',
        'x-searchleads-api-key': os.environ['SEARCHLEADS_API_KEY'],
    },
    data=json.dumps({
        'searchType': 'people',
        'textFilters': {'contact.keyword': 'sales'},
        'page': 0,
        'size': 1,
    }).encode(),
)
with urlopen(request) as response:
    print(json.load(response)['results']['content'])
```



The response contains `results.content`, `results.totalElements`, and a `search_id` for [asynchronous exports](/developers/api-docs/exports).

## Next steps

- [Authentication](/developers/api-docs/authentication) covers API keys and safe storage.
- [Search](/developers/api-docs/search) describes request fields, examples, and pagination.
- [Filters](/developers/api-docs/filters) shows how to discover valid filter values.
- [Capabilities](/developers/api-docs/capabilities) returns the current limits, access, and field catalog for your key.
- [MCP](/developers/api-docs/mcp) connects compatible AI clients to the hosted server.

Your account's live capabilities response is authoritative for enabled search types, field access, current limits, and export options.

- [Saved searches and sharing](/developers/api-docs/saved-searches) creates reusable definitions and signed-in, expiring share links through REST or MCP.


---

Create a key in [Developer → API Keys](/api-keys) and enable the scope needed for your request. Send the full key in the `x-searchleads-api-key` header.

```http
x-searchleads-api-key: sl_live_your_full_api_key_here
```

The full key is shown once. The prefix displayed later in the dashboard cannot authenticate API or MCP calls. Keep keys in server-side secret storage; never commit them or expose them in browser code.

The same header authenticates [search](/developers/api-docs/search), [capabilities](/developers/api-docs/capabilities), [filter discovery](/developers/api-docs/filters), [exports](/developers/api-docs/exports), and [MCP](/developers/api-docs/mcp).

API keys have `search`, `export`, and `mcp` scopes. Search and filter discovery require `search`; export creation and status require `export`; the hosted MCP server requires `mcp`. Enable only the scopes your client needs.

MCP connection permission does not grant search or export permission:

| Operation | Required key scopes |
| --- | --- |
| REST search / filter option lookup | `search` |
| REST export creation / status | `export` |
| MCP connection, capabilities, filter catalog | `mcp` |
| MCP `search_prospects` / `lookup_filter_options` | `mcp` + `search` |
| MCP `preview_export` / `start_export` / `get_export_status` | `mcp` + `export` |

To search and then export through MCP, enable all three scopes. A key with only `mcp` can connect and discover the service but cannot search, look up filter values, or export. Export creation uses an existing owned `search_id`; creating a new search first also requires search permission.

Authenticated capabilities return `keyCapabilities.scopes` and `keyCapabilities.tools`, including `requiredScopes`, `missingScopes`, and `allowed`. These describe the key's permissions; account feature access, credits, and job limits remain separate requirements. Public documentation capabilities do not describe a particular key.


---

`GET /functions/v1/api-capabilities` returns the current field catalog, access controls, rate limits, and export options for the authenticated key. This response is the source of truth when account configuration differs from the examples in these guides.

The outer response contains `capabilities` for the account and `keyCapabilities` for the current API key. Read `keyCapabilities.tools.<tool>.allowed`, `requiredScopes`, and `missingScopes` separately from account access. Each filter's `matching.defaultCondition` and executable `ruleSchema` reflect the same defaults as the UI; an omitted `matchAll` inherits that default, while explicit boolean true/false overrides it.

```bash
curl -X GET "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/api-capabilities?search_type=all&option_sample_limit=6" \
  -H "x-searchleads-api-key: sl_live_your_full_api_key_here"
```

Read `access.visibleSearchTypes` before offering people or company search. Use `filtersBySearchType` to build filters, `rateLimits` for backoff, and `exports` for supported formats, field keys, size limits, and job limits. The response also reports the lifetime of a search ID used for exports.

Each filter contract includes its `fieldPath`, `title`, `searchType`, `uiType`, include and exclude limits, option mode, option sample, `acceptedValueType`, `acceptedValueTypeV2`, `valueShape`, `acceptsCustomValues`, and `allowedValueBehavior`. Treat the legacy `selected_option_labels` token as a contract hint: submit an exact current `options[].label` for catalog-backed fields. Existing `options[].id` values remain accepted. Use [option discovery](/developers/api-docs/filters) when you need current values or pagination.

The JSON response wraps the contract as `{ "success": true, "capabilities": { ... } }`. Read `capabilities.filtersBySearchType.people` and `.company` separately: the same field can have different limits or permissions in each type. `sendIn` selects `filters` or `textFilters`; exclusions use `excludedFilters`. `exampleValue` is a correctly shaped starting value, `units` describes range boundaries, and `ruleSchema` lists supported matching controls. A null example means you must discover a value first. `uiType` describes the application widget and must not be used to infer the API input shape.

`GET /functions/v1/public-api-capabilities` requires no key and returns a public snapshot. It cannot establish your account's permissions. The [agent JSON contract](/developers/api-docs/agent-contract.json) and [complete text guide](/llms-full.txt) are public documentation snapshots; always refresh authenticated capabilities before executing a campaign.

`search` reports maximum page size and response versions. `exports.fieldsBySearchType` reports every available column, while `bulkDefaultFieldsBySearchType` reports built-in Bulk Export selections. The [live filter reference](/developers/api-docs/filters#complete-filter-reference) and [export column tables](/developers/api-docs/exports#available-export-columns) render these contracts in a readable form.

For API search and option discovery, `rateLimits.perDay.unlimited` is `true` and its limit/current/remaining values are `null`; there is no daily request cap. Continue to obey `rateLimits.perMinute`. Export create and status requests have no customer request quotas: `exports.createRateLimits` and `exports.statusRateLimits` report `unlimited: true` and null period limits. `exports.maxConcurrentJobs`, credit billing and export size limits still apply.


---


The available filters depend on the search type, account permissions, and current catalog. Request [capabilities](/developers/api-docs/capabilities) for the complete field contract. Use `filter-options` to discover values for a catalog-backed field; that lookup does not run a search or charge search or export credits.

```bash
curl -X POST "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/filter-options" \
  -H "Content-Type: application/json" \
  -H "x-searchleads-api-key: sl_live_your_full_api_key_here" \
  -d '{
    "searchType": "people",
    "field": "account.industry",
    "query": "software",
    "limit": 30
  }'
```

Send an exact readable `options[].label` in a search request. Existing `options[].id` values remain accepted for compatibility.

```json
{
  "searchType": "people",
  "filters": { "account.industry": ["Software Development"] },
  "page": 0,
  "size": 25
}
```

Put free-text fields such as `contact.keyword` and `contact.fullName` in `textFilters` as strings. Put structured includes in `filters`, and the values you want removed in `excludedFilters`. Range fields accept `min` and `max`; employee count also accepts an array of range objects. Check each field's `sendIn`, value type, and permitted search types in the capabilities response.

Matching defaults are the same in UI, REST, and MCP. Read each filter's `matching.defaultCondition` (`any` or `all`) and `matching.supportsMatchAll`. Omitting `filterRules.<field>.matchAll` inherits that default; explicit JSON `false` means ANY and `true` means ALL. String values such as `"false"` are invalid. See the [matching examples](/developers/api-docs/search#matching-follows-the-ui).

Option pages contain at most 100 values. REST clamps an oversized positive requested limit to 100; MCP validates its advertised limit of 1–100. Use `hasMore` and `nextCursor` to retrieve the remaining values rather than increasing the limit. Query-required fields still require a value search.

## Browsing and query-required options

Each field exposes `optionDiscovery.mode`, `minimumQueryLength`, `pageSizeMax`, and `starterSample` in capabilities and the agent contract. For `browseable`, omit the query and follow `hasMore` / `nextCursor`, keeping field, search type and query unchanged. A starter sample is not the full catalog. For `requires_query`, send at least two characters; a response with `requires_query: true` and no options asks for a query and does not mean there are no matching records. `not_applicable` fields use their documented typed value instead.

Every field also exposes `exportVerification.csvKeys`, `verification`, and `note`. Keys are actual CSV headers. `requires_source` means exported values alone cannot establish the complete predicate; check the applied query and source data.

## Company signals and export mappings

These keys are available only after the current environment's live-index audit succeeds. Check capabilities before sending them. People Search reads the employer's `organization` fields; Company Search reads the Company index root.

| Filter key | Value | Search types | Export key (People / Company) | Elasticsearch source (Company root) |
| --- | --- | --- | --- | --- |
| `account.hascio` | `[true]` or `[false]` | People, Company | `companyHasCio` / `hasCio` | `hasCio` |
| `account.hasciso` | `[true]` or `[false]` | People, Company | `companyHasCiso` / `hasCiso` | `hasCiso` |
| `account.locationcount` | `{ "min": 1, "max": 10 }` | People, Company | `companyLocationCount` / `locationCount` | `locationCount` |
| `account.organictraffic` | `{ "min": 0, "max": 10000 }` | People, Company | `companyOrganicTraffic` / `organicTraffic` | `monthlyOrganicTraffic` |
| `account.paidtraffic` | `{ "min": 0, "max": 10000 }` | People, Company | `companyPaidTraffic` / `paidTraffic` | `monthlyPaidTraffic` |
| `account.sic` | `["OPTION_ID"]` from option lookup | People, Company | `companySicCodes` / `sicCodes` | `sicCodes` |
| `account.legaltype` | `["OPTION_ID"]` from option lookup | People, Company | `companyLegalType` / `legalType` | `legalType` |
| `account.websiteforsale` | `[true]` or `[false]` | People, Company | `companyWebsiteForSale` / `websiteForSale` | `websiteForSale` |
| `account.websiteworking` | `[true]` or `[false]` | Company | ? / `websiteWorking` | `isWebsiteWorking` |
| `account.linkedinfollowers` | `{ "min": 100 }` | Company | ? / `linkedinFollowers` | `linkedinFollowers` |
| `account.uksic` | `["OPTION_ID"]` from option lookup | Company | ? / `ukSicCodes` | `ukSicCodes` |

All numeric signal bounds use nonnegative whole numbers and inclusive endpoints; either endpoint may be omitted. Zero is valid. For these new boolean flags, `false` requires an explicitly stored false value; missing values do not match. CIO/CISO flags describe the company. Codes are strings: preserve leading zeros. Request `filter-options` for SIC, UK SIC and legal-structure values, without a query to browse, then follow its pagination metadata until complete. Use returned values rather than copying an illustrative code above.

```json
{
  "searchType": "company",
  "filters": {
    "account.hasciso": [true],
    "account.locationcount": { "min": 2 },
    "account.organictraffic": { "min": 1000 }
  },
  "excludedFilters": { "account.websiteforsale": [true] },
  "page": 0,
  "size": 25
}
```

For SIC, UK SIC and legal structure, replace `OPTION_ID` with an exact `options[].id` returned by `filter-options`. Some upstream UK SIC and legal-structure labels contain a JSON-encoded list, such as `["58190"]`. Submit the complete returned label unchanged if using labels; do not extract an individual code from it. Using option IDs avoids nested JSON escaping. The CSV `sicCodes` and `ukSicCodes` list columns decode those stored lists into readable codes.

The same JSON filter objects apply to the MCP search tool. Record freshness (`updatedAt`) is not a supported filter.

App Rating and App Reviews ranges match when either iOS or Google Play satisfies the bounds. Export both platform-specific columns to inspect the matching value. Generic app columns prefer the first available iOS value; see [app-store export metrics](/developers/api-docs/exports#app-store-metrics) for keys and mappings.

## Value rules

| Filter kind | Send in | Shape | Notes |
| --- | --- | --- | --- |
| Catalog or exact values | `filters` | Array of strings | Use an exact current `options[].label`; `options[].id` remains accepted. |
| Free text | `textFilters` | String | Send short terms, not a full prompt. `contact.fullName` uses all-word matching, not exact-name matching. |
| Numeric range | `filters` | `{ "min": 1, "max": 100 }` | Use the field's units. Employee count also accepts an array of ranges, which are ORed. |
| Date range | `filters` | `{ "min": "2024-01-01", "max": "2026-01-01" }` | Use ISO calendar dates; numeric date bounds are invalid. |
| Boolean or presence | `filters` | `["true"]` or `["false"]` | JSON booleans also work. Never send a generic example label. |
| Department metric | `filters` | `[{ "function": "OPTION_ID", "min": 1, "max": 10 }]` | Replace OPTION_ID with a discovered dimension; a bare range object is invalid. |
| Exclusion | `excludedFilters` | Field's normal value shape | Use the same key and value rules as the included filter. |

Exact domain and LinkedIn filters accept up to 10,000 normalized values per request. Other include and exclude limits come from the live capabilities contract. `lookalikeDomains` is available only for company searches; use `account.domain` to target people at known domains. Typed fields such as domains, LinkedIn URLs, websites, and phones do not need catalog discovery.

Role durations use **months**, founding and education boundaries use **years**, monetary ranges use **USD**, and company headcount growth uses **percent**. Growth accepts a scalar range object, not department metric rows. Read each contract's `units` and `exampleValue` before constructing a request. Current job titles accept arbitrary title text, such as `["QA Engineer"]`; suggestions do not restrict that field unless the account contract explicitly restricts it.

The legacy email status option has ID `VALID` and label `Valid`; both are accepted. Use current option discovery for catalog-backed values. A field may be unavailable to your account even if it appears in a historical integration.

## Option pagination

Request up to 100 options per call. When `hasMore` is true, send `nextCursor` as `cursor` with the same `searchType`, `field`, and `query`. A cursor belongs to that lookup and must not be reused for another field or query.

Typeahead fields such as Skills and Education Degree require a query of at least two characters. Continue when `hasMore` is true even if `options` is empty. Skills lookup scans up to five underlying document pages per call; a sparse page can still have a valid next cursor. Stop when `hasMore` is false, or report a bounded lookup as incomplete if your client stops earlier.

For `account.metric.employee` and `account.openroles`, call `filter-options` for that exact field to discover supported dimensions. Send the returned ID or label as `function`, for example `[{ "function": "sales", "min": 1, "max": 10 }]` when Sales is returned. Employee Count and Open Roles have different dimension vocabularies. Discovery describes supported inputs, not guaranteed matching records.

If `unavailable` is true, discovery could not safely serve that catalog. Do not interpret its empty options as zero matching prospects or invent values. Retry later or contact support. An ordinary empty result with `unavailable` false and `hasMore` false means that lookup query found no suggestions. For ambiguous locations, use the option's identity metadata as described in [search requests](/developers/api-docs/search#location-identities).

```json
{
  "searchType": "people",
  "field": "account.industry",
  "query": "software",
  "limit": 100,
  "cursor": "NEXT_CURSOR_FROM_PREVIOUS_RESPONSE"
}
```

## Quick values

These bounded catalogs are convenient copy and paste starting points. For current values and larger catalogs, use the live reference below.

| Field | Readable values |
| --- | --- |
| `contact.seniority` | C-Team, Director, Manager, Other, Staff, VP |
| `contact.departmentAndFunction` | Advertising & Marketing; Art, Culture and Creative Professionals; Construction; Customer/Client Service; Education; Engineering; Finance & Accounting; General Business & Management; Healthcare & Human Services; Human Resources; Information Technology; Legal; Manufacturing & Production; Operations; Other; Public Administration & Safety; Purchasing; Research & Development; Sales & Business Development; Science; Supply Chain & Logistics; Writing/Editing |
| `contact.emailStatus` | Valid |
| `contact.hasCellphone` | `true`, `false` |
| `account.funding.lastType` | Angel Round; Convertible Note; Corporate Round; Debt Financing; Equity Crowdfunding; Funding Round; Grant; Initial Coin Offering; Non Equity Assistance; Post-IPO Debt; Post-IPO Equity; Post-IPO Secondary; Pre Seed Round; Private Equity Round; Product Crowdfunding; Secondary Market; Seed Round; Series A; Series B; Series C; Series D; Series E; Series F; Series G; Series H; Series I; Series J; Venture Round |

## Complete filter reference

The table below is included in the page HTML from the public capability snapshot taken at documentation build time. Search by field name or rule, switch between people and company, and open a field for its value contract, limits, and example. An API key loads your account's current exact contract and allows catalog value lookup. Agents can download the [full guide](/llms-full.txt) or [JSON input contract](/developers/api-docs/agent-contract.json).



---

## Endpoint

`POST https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/people-search`

Despite its name, this endpoint accepts both `"people"` and `"company"` in `searchType`. Company search is controlled by account configuration. Check [capabilities](/developers/api-docs/capabilities) for enabled types.

## Request body

| Field | Type | Purpose |
| --- | --- | --- |
| `searchType` | string | `people` or `company`; defaults to `people`. |
| `filters` | object | Structured inclusion filters: arrays, enums, ranges, and metrics. |
| `excludedFilters` | object | Values to remove, using the same field keys as `filters`. |
| `textFilters` | object | Plain string text values such as `contact.keyword`. |
| `filterRules` | object | Optional matching rules, including match-all and search mode. |
| `locationIdentities` | object | Structured location identities keyed by filter field and selected label, then `kind`, `city`, `state`, and `country`. Send the same identities through REST and MCP to distinguish cities from states. |
| `page` | number | Zero-indexed page; defaults to 0. |
| `size` | number | Results per page; permitted size comes from capabilities. |
| `sortBy`, `sortOrder` | string | Sort field and `asc` or `desc`. |
| `search_after` | array | Cursor from the prior response for deep pagination. |
| `list_filters` | array | Include or exclude lists by owned list ID. |
| `listId` | string | Legacy alias for one included application list. |
| `record_summary` | object | Saved-record scope with `enabled`, `savedListIds`, and `matchMode` (`any` or `all`). |
| `savedOnly`, `netNewOnly` | boolean | Limit to saved or net-new records; mutually exclusive. |

`lookalikeDomains` applies to company search only. To find people at known domains, use `account.domain`.

Included `list_filters` are ANDed; excluded lists are removed. List ownership and active lookup versions are checked by the server. `record_summary` affects results only with `savedOnly` or `netNewOnly`; omit it to use the account-wide saved set. With `matchMode: "any"`, net-new excludes the union of selected lists; with `"all"`, it excludes records in every selected list. Unrelated unknown extension fields remain ignored and appear in `meta.requestWarnings`. Known filter-bearing typos such as `filter` instead of `filters`, malformed supplied containers, string booleans, invalid sorts, and malformed cursors return `400` before billable work. REST uses `searchType`; MCP uses `search_type`. Filter access and allowed values are enforced by the authenticated capability contract.

## All, Saved only, or Exclude saved

These are account-owned **record scopes**, separate from ordinary inclusion/exclusion filters. They work for both `searchType: "people"` and `searchType: "company"`. People searches use Saved Contacts; Company searches use Saved Companies. Saving a person does not save or exclude their employer company.

| Scope | REST search body | MCP `search_prospects` arguments |
| --- | --- | --- |
| All matching records | Omit both scope flags, or set both to `false` | Omit both scope flags, or set both to `false` |
| Exclude saved / Net New | `"netNewOnly": true` | `"net_new_only": true` |
| Saved only | `"savedOnly": true` | `"saved_only": true` |

Never set both flags to `true`. Use JSON booleans, not strings. Omit `record_summary` to use all saved records for the authenticated account and matching search type. A selected-list summary changes which saved set is used; it does not replace the scope flag.

Read authenticated capabilities `search.recordScopesBySearchType` for enabled scopes and `search.recordScopeParameters` for exact REST/MCP field names. An empty scope list means that search type is unavailable. People Saved/Net New scopes may be disabled by account configuration; handle the returned error rather than retrying without the restriction.

For example, find new companies in the United States:

```json
{
  "searchType": "company",
  "filters": { "account.location": ["United States"] },
  "netNewOnly": true,
  "size": 3
}
```

Use `"searchType": "people"` with the same flag to exclude saved contacts. To search only saved records, replace `netNewOnly` with `savedOnly`. Pass the returned `search_id` to export creation: its saved/net-new scope is retained. Searching alone never adds records to Saved; choose `saveContacts` when creating the export. See [saving exported records](/developers/api-docs/exports#save-or-do-not-save-exported-records).

## Matching follows the UI

Rules apply to values **within one filter**, rather than globally to the entire search. Normal multi-select filters default to ANY: selecting United States and United Kingdom accepts either country. ALL requires both selections to match the record's indexed values and may return no results for a single-valued field. Distinct filter fields still constrain the same search together.

Omit a rule to inherit that filter's current UI/catalog default. Some configured filters default to ALL; read `matching.defaultCondition` and `ruleSchema` in capabilities. Explicit `false` overrides an ALL default and survives export/history reruns. Where the UI supports this choice, send:

```json
{
  "searchType": "company",
  "filters": { "account.location": ["United States", "United Kingdom"] },
  "filterRules": { "account.location": { "matchAll": false } },
  "size": 3
}
```

Use boolean `true` for ALL or boolean `false` for ANY. The text `"true"` is invalid. The compatibility alias `condition` accepts `"any"` or `"all"`; omit it when using `matchAll`, or ensure both agree. Supported text modes are `SMART`, `WORD`, and `STRICT`; source arrays and metric row shapes are documented per field. Unknown nested rule properties are rejected rather than silently ignored.

Explicit `sortBy` accepts `name`, `title`, `contact.fullName`, `contact.experience.latest.title`, `organization.name.raw`, `organization.employeesOnLinkedin`, `organization.foundedYear`, `organization.revenueMin`, or `organization.revenueMax`. Use only fields meaningful to the chosen index. `sortOrder` accepts `asc` or `desc`. The response cursor has two elements (the selected sort value and `_shard_doc`); send it unchanged with the same query, scope, size, and sort. An invalid cursor returns an error instead of restarting the first page. Do not send conflicting camelCase/snake_case aliases.

## Example

```bash
curl -X POST "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/people-search" \
  -H "Content-Type: application/json" \
  -H "x-searchleads-api-key: sl_live_your_full_api_key_here" \
  -d '{
    "searchType": "people",
    "filters": {
      "account.industry": ["Software Development"],
      "account.employeeSize": { "min": 50, "max": 500 },
      "contact.seniority": ["C-Team"]
    },
    "excludedFilters": { "account.location": ["India"] },
    "textFilters": { "contact.keyword": "outbound sales" },
    "page": 0,
    "size": 25
  }'
```

Use [filter discovery](/developers/api-docs/filters) to verify available fields and readable values for your account before sending them.

`meta.chargedCredits` and `meta.chargedCreditKind` identify the actual debit and credit pool. API People responses also quote `meta.apiProspectCostPerResult`; Company responses quote `meta.companySearchCostPerResult`. These search charges round the returned-row charge up to a whole credit; search pricing is separate from fractional CSV export pricing. A zero-row response has no returned-row charge. Read the actual response and account policy rather than assuming an example price.

`C-Team` is a current seniority value; `Founder` is not. To target founders specifically, send `"contact.experience.latest.title": ["Founder"]` in `filters`. Current job-title text accepts custom values without a catalog ID unless your account contract explicitly restricts that field.

## Matching rules

Key `filterRules` by the same field used in the request. Values within a filter are normally ORed; separate fields are ANDed. `matchAll: true` or `condition: "all"` requires all values within that field. An exclusion bucket removes matching records; `exclude: true` on a field rule also excludes that field's values.

Text matching supports `SMART` (default), `WORD`, and `STRICT`. These modes control text-query matching; they do not turn Contact Name into an exact identity lookup. The contract's `ruleSchema` lists relevant rules and keyword-source enums for each field.

```json
{
  "searchType": "people",
  "textFilters": { "account.keyword": "software" },
  "filterRules": {
    "account.keyword": { "mode": "SMART", "sources": ["NAME", "DESCRIPTION"] }
  },
  "size": 1
}
```

The rule shape is `{ "matchAll": boolean, "condition": "any" | "all", "exclude": boolean, "mode": "SMART" | "WORD" | "STRICT" }`. Keyword fields additionally accept `sources`, `includeSources`, and `excludeSources` as arrays of exact source IDs in `ruleSchema`. Avoid source IDs from a different field.

Metric filters accept rows such as `[{ "function": "DIMENSION_FROM_LOOKUP", "min": 1, "max": 10 }]`; select the dimension with `filter-options` first. Headcount Growth is a direct percentage range, not a department metric. Legacy `metricRows` rules can carry `functions: string[]`, `start`, `end`, `timeFrame`, and `exclude`; new clients should use explicit structured rows and the live value contract.

## Location identities

People Search's `account.location` means **company headquarters**, while `contact.location` means the person's location. Standalone Company Search retains its own location contract. A contact outside the US can correctly match a US headquarters filter.

Disambiguate city, state, and country names using `locationIdentities`. Key it by the exact filter field, then by the selected label. This selects the US state of Georgia, rather than the country:

```json
{
  "searchType": "people",
  "filters": { "contact.location": ["Georgia"] },
  "locationIdentities": {
    "contact.location": {
      "Georgia": { "kind": "state", "state": "Georgia", "country": "United States" }
    }
  },
  "size": 1
}
```

Use `kind: "city"` with `city`, `state`, and `country`, or `kind: "country"` with `country` for the other identity types. Preserve these identities in REST and MCP requests.

## Response and pagination

```json
{
  "results": {
    "totalElements": 18432,
    "recordCounts": {
      "totalRecords": 18432,
      "savedRecords": 213,
      "netNewRecords": 18219,
      "savedRecordScope": "query"
    },
    "content": [{
      "id": "abc123",
      "firstName": "Sarah",
      "lastName": "Chen",
      "name": "Sarah Chen",
      "title": "CEO",
      "linkedinUrl": "https://linkedin.com/in/sarahchen",
      "organization": { "name": "Example Company", "industry": "Business Services", "employeeCount": 120 }
    }],
    "results": ["Deprecated version 1 duplicate of content"]
  },
  "search_id": "9e9013ff-b8af-4f85-b4dc-3e0c995da0c1",
  "search_id_expires_at": "2026-04-22T09:15:00.000Z",
  "rate_limits": {
    "per_minute": { "limit": 60, "remaining": 59 },
    "per_day": { "limit": null, "current": null, "remaining": null, "unlimited": true }
  },
  "meta": { "responseVersion": 1, "page": 0, "size": 25, "searchId": "9e9013ff-b8af-4f85-b4dc-3e0c995da0c1" }
}
```

Start with `page: 0`, increment the page until `page * size >= totalElements`, and use `search_after` for deep pagination beyond the Elasticsearch 10,000-result offset window. Each page counts toward rate limits. People search billing is based on returned prospects; it does not create an export job. Keep the returned `search_id` if you will [create an export](/developers/api-docs/exports).

The response returns the next cursor as top-level `next_search_after`. Send that array unchanged as `search_after`, keep the same filters, scope, size, and sort, and omit an advancing `page`. Stop when the cursor is null or content is empty. Treat cursors as opaque arrays; do not construct them from a displayed record ID.

```json
{
  "searchType": "people",
  "filters": { "account.domain": ["example.com"] },
  "size": 25,
  "search_after": [12.5, 47263732265]
}
```

These numbers illustrate the shape; use the real prior response's `next_search_after`. Check `meta.appliedFilterFields` and `meta.skippedFilters` before accepting an audience: HTTP 200 alone does not prove every condition was applied. Validation failures can return top-level `skipped_filters`.

The default response version is 1. The capabilities response lists supported versions and the `X-SearchLeads-Response-Version` header used to request another version; version 2's result path is `results.content`.

## JavaScript

```js
const response = await fetch("https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/people-search", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-searchleads-api-key": process.env.SEARCHLEADS_API_KEY,
  },
  body: JSON.stringify({
    searchType: "people",
    filters: { "account.industry": ["Software Development"] },
    textFilters: { "contact.keyword": "developer tools" },
    excludedFilters: { "account.location": ["India"] },
    page: 0,
    size: 25,
  }),
});
if (response.status === 429) throw new Error(`Retry after ${response.headers.get("Retry-After")} seconds`);
if (!response.ok) throw new Error(`Search failed: ${response.status}`);
const data = await response.json();
console.log(data.results.totalElements, data.results.content);
```

## Python

```python
import os
import time
import requests

url = "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/people-search"
body = {
    "searchType": "people",
    "filters": {"account.industry": ["Software Development"]},
    "page": 0,
    "size": 25,
}
headers = {"x-searchleads-api-key": os.environ["SEARCHLEADS_API_KEY"]}
while True:
    response = requests.post(url, json=body, headers=headers)
    if response.status_code != 429:
        response.raise_for_status()
        break
    time.sleep(int(response.headers.get("Retry-After", "60")))
data = response.json()
print(data["results"]["totalElements"])
```

For matching results across UI, REST, and MCP, use the same environment, account, dataset, record scope, filters (including location identities), and sort. The UI preserves server ranking by default; clicking a column sorts the loaded preview only.

### Company location in results

Company Location can match a company's primary address or headquarters. For supported included location filters, Company results add `searchLocation` with `city`, `state`, `country`, `source`, and `matched`. The Company UI and geographic CSV columns use this same address tuple. Original source addresses remain available in the API response.

`matched: true` identifies an address that satisfied a complete selected location alternative. If multiple addresses match, the primary address is preferred. With ALL, different selected locations may be satisfied by different addresses; one displayed tuple cannot show every matching address. Historical structured queries can also match components across different addresses. When no single address satisfies a complete alternative, `matched: false` identifies one coherent fallback address, with missing components left blank. Exclusion-only searches and unsupported historical query shapes retain their existing presentation.

Legal Structure catalog values can contain serialized arrays representing combined structures. The UI displays these readably, but requests must still send the exact option ID or original label returned by filter-options. Do not split a combined catalog entry into invented independent values.

API and MCP prospect searches are billed according to the account's current pricing and can debit the export-credit pool. Read `meta.chargedCredits` and `meta.chargedCreditKind` to identify the charge and pool; the name `chargedSearchCredits` does not by itself identify a separate wallet. Export-file charges are accounted for separately. Repeating a search to inspect records can therefore incur its own search charge.

Experience Duration (`contact.experience.latest.duration`) is expressed in months relative to the date a new search runs. Re-running the same 0–84 month filter on a later day moves its underlying job-start-date window accordingly. Exporting an existing `search_id` uses its pinned execution snapshot instead of recalculating that window.


---


## Preview before creating an export

Optional: POST `api-export-preflight` or call MCP `preview_export` with the same export intent. Requires `export` scope (hosted MCP also requires `mcp`). Preview is available for both People and Company search IDs.

```bash
curl -X POST "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/api-export-preflight" \
  -H "Content-Type: application/json" \
  -H "x-searchleads-api-key: sl_live_your_full_api_key_here" \
  -d '{"search_id":"SEARCH_ID_FROM_SEARCH_RESPONSE","requested_leads":3,"format":"csv","fields":["name","workEmail"],"saveContacts":true}'
```

Allowed JSON keys: `search_id` (required owned, unexpired successful search UUID), `requested_leads` (positive integer), `format` (`csv` only), `fields` (array of column keys), and `saveContacts` (JSON boolean). Omitted row count uses the smaller of the account limit and search snapshot count. Omitted columns use the safe-core default without email. Saving uses the current completed-export default; preview itself never saves records. Company requests must use Company column keys, for example `name` and `country`.

A valid preview returns HTTP 200 with `can_export`, `blockers` (`code` and `message`), `requested_leads`, `max_exportable_rows`, `fields` (normalized keys and readable labels), `saving`, `credits`, `limits` and `delivery`. Check `can_export` and resolve blockers before calling export creation. The server never silently reduces an explicitly requested row count.

- `availability.rows_at_search` is the **search-time snapshot**, not a fresh live count. `as_of`, `snapshot_age_seconds` and `expires_at` show its age/expiry. `count_exact: true` means exact at search time; `false` means a lower bound; `null` means historical exactness is unknown. An approximate count does not prove the full audience size.
- `credits.maximum_required_hold` is the maximum credit hold calculated with current prices and selected paid fields. `credits.spendable` and `credits.sufficient` describe the current spendable balance. Final charges depend on delivered email/phone data and existing entitlements; the maximum hold is not a promised final charge.
- `credits.charged` and `credits.reserved` are zero. Preview creates no search session, export job, provider request, file or saved membership. Saving adds no separate surcharge.
- Preview reserves neither credits nor records. Prices, balance, membership, limits and readiness may change; `start_export` / `api-export-create` always revalidate and may reject a previously ready preview. Preview is optional and is not a reservation token.
- Preview uses **one shared per-minute request slot** across REST/MCP, has no daily cap, and returns the normal rate-limit headers in REST. Export creation and status remain unlimited by those customer request quotas. MCP uses `result.isError` for HTTP failures; HTTP 200 with `can_export: false` is a readable blocked preview, not a transport error.

Readiness blockers include `insufficient_export_credits`, `export_size_exceeded`, `export_size_exceeds_search_total`, `search_total_zero`, `max_concurrent_jobs_reached`, payment review, and unavailable delivery. Invalid/unsupported fields return 400; invalid typed values or format return 422; missing access returns 401/403; foreign/unknown search IDs return 404; expired IDs return 410; missing successful snapshots return 409; quota exhaustion returns 429; failed dependency reads return 503. Retry 429/503 with backoff; rerun a paid search only when a new search ID is intentionally needed.

The asynchronous export API uses a `search_id` returned by [people or company search](/developers/api-docs/search). It runs from page 0 of the saved canonical query. New searches also pin their server sort, so a limited export follows the search order. Existing snapshots without a pinned sort retain their original traversal. Create a job, then poll its status. Your client does not need to send a provider callback.

```bash
curl -X POST "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/api-export-create" \
  -H "Content-Type: application/json" \
  -H "x-searchleads-api-key: sl_live_your_full_api_key_here" \
  -H "Idempotency-Key: my-export-2026-10-06" \
  -d '{
    "search_id": "SEARCH_ID_FROM_SEARCH_RESPONSE",
    "requested_leads": 5000,
    "format": "csv",
    "fields": ["name", "title", "workEmail"],
    "delivery_email": "ops@yourcompany.com"
  }'

curl -X GET "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/api-export-status?job_id=JOB_ID" \
  -H "x-searchleads-api-key: sl_live_your_full_api_key_here"
```

You can provide an `Idempotency-Key` header or `idempotency_key` body field. If omitted, SearchLeads generates and returns one. Status polling is read-only.

Choose `requested_leads` between 1 and the smaller of your account's maximum and the saved search response's `results.totalElements`. Use the total, not `results.content.length`, which is only the current page. Do not create an export when the search is empty. A reported lower-bound or approximate total does not establish the entire audience size; the saved snapshot count is the exportable limit for that `search_id`.

The 5,000-row example above assumes at least 5,000 available records. An oversized request returns REST HTTP `422` with `code: "export_size_exceeds_search_total"` and `available_records`; MCP returns the same payload with `result.isError: true`. This refusal does not create an export job or hold additional export credits. For example, if `available_records` is 1, create a new intentional one-row request with a fresh idempotency key. Keep the original key and identical body when retrying an unchanged request after a timeout.

Choose `fields` explicitly. Omitting it uses a smaller safe-core API default that does not include email. Check [capabilities](/developers/api-docs/capabilities) for supported column keys, current maximum rows, job limits, and formats. Export credit cost depends on selected data and account configuration.

### Save or do not save exported records

REST export creation and MCP `start_export` both accept `saveContacts` as a JSON boolean. It applies to both People and Company exports despite the parameter's name.

| Value | People export | Company export |
| --- | --- | --- |
| `true` | Add completed exported people to this account's Saved Contacts | Add completed exported companies to this account's Saved Companies |
| `false` | Leave existing saved membership unchanged | Leave existing saved membership unchanged |
| Omitted | Use the configured People save default | Use the configured Company save default |

Check authenticated capabilities `exports.saveRecordsBySearchType.people` or `.company` for `enabled`, `default`, and the parameter name. If saving is disabled, the current service uses `false` even when `true` was requested; do not promise that those records were saved. Set an explicit boolean whenever your workflow needs a particular choice. `false` does not remove previously saved records.

```json
{
  "search_id": "REPLACE_WITH_RETURNED_SEARCH_ID",
  "requested_leads": 1,
  "fields": ["name", "linkedin"],
  "format": "csv",
  "saveContacts": true,
  "idempotency_key": "REPLACE_WITH_ONE_KEY_FOR_THIS_EXPORT_INTENT"
}
```

The saved search determines People versus Company and preserves any Saved-only or Net-New scope. Saving occurs as export records are completed/committed, rather than when the search runs. Wait for completion and saved-membership synchronization before expecting the records to disappear from a fresh Net New search. Saving does not alter an already-created search snapshot; run a new scoped search to observe the updated saved set. Previous exports are not backfilled. Keep the same body and key for an uncertain retry; intentionally changing the save choice creates a new export intent and requires a new key.

## Export behavior and pricing

- API clients make two kinds of calls: create a job, then poll status. Provider callbacks are internal server-to-server messages. Status polling is read-only.
- UI, API, and MCP use the same configured fractional-credit prices for equivalent exports. Company exports use the configured company price per delivered row; for example, at 0.1 credit per row, one row costs 0.1 and eleven rows cost 1.1. Credit calculations retain two decimal places instead of rounding each export up to a whole credit. Read your account's current pricing and available/held credits before exporting.
- The export begins at page 0 of the saved canonical search, even if the `search_id` came from a later search page. Use the ID before its `search_id_expires_at` time.
- A job holds the maximum selected-field charge, then settles based on delivered data. People rows with a valid Work Email use the account's export base cost plus its Work Email cost. A row with no requested paid contact data costs 0.5 credit when that policy is enabled. API and MCP exports have no separate channel surcharge.
- The account's saved default export template can override built-in Bulk Export selections. Explicit `fields` make integrations predictable.
- If a provider job is stuck before pickup, SearchLeads support can retry dispatch internally; clients do not need an extra callback or retry parameter.

The [capabilities endpoint](/developers/api-docs/capabilities) reports allowed formats, maximum requested leads, concurrent jobs, and explicit unlimited create/status request quotas. Create and status requests have no customer request quotas and do not consume the shared search allowance. Concurrent jobs, credits, ownership checks and maximum export size remain enforced.

## Available export columns

The live tables include every current People and Company column key (the exact CSV header), display label, group, kind, and built-in Bulk Export default. An API key loads your account's exact export permissions.

Legacy export integrations may accept additional historical column aliases. New integrations should use the current `exports.fieldsBySearchType` keys and must not infer additional fields from old CSV files.


## Additional People column mappings

| Export key | CSV value source | Export section |
| --- | --- | --- |
| `jobLocation` | `jobLocation.city`, `.state`, `.country`; never personal or HQ geography | Profile |
| `educationCompletionYear` | All `education.endYear` values | Experience |
| `emailLastVerifiedDate` | `emailLastVerifiedAt` | Contact |
| `contactMethodAvailable` | `isReachable` | Contact |
| `persona` | `persona` | Profile |
| `linkedinConnections` | `linkedinConnections` | Profile |
| `patents` | `patents` | Experience |
| `publications` | `publications` | Experience |
| `companyDescription` | `organization.about`, then legacy company description fields | Current company |

Company signal columns and their source fields are listed in [Filters and option discovery](/developers/api-docs/filters#company-signals-and-export-mappings). Their People equivalents use the `organization.` prefix and belong to Digital signals. Experience and Digital signals columns follow the account's enabled export-section switches. Request `exports.fieldsBySearchType` for the exact allowed set before creating an export. Boolean values export as `true`/`false`, zero remains `0`, absent values remain blank, and lists use ` | ` between values. Industry codes retain leading zeros in the CSV text; import those columns as text in spreadsheets.

Company `city`, `state`, and `country` keep their existing primary and legacy values and use the corresponding headquarters value when otherwise blank. Headquarters regions such as APAC are not substituted for a missing State. These fallbacks do not change People location columns or the search's location semantics.

Company keyword filters also search company descriptions. Select the optional `companyDescription` column in People exports to inspect that text. Missing descriptions remain blank. This field is available through the same UI, API and MCP column catalog and does not change existing export layouts.

### App-store metrics

App Rating and App Reviews filters can match either iOS or Google Play. The existing generic columns (`appRating`, `appReviews`, and their `company`-prefixed People equivalents) keep their first-available behavior: iOS is preferred, then Google Play, then legacy sources. A generic value may therefore fall outside your range when the other store matched.

Select `iosAppRating`, `googlePlayAppRating`, `iosAppReviews`, and `googlePlayAppReviews` for Company exports. People exports use `companyIosAppRating`, `companyGooglePlayAppRating`, `companyIosAppReviews`, and `companyGooglePlayAppReviews`. These map directly to `appStore.iosRating`, `appStore.playRating`, `appStore.iosReviews`, and `appStore.playReviews`, with `organization.` added for People. Missing platform values stay blank; zero remains `0`. Only selected columns are added, in your requested order.

## Job lifecycle and download

A successful create returns HTTP `202` with `job_id` and `status`. Poll `api-export-status?job_id=...` about every five seconds; polling more frequently does not make jobs complete faster. The status body includes `job_id`, `status`, `requested_leads`, `effective_leads`, `held_credits`, `final_credits_charged`, `refunded_credits`, `download_url`, `download_expires_at`, and `error_message`; some values remain null until completion.

| Status | Next step |
| --- | --- |
| `queued`, `processing` | Continue polling with a bounded timeout. |
| `completed` | GET the non-null `download_url` to retrieve the file, or use `google_sheet_url` for a Sheets export. |
| `failed`, `cancelled` | Stop polling and inspect `error_message`. Do not assume a usable file exists. |

CSV download URLs are signed and expire; the current in-house URL lifetime is five minutes. Poll status again for a fresh URL if it expires. Treat the URL as a bearer secret. If a create request times out, retry with the same `Idempotency-Key` and identical body to avoid duplicate jobs. If your polling timeout expires, retain the job ID and resume status polling later.

This Python example uses the standard library. Set `SEARCHLEADS_API_KEY`, `SEARCHLEADS_SEARCH_ID`, and `SEARCHLEADS_DELIVERY_EMAIL` in your environment. It assumes the saved search has at least two available records, creates a two-row CSV with explicitly selected, non-email columns, then downloads it after completion. For a one-result search, intentionally change the row count to 1 before creating the job. This is a real export and consumes credits according to your account policy. The API base below targets the current documentation environment.

```python
import json
import os
import time
import urllib.request
import uuid
from pathlib import Path

base = "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1"
key = os.environ["SEARCHLEADS_API_KEY"]
idempotency_key = str(uuid.uuid4())  # Persist and reuse if create is retried.

def request(path, payload=None, extra_headers=None):
    headers = {"x-searchleads-api-key": key, **(extra_headers or {})}
    data = None if payload is None else json.dumps(payload).encode()
    if data is not None:
        headers["Content-Type"] = "application/json"
    req = urllib.request.Request(base + path, data=data, headers=headers)
    with urllib.request.urlopen(req, timeout=30) as response:
        return json.load(response)

job = request("/api-export-create", {
    "search_id": os.environ["SEARCHLEADS_SEARCH_ID"],
    "requested_leads": 2,
    "format": "csv",
    "fields": ["name", "title"],
    "saveContacts": False,
    "delivery_email": os.environ["SEARCHLEADS_DELIVERY_EMAIL"],
}, {"Idempotency-Key": idempotency_key})
job_id = job["job_id"]
for _ in range(120):
    state = request("/api-export-status?job_id=" + job_id)
    if state["status"] == "completed":
        if not state.get("download_url"):
            raise RuntimeError("Completed job has no CSV download URL")
        with urllib.request.urlopen(state["download_url"], timeout=60) as file:
            Path("searchleads-export.csv").write_bytes(file.read())
        break
    if state["status"] in ("failed", "cancelled"):
        raise RuntimeError(state.get("error_message") or state["status"])
    time.sleep(5)
else:
    raise TimeoutError("Resume polling job " + job_id + " later")
```

The request `fields` entries and CSV headers use exact keys such as `companyHasCio`. Display labels such as `Company Has CIO` are for readability. Read each filter's `exportVerification` for related CSV keys and verification limitations.

For Company exports with a supported included Company Location filter, `location`, `city`, `state`, and `country` use the same selected primary or headquarters address as `searchLocation` in search results. A headquarters match therefore exports headquarters geography even if the main address is in another country. Missing components of that address remain blank; components from different offices are not combined. A CSV shows one address, so ALL across separate locations cannot be fully verified from that tuple alone. Previously generated files are not rewritten.

In the UI, **Re-run search** restores search criteria. **Repeat export** restores stored columns, column order, row count and save choice, then opens a review dialog after the search succeeds. It does not submit an export automatically. Current availability, credits and enabled columns are checked again. Older exports without complete stored settings cannot restore those settings; rerun their search and choose new export settings instead.


---

These endpoints require the `search` key scope. Their MCP equivalents additionally require `mcp`. They use the shared rolling minute allowance and return `X-RateLimit-*` headers; a blocked request returns 429 and `Retry-After`. There is no daily request quota.

Creating definitions or links does not charge credits or save contacts/companies. **Search requests remain unchanged.** Completed exports use the configured save-by-default policy; explicitly pass `saveContacts: false` to opt out. Saving adds no separate surcharge; normal export/data charges still apply.

## Save a successful search

`POST /functions/v1/api-saved-searches`

```json
{ "name": "US founders", "search_id": "SEARCH_UUID_FROM_A_SUCCESSFUL_SEARCH" }
```

`name` is a nonblank string of 1–120 characters after trimming. `search_id` must be an owned, unexpired UUID from a successful People or Company search. The server preserves filters, exclusions, text, matching rules, structured locations and All/Saved/Net New scope. It returns `saved_search_id`, `search_type`, `definition`, `url`, `created`, and `credits_charged: 0`. The search appears in the UI's Saved Searches.

Retrying the same owner/name/definition returns the same saved search with `created: false`. A different definition under an existing name returns 409 `saved_search_name_conflict`; choose a new name. A saved definition does not expire with its source search session. Rerunning evaluates current data and relative dates, with normal search permissions and credits. It does not replay an immutable export snapshot.

## Create a share link

`POST /functions/v1/api-search-share-links`

```json
{ "saved_search_id": "SAVED_SEARCH_UUID", "expires_in_days": 7 }
```

Send exactly one of `saved_search_id` or `search_id`. `expires_in_days` is an optional JSON integer from 1 to 30; default 7. The response contains `share_link_id`, `share_url`, `search_type`, `expires_at`, `requires_sign_in: true`, and `credits_charged: 0`.

Each successful create makes an independent link. Retain the returned link and ID; a transport retry may create another link. Tokens are stored only as hashes and cannot be recovered by listing. Links contain filters, not exported rows, API keys, or the creator's saved-record membership. Rule-level numeric bounds are not reusable in the UI: send the range as a structured value in `filters` and run search again before saving or sharing. Private lists and private bulk-reference definitions are rejected with 422 `search_definition_not_reusable`.

Recipients must sign in. Opening the link loads and runs the criteria using the recipient's own permissions and normal search credits. Saved/Net New refers to the recipient's saved contacts or companies. Unsupported filters require review before execution; they are never silently removed from an automatically executed search. Sharing a link does not make a private saved-search record readable by another owner.

## Revoke a link

`DELETE /functions/v1/api-search-share-links`

```json
{ "share_link_id": "SHARE_LINK_UUID" }
```

Only the owner can revoke the link. Repeating revocation is safe. Expired or revoked links return 410 when opened. Revocation prevents future link resolution; it does not remove filters already loaded or copies a recipient has saved. It does not delete the owner's saved search.

## MCP tools

Use `create_saved_search`, `create_search_share_link`, and `revoke_search_share_link` with the same JSON arguments as their REST equivalents. Read `tools/list` for current schemas. Link creation requires exactly one source ID even though both properties are optional individually in the schema.

## Errors

| HTTP | Meaning | Recovery |
| --- | --- | --- |
| 400 | Invalid JSON | Send a JSON object. |
| 401 / 403 | Invalid credentials, missing scope, or disabled API channel | Check key scopes and account capabilities. |
| 404 | Source or link missing, or owned by someone else | Use an ID from your own account. |
| 409 | Duplicate name with different criteria, or no successful snapshot | Choose a new name or run the search successfully. |
| 410 | Source search session expired | Run search again; existing saved definitions remain valid. |
| 422 | Invalid field/value, ambiguous source IDs, or unsupported definition | Correct the request; do not discard filters. |
| 429 | Shared minute allowance exhausted | Honor `Retry-After`. |
| 500 | Storage or service failure | Retry saving with the same name/definition. Avoid blind repeated link creation. |


---

Responses include rate limit headers so clients can throttle without guessing:

| Header | Meaning |
| --- | --- |
| `X-RateLimit-Limit` | Requests allowed in the current 60-second window. |
| `X-RateLimit-Remaining` | Requests left in the window. |
| `X-RateLimit-Reset` | Unix timestamp for the next retry on `429`; on success, an upper bound for expiry of the current rolling window. |
| `Retry-After` | Seconds to wait on a `429` response. |

On `429`, wait for `Retry-After` before retrying. For transient server errors, use exponential backoff with a cap. Treat authentication and validation errors as requests that need correction rather than immediate retries.

The allowance is a rolling 60-second window: requests leave it as they age out. `api-capabilities` reports the same minute snapshot in its body and headers. If an intermediary strips `Retry-After`, use the response body's positive `retryAfterSeconds`, falling back to 60 seconds when neither is available. Daily API request quota headers remain omitted.

Hosted MCP can carry a quota failure inside HTTP `200`. Check the JSON-RPC `error` and tool result `isError` before treating a response as successful; see [MCP retry handling](/developers/api-docs/mcp#rate-limits-and-retries).

| Status | Meaning | Action |
| --- | --- | --- |
| `400` | Bad request | Check required fields and the `error` string for invalid filter formats. |
| `401` | Unauthorized | Send a valid full API key in `x-searchleads-api-key`. |
| `403` | Forbidden | Check your plan, key scope, and filter or feature access. |
| `402` | Insufficient credits | Add credits or reduce the requested operation. |
| `422` | Unprocessable operation | Read `error`, `reason`, and any `skipped_filters`; correct unsupported fields, formats, or account constraints. |
| `429` | Rate limited | Wait for `Retry-After` before trying again. |
| `500` | Server error | Retry with exponential backoff, such as 1, 2, 4, then 8 seconds. |

Current limits vary by account and endpoint. Read [capabilities](/developers/api-docs/capabilities), including export-specific limits, before scheduling large jobs.

Malformed search requests return `400` with a `field` and an `issues` array of `{ "path": "...", "message": "..." }`. Invalid `page`, `size`, and `searchType` retain their established codes: `invalid_page`, `invalid_page_size`, and `invalid_search_type`. Other malformed shapes use `invalid_search_request`. Correct the supplied path before retrying. For example, `filterRules.account.location.matchAll` must contain a boolean, not the text `"true"`. These failures occur before credit charging or search execution. MCP reports corresponding validation failures through JSON-RPC/tool error conventions; always inspect the result body.

Filter selection limits count normalized distinct values separately for inclusion and exclusion. REST and MCP use the same limits. Exceeding a normal selection limit returns HTTP `400` with `code: "filter_value_limit_exceeded"`, `field`, `bucket`, `limit`, and `received`. Exact domain/LinkedIn bulk-limit violations retain HTTP `413`. The server rejects the request before searching or charging returned-record credits; it does not silently truncate it. Correct the values or intentionally divide the operation before retrying.

API search and filter-option requests have **no daily request cap**. REST and hosted MCP share the account's rolling 60-second request allowance. Read `rateLimits.perMinute` from authenticated capabilities; `rateLimits.perDay` is `{ "limit": null, "current": null, "remaining": null, "unlimited": true }`. A null daily limit means unlimited, not zero. Daily quota headers are omitted for these API calls. Per-minute limits, credit billing, permissions, maximum page sizes, and export-job concurrency limits still apply. Export create and status requests have no per-minute, per-hour or per-day request quotas and do not consume the shared search allowance, including through MCP. Unlimited daily requests do not mean unlimited requests per second or free returned records.


---

The hosted Streamable HTTP MCP endpoint exposes account capabilities, filter discovery, search, export, prompts, and authenticated resources. Authenticate with the same full API key used for REST calls.

Enable `mcp` to connect, plus `search` for search/filter-value lookup and `export` for creating or checking exports. An MCP-only key can connect and read capabilities but cannot perform those searches or exports. Read [the scope matrix](/developers/api-docs/authentication) and the authenticated `keyCapabilities` response before selecting tools.

Search uses `search_type` in MCP and `searchType` in REST. Nested `filterRules` use the same field keys, JSON booleans, and effective per-filter defaults as the UI. `matchAll: false` means ANY; `matchAll: true` means ALL. Omit it to inherit the catalog default. The string `"true"` is rejected. See [matching rules](/developers/api-docs/search#matching-follows-the-ui).

```json
{
  "mcpServers": {
    "searchleads": {
      "type": "http",
      "url": "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/searchleads-mcp",
      "headers": {
        "x-searchleads-api-key": "sl_live_your_full_api_key_here"
      }
    }
  }
}
```

MCP clients vary in configuration syntax. Set the HTTP server URL and header using your client's format. The server supports tool discovery, `prompts/list`, `prompts/get`, `resources/list`, and `resources/read`. Agents can call `lookup_filter_options` for exact catalog values before searching.

| Type | Built-in names |
| --- | --- |
| Tools | `get_account_capabilities`, `list_filter_catalog`, `lookup_filter_options`, `search_prospects`, `preview_export`, `start_export`, `get_export_status`, `create_saved_search`, `create_search_share_link`, `revoke_search_share_link` |
| Prompts | `plan_filters`, `explain_search_results`, `draft_outreach_copy` |
| Resources | MCP overview, account capabilities, people filters, company filters |

Before `start_export`, optionally call `preview_export` with `search_id`, `requested_leads`, `fields`, `format`, and `saveContacts`. Inspect `can_export`, `blockers`, `availability.count_exact`, and `credits.maximum_required_hold`. Preview creates no file/job or credit hold and does not save records. It uses one shared request-minute slot; creation/status retain their unlimited customer quotas. A ready preview is not a reservation: creation revalidates the current account and search. See [export preflight](/developers/api-docs/exports#preview-before-creating-an-export).

Catalog-backed filters accept exact readable labels. Option IDs remain supported for existing integrations. Typed-input filters accept direct normalized values and report their mode in capabilities.

MCP tool arguments use `search_type` (for example, `{ "search_type": "people", "filters": { "account.location": ["United States"] }, "size": 1 }` for `search_prospects`). The corresponding REST search body uses `searchType`. Keep filter field paths, `textFilters`, `excludedFilters`, `filterRules`, and `locationIdentities` unchanged. Read each tool's `inputSchema` from `tools/list` before calling it. `start_export` uses a prior `search_id`, and `get_export_status` uses the returned `job_id`.

## Exclude saved contacts or companies, and save export results

Use `get_account_capabilities` first. `search.recordScopesBySearchType` lists enabled scopes; `exports.saveRecordsBySearchType` gives independent People/Company saving availability and defaults.

For `search_prospects`, choose `search_type: "people"` for contacts or `"company"` for companies. Both support:

| Choice | Tool argument |
| --- | --- |
| All matching records | Omit both scope flags |
| Exclude this account's saved records | `"net_new_only": true` |
| Only this account's saved records | `"saved_only": true` |

Do not enable both flags. Use real booleans. Omit `record_summary` to use the account-wide saved set for that search type. People and Company saved sets are separate.

Example `search_prospects` arguments for new companies:

```json
{
  "search_type": "company",
  "filters": { "account.location": ["United States"] },
  "net_new_only": true,
  "size": 3
}
```

Use the returned `search_id` in `start_export`. Add `"saveContacts": true` to save completed exported records, or `false` to leave existing saved membership unchanged. This parameter has the same camelCase spelling for REST and MCP, and saves either contacts or companies according to the search ID. Omitting it uses the corresponding configured default. Saving must be enabled; inspect the capability rather than assuming `true` will take effect. Search itself does not save records. See [export saving and synchronization](/developers/api-docs/exports#save-or-do-not-save-exported-records).

## Rate limits and retries

REST and MCP share the customer's rolling minute allowance across API keys. Protocol initialization, discovery, resources and locally handled tools also consume allowance; `notifications/initialized` does not. Forwarded search and option tools reserve once at the appropriate boundary. Daily API search/option requests remain unlimited. `start_export` and `get_export_status` have no customer request quotas and do not consume the shared minute allowance. Export-job concurrency, export size limits, permissions and credit billing still apply.

An MCP quota failure can use HTTP `200` with this JSON-RPC error. Read `error` before `result`; HTTP success alone does not mean the operation succeeded:

```json
{
  "jsonrpc": "2.0",
  "id": "quota-example",
  "error": {
    "code": -32029,
    "message": "Rate limit exceeded.",
    "data": { "httpStatus": 429, "retryAfterSeconds": 7, "limit": 60, "current": 60 }
  }
}
```

Forwarded tool failures instead use `result.isError: true`. For a quota failure, `result.structuredContent` contains `error`, `limits`, `usage` and `retryAfterSeconds`; `result.content` contains the same payload as JSON text. Inspect that payload before using search results or options. Other tool errors require correction and must not automatically be retried as quota failures.

This bounded JavaScript example accepts a `send` function that returns a decoded JSON-RPC response from your MCP transport. It retries only quota failures and preserves other error codes. SDKs that throw errors expose equivalent `code`/`data` fields; apply the same checks in your catch handler. An HTTP `429` at the transport layer uses `Retry-After` as described in [Rate limits and errors](/developers/api-docs/errors).

```javascript
async function callWithMcpBackoff(send) {
  for (let attempt = 0; attempt < 3; attempt++) {
    const reply = await send();
    const toolFailure = reply.result?.isError ? reply.result.structuredContent : null;
    const quota = reply.error?.code === -32029 ||
      Boolean(toolFailure?.limits && "retryAfterSeconds" in toolFailure);
    const failure = reply.error || (reply.result?.isError ? {
      code: quota ? -32029 : toolFailure?.code,
      message: toolFailure?.error || "MCP tool failed.",
      data: toolFailure,
    } : null);
    if (!failure) return reply.result;
    if (!quota || attempt === 2) {
      throw Object.assign(new Error(failure.message), { code: failure.code, data: failure.data });
    }
    const seconds = Number(failure.data?.retryAfterSeconds);
    const delay = Number.isFinite(seconds) && seconds > 0 ? seconds : 60;
    await new Promise(resolve => setTimeout(resolve, delay * 1000));
  }
}
```

Keep the original search/filter arguments on retry. For `start_export`, retain the same `idempotency_key` so a transport retry cannot create duplicate jobs. If the bounded retries are exhausted, surface the error and pause the workflow instead of retrying indefinitely.


See [saved searches and share links](/developers/api-docs/saved-searches) for named reusable definitions, signed-in sharing, expiry and owner-only revocation. These tools reserve the shared minute allowance once at their REST boundary. Searches do not automatically save records.


# Complete public input contract

{
  "schemaVersion": 1,
  "generatedAt": "2026-10-22T19:57:32.589Z",
  "environment": "staging",
  "baseUrl": "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1",
  "documentation": "https://dev.searchleads.co/developers/api-docs/",
  "authentication": {
    "header": "x-searchleads-api-key",
    "fullKeyRequired": true,
    "scopes": {
      "search": [
        "search"
      ],
      "filterOptions": [
        "search"
      ],
      "exports": [
        "export"
      ],
      "mcp": [
        "mcp"
      ]
    },
    "mcpToolScopes": {
      "get_account_capabilities": [
        "mcp"
      ],
      "list_filter_catalog": [
        "mcp"
      ],
      "lookup_filter_options": [
        "mcp",
        "search"
      ],
      "search_prospects": [
        "mcp",
        "search"
      ],
      "preview_export": [
        "mcp",
        "export"
      ],
      "start_export": [
        "mcp",
        "export"
      ],
      "get_export_status": [
        "mcp",
        "export"
      ],
      "create_saved_search": [
        "mcp",
        "search"
      ],
      "create_search_share_link": [
        "mcp",
        "search"
      ],
      "revoke_search_share_link": [
        "mcp",
        "search"
      ]
    },
    "keyCapabilityEndpoint": "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/api-capabilities",
    "note": "Account features and key scopes are separate. Check keyCapabilities.tools for the authenticated key; an MCP-only key can connect but cannot search or export."
  },
  "endpoints": {
    "capabilities": "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/api-capabilities",
    "publicCapabilities": "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/public-api-capabilities",
    "filterOptions": "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/filter-options",
    "search": "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/people-search",
    "exportPreflight": "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/api-export-preflight",
    "exportCreate": "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/api-export-create",
    "exportStatus": "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/api-export-status",
    "savedSearches": "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/api-saved-searches",
    "searchShareLinks": "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/api-search-share-links",
    "mcp": "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/searchleads-mcp"
  },
  "savedSearches": {
    "method": "POST",
    "requiredScope": "search",
    "required": [
      "name",
      "search_id"
    ],
    "nameMaxLength": 120,
    "source": "Owned unexpired successful search session",
    "retry": "Identical owner/name/definition returns the same saved search; different definition returns 409",
    "creditsCharged": 0,
    "preserves": [
      "filters",
      "excludedFilters",
      "textFilters",
      "filterRules",
      "locationIdentities",
      "recordScope"
    ],
    "rerun": "Current data, recipient permissions and normal search credits"
  },
  "searchShareLinks": {
    "createMethod": "POST",
    "revokeMethod": "DELETE",
    "source": "Exactly one of search_id or saved_search_id",
    "expiresInDays": {
      "default": 7,
      "minimum": 1,
      "maximum": 30
    },
    "revokeRequired": [
      "share_link_id"
    ],
    "requiresSignIn": true,
    "payload": "Criteria only; recipient uses their own Saved/Net New membership",
    "retry": "Every create makes an independent link; retain returned share_link_id and share_url",
    "unsupported": [
      "Private lists",
      "Private bulk-reference searches",
      "Rule-level numeric bounds: send the range in filters and run search again"
    ],
    "creditsCharged": 0
  },
  "optionDiscovery": {
    "maxOptions": 100,
    "minTypeaheadQueryCharacters": 2,
    "emptyPageMayHaveMore": true,
    "maxSourcePagesPerRequest": 5,
    "continuation": "When hasMore is true, continue with nextCursor even if options is empty. Keep searchType, field and query unchanged. An empty page does not prove the catalog or audience is empty.",
    "metricDimensions": "Discover account.metric.employee and account.openroles separately. Submit an exact returned ID or label as function; dimensions supported by one field may not be supported by the other."
  },
  "validation": {
    "invalidInputs": "Invalid supplied filter containers, nested matching rules, booleans, sort fields and cursors fail before work or credit charging. Unknown MCP arguments are rejected. REST rejects known filter-bearing typos; unrelated extension fields are ignored with meta.requestWarnings. Use actual JSON booleans, including nested filterRules matchAll.",
    "selectionLimits": {
      "code": "filter_value_limit_exceeded",
      "status": 400,
      "bulkStatus": 413,
      "countsNormalizedDistinctValues": true,
      "fields": [
        "field",
        "bucket",
        "limit",
        "received"
      ],
      "guidance": "Use the authenticated include/exclude limits. Split an over-limit operation intentionally; the server does not silently truncate selections."
    }
  },
  "workflow": [
    "Obtain a full API key with the required scopes.",
    "GET capabilities for the key owner before offering filters or search types.",
    "For catalog-backed inputs, POST filter-options; paginate hasMore/nextCursor and select an exact returned ID or label.",
    "If discovery returns unavailable=true, retry later or contact support; do not treat an unavailable catalog as an empty audience.",
    "POST people-search with a small size; check meta.appliedFilterFields and meta.skippedFilters before using the audience.",
    "Use the returned search_id to create an export, poll status, and GET download_url only after completed."
  ],
  "visibleSearchTypes": [
    "people",
    "company"
  ],
  "search": {
    "recordScopesBySearchType": {
      "people": [
        "all",
        "saved",
        "net_new"
      ],
      "company": [
        "all",
        "saved",
        "net_new"
      ]
    },
    "recordScopeParameters": {
      "rest": {
        "saved": "savedOnly",
        "net_new": "netNewOnly"
      },
      "mcp": {
        "saved": "saved_only",
        "net_new": "net_new_only"
      },
      "mutuallyExclusive": true,
      "defaultScope": "all"
    },
    "maxPageSize": 100,
    "responseVersions": [
      1,
      2
    ],
    "defaultResponseVersion": 1,
    "responseVersionHeader": "X-SearchLeads-Response-Version",
    "version2ResultsPath": "results.content",
    "requestBuckets": {
      "filters": "structured includes",
      "textFilters": "free-text includes",
      "excludedFilters": "exclusions using the field's normal value shape",
      "filterRules": "matching rules keyed by the same exact filter field",
      "locationIdentities": "identities keyed by field and selected label"
    },
    "cursor": {
      "requestField": "search_after",
      "responseField": "next_search_after",
      "stopWhenNull": true
    },
    "searchIdTtlMinutes": 1440
  },
  "rateLimits": {
    "perMinute": {
      "limit": 60
    },
    "perDay": {
      "limit": null,
      "unlimited": true
    }
  },
  "filtersBySearchType": {
    "people": [
      {
        "fieldPath": "contact.experience.latest.title",
        "title": "Job Title",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "free_text_values",
        "valueShape": "string[] of current job-title text",
        "units": null,
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send current job-title text. Suggestions are optional and do not restrict submitted titles.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": [
          "QA Engineer"
        ],
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": true
        },
        "exportVerification": {
          "csvKeys": [
            "title"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "mode": {
            "enum": [
              "SMART",
              "WORD",
              "STRICT"
            ],
            "default": "SMART"
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "contact.fullname",
        "title": "Contact Name",
        "searchType": "people",
        "sendIn": "textFilters",
        "acceptedValueTypeV2": "free_text_values",
        "valueShape": "string or string[] of concise values",
        "units": null,
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Custom values are allowed, but keep them short and directly tied to what this filter matches.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": "Sarah Chen",
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "name"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "mode": {
            "enum": [
              "SMART",
              "WORD",
              "STRICT"
            ],
            "default": "SMART"
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "contact.linkedin",
        "title": "LinkedIn URL",
        "searchType": "people",
        "sendIn": "textFilters",
        "acceptedValueTypeV2": "exact_domain_or_url_values",
        "valueShape": "string or string[] of exact domains or URLs",
        "units": null,
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send an exact domain, LinkedIn URL, or website URL. A valid request can return zero matches when the value is not in the dataset.",
        "includeLimit": 10000,
        "excludeLimit": 10000,
        "exampleValue": "https://www.linkedin.com/in/example",
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "linkedin"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "contact.location",
        "title": "Person Location",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": [
          "United States"
        ],
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "requires_query",
          "minimumQueryLength": 2,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "location",
            "city",
            "state",
            "country"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.keyword",
        "title": "Account Keywords",
        "searchType": "people",
        "sendIn": "textFilters",
        "acceptedValueTypeV2": "free_text_keyword_terms",
        "valueShape": "string or string[] of short keyword terms",
        "units": null,
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Custom values are allowed, but keep them concise buyer-side terms. Do not send full prompts or sentences.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": "outbound sales",
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "company",
            "companyDescription",
            "companyIndustry",
            "companyTechnologies",
            "companyKeywords"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "mode": {
            "enum": [
              "SMART",
              "WORD",
              "STRICT"
            ],
            "default": "SMART"
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          },
          "sources": {
            "type": "array",
            "items": {
              "enum": [
                "NAME",
                "DESCRIPTION",
                "SPECIALTIES",
                "INDUSTRY",
                "TECHNOLOGIES"
              ]
            }
          },
          "includeSources": {
            "type": "array",
            "items": {
              "enum": [
                "NAME",
                "DESCRIPTION",
                "SPECIALTIES",
                "INDUSTRY",
                "TECHNOLOGIES"
              ]
            }
          },
          "excludeSources": {
            "type": "array",
            "items": {
              "enum": [
                "NAME",
                "DESCRIPTION",
                "SPECIALTIES",
                "INDUSTRY",
                "TECHNOLOGIES"
              ]
            }
          }
        }
      },
      {
        "fieldPath": "contact.joblocation",
        "title": "Job Location",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": [
          "United States"
        ],
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "requires_query",
          "minimumQueryLength": 2,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "jobLocation"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "contact.seniority",
        "title": "Seniority",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "seniority"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "contact.departmentandfunction",
        "title": "Department",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "department"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "contact.company.current",
        "title": "Current Company",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "requires_query",
          "minimumQueryLength": 2,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "company",
            "companyDomain",
            "companyWebsite",
            "companyLinkedin"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "mode": {
            "enum": [
              "SMART",
              "WORD",
              "STRICT"
            ],
            "default": "SMART"
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "contact.keyword",
        "title": "Keywords",
        "searchType": "people",
        "sendIn": "textFilters",
        "acceptedValueTypeV2": "free_text_keyword_terms",
        "valueShape": "string or string[] of short keyword terms",
        "units": null,
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Custom values are allowed, but keep them concise buyer-side terms. Do not send full prompts or sentences.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": "outbound sales",
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "headline",
            "title",
            "skills",
            "certifications"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "mode": {
            "enum": [
              "SMART",
              "WORD",
              "STRICT"
            ],
            "default": "SMART"
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          },
          "sources": {
            "type": "array",
            "items": {
              "enum": [
                "TITLE",
                "JOB_DESCRIPTION",
                "HEADLINE",
                "ABOUT",
                "SKILLS",
                "CERTIFICATIONS",
                "LANGUAGES"
              ]
            }
          },
          "includeSources": {
            "type": "array",
            "items": {
              "enum": [
                "TITLE",
                "JOB_DESCRIPTION",
                "HEADLINE",
                "ABOUT",
                "SKILLS",
                "CERTIFICATIONS",
                "LANGUAGES"
              ]
            }
          },
          "excludeSources": {
            "type": "array",
            "items": {
              "enum": [
                "TITLE",
                "JOB_DESCRIPTION",
                "HEADLINE",
                "ABOUT",
                "SKILLS",
                "CERTIFICATIONS",
                "LANGUAGES"
              ]
            }
          }
        }
      },
      {
        "fieldPath": "contact.skill",
        "title": "Skills",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "requires_query",
          "minimumQueryLength": 2,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "skills"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "mode": {
            "enum": [
              "SMART",
              "WORD",
              "STRICT"
            ],
            "default": "SMART"
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "contact.certification",
        "title": "Certifications",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "requires_query",
          "minimumQueryLength": 2,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "certifications"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "contact.education.degree",
        "title": "Education Degree",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "requires_query",
          "minimumQueryLength": 2,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "educationDegree"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "contact.education.date",
        "title": "Education Date",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "year",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 2010,
          "max": 2025
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "educationCompletionYear"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "contact.experience.latest.duration",
        "title": "Experience Duration",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "months",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 12,
          "max": 36
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "jobStartDate"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "contact.emailverificationdate",
        "title": "Email Verification Date",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with ISO 8601 min and/or max dates (YYYY-MM-DD)",
        "units": "ISO 8601 date (YYYY-MM-DD)",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send ISO 8601 calendar dates as min and/or max; do not use numeric timestamps.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": "2024-01-01",
          "max": "2026-01-01"
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "emailLastVerifiedDate"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "contact.hasemail",
        "title": "Work Email Available",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "boolean_values",
        "valueShape": "boolean, \"true\"/\"false\", or an array containing one of those values",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Send true or false (or the string \"true\"/\"false\"). No catalog lookup is needed.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": [
          "true"
        ],
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "workEmailAvailable"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "contact.hascellphone",
        "title": "Mobile Available",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "boolean_values",
        "valueShape": "boolean, \"true\"/\"false\", or an array containing one of those values",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Send true or false (or the string \"true\"/\"false\"). No catalog lookup is needed.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": [
          "true"
        ],
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "personalMobileAvailable"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "contact.reachable",
        "title": "Any Contact Method Available",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "boolean_values",
        "valueShape": "boolean, \"true\"/\"false\", or an array containing one of those values",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Send true or false (or the string \"true\"/\"false\"). No catalog lookup is needed.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": [
          "true"
        ],
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "contactMethodAvailable"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "contact.persona",
        "title": "Persona",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "persona"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "contact.linkedinconnections",
        "title": "LinkedIn Connections",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "count",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 1,
          "max": 100
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "linkedinConnections"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.name",
        "title": "Company Name",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "requires_query",
          "minimumQueryLength": 2,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "company"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.domain",
        "title": "Company Domain",
        "searchType": "people",
        "sendIn": "textFilters",
        "acceptedValueTypeV2": "exact_domain_or_url_values",
        "valueShape": "string or string[] of exact domains or URLs",
        "units": null,
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send an exact domain, LinkedIn URL, or website URL. A valid request can return zero matches when the value is not in the dataset.",
        "includeLimit": 10000,
        "excludeLimit": 10000,
        "exampleValue": "example.com",
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyDomain",
            "companyWebsite"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.website",
        "title": "Company Website",
        "searchType": "people",
        "sendIn": "textFilters",
        "acceptedValueTypeV2": "exact_domain_or_url_values",
        "valueShape": "string or string[] of exact domains or URLs",
        "units": null,
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send an exact domain, LinkedIn URL, or website URL. A valid request can return zero matches when the value is not in the dataset.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": "https://example.com",
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyWebsite"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.funding.lasttype",
        "title": "Last Funding Type",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 50,
        "excludeLimit": 50,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyLastFundingType"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.funding.available",
        "title": "Has Funding Data",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "boolean_values",
        "valueShape": "boolean, \"true\"/\"false\", or an array containing one of those values",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Send true or false (or the string \"true\"/\"false\"). No catalog lookup is needed.",
        "includeLimit": 1,
        "excludeLimit": 1,
        "exampleValue": [
          "true"
        ],
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyLastFundingType"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.funding.lastamount",
        "title": "Last Funding Amount",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "USD",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 20,
        "excludeLimit": 20,
        "exampleValue": {
          "min": 1000000,
          "max": 10000000
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyLastFundingAmount"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.funding.totalamount",
        "title": "Total Funding",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "USD",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 20,
        "excludeLimit": 20,
        "exampleValue": {
          "min": 1000000,
          "max": 10000000
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyTotalFunding"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.funding.lastdate",
        "title": "Last Funding Date",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with ISO 8601 min and/or max dates (YYYY-MM-DD)",
        "units": "ISO 8601 date (YYYY-MM-DD)",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send ISO 8601 calendar dates as min and/or max; do not use numeric timestamps.",
        "includeLimit": 20,
        "excludeLimit": 20,
        "exampleValue": {
          "min": "2024-01-01",
          "max": "2026-01-01"
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyLastFundingDate"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.funding.leadinvestors",
        "title": "Lead Investors",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 100,
        "excludeLimit": 100,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": true
        },
        "exportVerification": {
          "csvKeys": [
            "companyLeadInvestors"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.linkedin",
        "title": "Company LinkedIn",
        "searchType": "people",
        "sendIn": "textFilters",
        "acceptedValueTypeV2": "exact_domain_or_url_values",
        "valueShape": "string or string[] of exact domains or URLs",
        "units": null,
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send an exact domain, LinkedIn URL, or website URL. A valid request can return zero matches when the value is not in the dataset.",
        "includeLimit": 10000,
        "excludeLimit": 10000,
        "exampleValue": "https://www.linkedin.com/company/example",
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyLinkedin"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.funding.investorcount",
        "title": "Investor Count",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "count",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 20,
        "excludeLimit": 20,
        "exampleValue": {
          "min": 1,
          "max": 100
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyInvestorCount"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.location",
        "title": "Company Location",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": [
          "United States"
        ],
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "requires_query",
          "minimumQueryLength": 2,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyLocation"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.industry",
        "title": "Industry",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyIndustry"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.naics",
        "title": "NAICS",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyNaics"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.type",
        "title": "Company Type",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyType"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.employeesize",
        "title": "Employee Count",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "one object with min and/or max, or an array of those range objects",
        "units": "count",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "A single range object remains supported. Multiple Employee Count ranges are ORed; use grounded non-negative integer boundaries.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 1,
          "max": 100
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyEmployees"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.revenue",
        "title": "Annual Revenue",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "USD",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 1000000,
          "max": 10000000
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyRevenue"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.foundedyear",
        "title": "Founded Year",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "year",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 2010,
          "max": 2025
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyFoundedYear"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.technology",
        "title": "Technologies",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyTechnologies"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "mode": {
            "enum": [
              "SMART",
              "WORD",
              "STRICT"
            ],
            "default": "SMART"
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.metric.growth",
        "title": "Headcount Growth",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "percent",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 10,
          "max": 50
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyHeadcountGrowth"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "min": {
            "type": "number"
          },
          "max": {
            "type": "number"
          }
        }
      },
      {
        "fieldPath": "account.hiring",
        "title": "Hiring & Open Roles",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyHiringDepartments"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.traffic",
        "title": "Website Traffic",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "count",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 1,
          "max": 100
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyTraffic"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.adspend",
        "title": "Advertising Spend",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "USD",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 1000000,
          "max": 10000000
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyAdvertisingSpend"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.apppresence",
        "title": "App Presence",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "boolean_values",
        "valueShape": "boolean, \"true\"/\"false\", or an array containing one of those values",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Send true or false (or the string \"true\"/\"false\"). No catalog lookup is needed.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": [
          "true"
        ],
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyMobileAppPresence",
            "companyWebAppPresence"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.apprating",
        "title": "App Rating",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "rating",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 3,
          "max": 5
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyAppRating",
            "companyIosAppRating",
            "companyGooglePlayAppRating"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.appreviews",
        "title": "App Reviews",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "count",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 1,
          "max": 100
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyAppReviews",
            "companyIosAppReviews",
            "companyGooglePlayAppReviews"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.appdownloads",
        "title": "App Downloads",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "count",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 1,
          "max": 100
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyAppDownloads"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "contact.personalWebsite",
        "title": "Personal Website",
        "searchType": "people",
        "sendIn": "textFilters",
        "acceptedValueTypeV2": "exact_domain_or_url_values",
        "valueShape": "string or string[] of exact domains or URLs",
        "units": null,
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send an exact domain, LinkedIn URL, or website URL. A valid request can return zero matches when the value is not in the dataset.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": "https://example.com",
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "personalWebsite"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "contact.patent",
        "title": "Patents",
        "searchType": "people",
        "sendIn": "textFilters",
        "acceptedValueTypeV2": "free_text_values",
        "valueShape": "string or string[] of concise values",
        "units": null,
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Custom values are allowed, but keep them short and directly tied to what this filter matches.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": "battery",
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "patents"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "mode": {
            "enum": [
              "SMART",
              "WORD",
              "STRICT"
            ],
            "default": "SMART"
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "contact.publication",
        "title": "Publications",
        "searchType": "people",
        "sendIn": "textFilters",
        "acceptedValueTypeV2": "free_text_values",
        "valueShape": "string or string[] of concise values",
        "units": null,
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Custom values are allowed, but keep them short and directly tied to what this filter matches.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": "robotics",
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "publications"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "mode": {
            "enum": [
              "SMART",
              "WORD",
              "STRICT"
            ],
            "default": "SMART"
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.hascio",
        "title": "Has CIO",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "boolean_values",
        "valueShape": "boolean, \"true\"/\"false\", or an array containing one of those values",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Send true or false (or the string \"true\"/\"false\"). No catalog lookup is needed.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": [
          "true"
        ],
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyHasCio"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.hasciso",
        "title": "Has CISO",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "boolean_values",
        "valueShape": "boolean, \"true\"/\"false\", or an array containing one of those values",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Send true or false (or the string \"true\"/\"false\"). No catalog lookup is needed.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": [
          "true"
        ],
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyHasCiso"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.locationcount",
        "title": "Number of Locations",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "count",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 1,
          "max": 100
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyLocationCount"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.organictraffic",
        "title": "Organic Traffic",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "count",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 1,
          "max": 100
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyOrganicTraffic"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.paidtraffic",
        "title": "Paid Traffic",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "count",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 1,
          "max": 100
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyPaidTraffic"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.sic",
        "title": "SIC Codes",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companySicCodes"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.legaltype",
        "title": "Legal Structure",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyLegalType"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.websiteforsale",
        "title": "Website for Sale",
        "searchType": "people",
        "sendIn": "filters",
        "acceptedValueTypeV2": "boolean_values",
        "valueShape": "boolean, \"true\"/\"false\", or an array containing one of those values",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Send true or false (or the string \"true\"/\"false\"). No catalog lookup is needed.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": [
          "true"
        ],
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyWebsiteForSale"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      }
    ],
    "company": [
      {
        "fieldPath": "account.linkedin",
        "title": "LinkedIn URL",
        "searchType": "company",
        "sendIn": "textFilters",
        "acceptedValueTypeV2": "exact_domain_or_url_values",
        "valueShape": "string or string[] of exact domains or URLs",
        "units": null,
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send an exact domain, LinkedIn URL, or website URL. A valid request can return zero matches when the value is not in the dataset.",
        "includeLimit": 10000,
        "excludeLimit": 10000,
        "exampleValue": "https://www.linkedin.com/company/example",
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "linkedin"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.industry",
        "title": "Industry",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "industry"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.employeesize",
        "title": "Employee Size",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "one object with min and/or max, or an array of those range objects",
        "units": "count",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "A single range object remains supported. Multiple Employee Count ranges are ORed; use grounded non-negative integer boundaries.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 1,
          "max": 100
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "employees"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.revenue",
        "title": "Annual Revenue",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "USD",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 1000000,
          "max": 10000000
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "revenue"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.type",
        "title": "Company Type",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "companyType"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.foundedyear",
        "title": "Founded Year",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "year",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 2010,
          "max": 2025
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "foundedYear"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.technology",
        "title": "Technologies",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "technologies"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "mode": {
            "enum": [
              "SMART",
              "WORD",
              "STRICT"
            ],
            "default": "SMART"
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.metric.growth",
        "title": "Headcount Growth",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "percent",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 10,
          "max": 50
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "headcountGrowth"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "min": {
            "type": "number"
          },
          "max": {
            "type": "number"
          }
        }
      },
      {
        "fieldPath": "account.naics",
        "title": "NAICS",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "naics"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.keyword",
        "title": "Keywords",
        "searchType": "company",
        "sendIn": "textFilters",
        "acceptedValueTypeV2": "free_text_keyword_terms",
        "valueShape": "string or string[] of short keyword terms",
        "units": null,
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Custom values are allowed, but keep them concise buyer-side terms. Do not send full prompts or sentences.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": "outbound sales",
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "name",
            "description",
            "industry",
            "technologies",
            "companyKeywords"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "mode": {
            "enum": [
              "SMART",
              "WORD",
              "STRICT"
            ],
            "default": "SMART"
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          },
          "sources": {
            "type": "array",
            "items": {
              "enum": [
                "NAME",
                "DESCRIPTION",
                "SPECIALTIES",
                "INDUSTRY",
                "TECHNOLOGIES"
              ]
            }
          },
          "includeSources": {
            "type": "array",
            "items": {
              "enum": [
                "NAME",
                "DESCRIPTION",
                "SPECIALTIES",
                "INDUSTRY",
                "TECHNOLOGIES"
              ]
            }
          },
          "excludeSources": {
            "type": "array",
            "items": {
              "enum": [
                "NAME",
                "DESCRIPTION",
                "SPECIALTIES",
                "INDUSTRY",
                "TECHNOLOGIES"
              ]
            }
          }
        }
      },
      {
        "fieldPath": "account.domain",
        "title": "Domain",
        "searchType": "company",
        "sendIn": "textFilters",
        "acceptedValueTypeV2": "exact_domain_or_url_values",
        "valueShape": "string or string[] of exact domains or URLs",
        "units": null,
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send an exact domain, LinkedIn URL, or website URL. A valid request can return zero matches when the value is not in the dataset.",
        "includeLimit": 10000,
        "excludeLimit": 10000,
        "exampleValue": "example.com",
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "domain"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.name",
        "title": "Company Name",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "requires_query",
          "minimumQueryLength": 2,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "name"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.location",
        "title": "Company Location",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": [
          "United States"
        ],
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "requires_query",
          "minimumQueryLength": 2,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "location",
            "city",
            "state",
            "country"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.metric.employee",
        "title": "Employees by Department",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "structured_metric_ranges",
        "valueShape": "object or object[] with function, department, or role plus min and/or max",
        "units": "count",
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Choose an exact metric dimension from lookup_filter_options, then send that value as function (or department/role) with a grounded min and/or max. A bare { min, max } object is invalid because it does not identify a metric dimension.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": [
          {
            "function": "sales",
            "min": 1,
            "max": 10
          }
        ],
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "departmentEmployees"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [
          {
            "id": "sales",
            "label": "Sales",
            "sort_order": 1
          },
          {
            "id": "it",
            "label": "IT",
            "sort_order": 2
          },
          {
            "id": "marketing",
            "label": "Marketing",
            "sort_order": 3
          },
          {
            "id": "operations",
            "label": "Operations",
            "sort_order": 4
          },
          {
            "id": "customer_success",
            "label": "Customer Success",
            "sort_order": 5
          },
          {
            "id": "business_development",
            "label": "Business Development",
            "sort_order": 6
          }
        ],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "metricRows": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "functions": {
                  "type": "array",
                  "items": {
                    "type": "string"
                  },
                  "description": "Exact dimensions returned by this field's filter-options lookup."
                },
                "start": {
                  "type": "number"
                },
                "end": {
                  "type": "number"
                },
                "exclude": {
                  "type": "boolean",
                  "default": false
                }
              }
            }
          }
        }
      },
      {
        "fieldPath": "account.hiring",
        "title": "Hiring & Open Roles",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [],
          "verification": "requires_source",
          "note": "No direct CSV column exposes this predicate. Verify the applied query and source data; a missing column does not mean the filter was ignored."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.openroles",
        "title": "Open Roles",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "structured_metric_ranges",
        "valueShape": "object or object[] with function, department, or role plus min and/or max",
        "units": "count",
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Choose an exact metric dimension from lookup_filter_options, then send that value as function (or department/role) with a grounded min and/or max. A bare { min, max } object is invalid because it does not identify a metric dimension.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": [
          {
            "function": "sales",
            "min": 1,
            "max": 10
          }
        ],
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "hiringDepartments",
            "openRoles"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [
          {
            "id": "sales",
            "label": "Sales",
            "sort_order": 1
          },
          {
            "id": "it",
            "label": "IT",
            "sort_order": 2
          },
          {
            "id": "marketing",
            "label": "Marketing",
            "sort_order": 3
          },
          {
            "id": "operations",
            "label": "Operations",
            "sort_order": 4
          },
          {
            "id": "customer_success",
            "label": "Customer Success",
            "sort_order": 5
          },
          {
            "id": "business_development",
            "label": "Business Development",
            "sort_order": 6
          }
        ],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "metricRows": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "functions": {
                  "type": "array",
                  "items": {
                    "type": "string"
                  },
                  "description": "Exact dimensions returned by this field's filter-options lookup."
                },
                "start": {
                  "type": "number"
                },
                "end": {
                  "type": "number"
                },
                "exclude": {
                  "type": "boolean",
                  "default": false
                }
              }
            }
          }
        }
      },
      {
        "fieldPath": "account.funding.available",
        "title": "Has Funding Data",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "boolean_values",
        "valueShape": "boolean, \"true\"/\"false\", or an array containing one of those values",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Send true or false (or the string \"true\"/\"false\"). No catalog lookup is needed.",
        "includeLimit": 1,
        "excludeLimit": 1,
        "exampleValue": [
          "true"
        ],
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "lastFundingType"
          ],
          "verification": "requires_source",
          "note": "Related CSV columns are listed. Matching can span multiple source fields, use fallback values or derived conditions; these columns alone do not prove every predicate."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.funding.lasttype",
        "title": "Last Funding Type",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 50,
        "excludeLimit": 50,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "lastFundingType"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.funding.lastamount",
        "title": "Last Funding Amount",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "USD",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 20,
        "excludeLimit": 20,
        "exampleValue": {
          "min": 1000000,
          "max": 10000000
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "lastFundingAmount"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.funding.totalamount",
        "title": "Total Funding",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "USD",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 20,
        "excludeLimit": 20,
        "exampleValue": {
          "min": 1000000,
          "max": 10000000
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "totalFunding"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.funding.lastdate",
        "title": "Last Funding Date",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with ISO 8601 min and/or max dates (YYYY-MM-DD)",
        "units": "ISO 8601 date (YYYY-MM-DD)",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send ISO 8601 calendar dates as min and/or max; do not use numeric timestamps.",
        "includeLimit": 20,
        "excludeLimit": 20,
        "exampleValue": {
          "min": "2024-01-01",
          "max": "2026-01-01"
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "lastFundingDate"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.funding.leadinvestors",
        "title": "Lead Investors",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 100,
        "excludeLimit": 100,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": true
        },
        "exportVerification": {
          "csvKeys": [
            "leadInvestors"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.funding.investorcount",
        "title": "Investor Count",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "count",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 20,
        "excludeLimit": 20,
        "exampleValue": {
          "min": 1,
          "max": 100
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "investorCount"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.hascio",
        "title": "Has CIO",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "boolean_values",
        "valueShape": "boolean, \"true\"/\"false\", or an array containing one of those values",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Send true or false (or the string \"true\"/\"false\"). No catalog lookup is needed.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": [
          "true"
        ],
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "hasCio"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.hasciso",
        "title": "Has CISO",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "boolean_values",
        "valueShape": "boolean, \"true\"/\"false\", or an array containing one of those values",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Send true or false (or the string \"true\"/\"false\"). No catalog lookup is needed.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": [
          "true"
        ],
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "hasCiso"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.locationcount",
        "title": "Number of Locations",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "count",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 1,
          "max": 100
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "locationCount"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.organictraffic",
        "title": "Organic Traffic",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "count",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 1,
          "max": 100
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "organicTraffic"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.paidtraffic",
        "title": "Paid Traffic",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "count",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 1,
          "max": 100
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "paidTraffic"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.sic",
        "title": "SIC Codes",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "sicCodes"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.legaltype",
        "title": "Legal Structure",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "legalType",
            "companyType"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.websiteforsale",
        "title": "Website for Sale",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "boolean_values",
        "valueShape": "boolean, \"true\"/\"false\", or an array containing one of those values",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Send true or false (or the string \"true\"/\"false\"). No catalog lookup is needed.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": [
          "true"
        ],
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "websiteForSale"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.websiteworking",
        "title": "Working Website",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "boolean_values",
        "valueShape": "boolean, \"true\"/\"false\", or an array containing one of those values",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Send true or false (or the string \"true\"/\"false\"). No catalog lookup is needed.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": [
          "true"
        ],
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "websiteWorking"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.linkedinfollowers",
        "title": "Company LinkedIn Followers",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "range_min_max",
        "valueShape": "object with grounded min and/or max values",
        "units": "count",
        "acceptsCustomValues": true,
        "allowedValueBehavior": "Send a range only when the prompt or campaign strategy gives a real reason for that constraint.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": {
          "min": 1,
          "max": 100
        },
        "optionLookup": {
          "available": false,
          "supportsQuery": false,
          "supportsCursor": false
        },
        "optionDiscovery": {
          "mode": "not_applicable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "linkedinFollowers"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      },
      {
        "fieldPath": "account.uksic",
        "title": "UK SIC Codes",
        "searchType": "company",
        "sendIn": "filters",
        "acceptedValueTypeV2": "selected_option_ids_or_labels",
        "valueShape": "string[] of exact current option IDs or readable labels",
        "units": null,
        "acceptsCustomValues": false,
        "allowedValueBehavior": "Call the filter-options option lookup, then submit exact options[].id or options[].label values. Do not invent catalog values.",
        "includeLimit": 300,
        "excludeLimit": 300,
        "exampleValue": null,
        "optionLookup": {
          "available": true,
          "supportsQuery": true,
          "supportsCursor": true
        },
        "optionDiscovery": {
          "mode": "browseable",
          "minimumQueryLength": 0,
          "pageSizeMax": 100,
          "starterSample": false
        },
        "exportVerification": {
          "csvKeys": [
            "ukSicCodes"
          ],
          "verification": "row_check",
          "note": "Use these exact CSV header keys to check the corresponding source value; missing values and exclusions follow the documented filter semantics."
        },
        "optionSampleOptions": [],
        "matching": {
          "defaultCondition": "any",
          "supportsMatchAll": true,
          "overridePath": "filterRules.<field>.matchAll",
          "acceptedValues": [
            true,
            false
          ]
        },
        "ruleSchema": {
          "matchAll": {
            "type": "boolean",
            "default": false
          },
          "exclude": {
            "type": "boolean",
            "default": false
          },
          "condition": {
            "enum": [
              "any",
              "all"
            ],
            "default": "any"
          }
        }
      }
    ]
  },
  "exportPreflight": {
    "method": "POST",
    "endpoint": "https://ttzqldekaizydrdmirpn.supabase.co/functions/v1/api-export-preflight",
    "mcpTool": "preview_export",
    "requiredScope": "export",
    "required": [
      "search_id"
    ],
    "optional": [
      "requested_leads",
      "fields",
      "format",
      "saveContacts"
    ],
    "readinessField": "can_export",
    "blockersField": "blockers",
    "maximumHoldField": "credits.maximum_required_hold",
    "countExactField": "availability.count_exact",
    "countSource": "Search snapshot; historical exactness can be null",
    "creditsCharged": 0,
    "reservesCredits": false,
    "quota": "One shared request-minute slot; create/status remain unlimited",
    "note": "Optional preview. No new search/job/file/saved membership. Creation revalidates; final charges depend on delivered data and entitlements."
  },
  "exports": {
    "preflight": {
      "endpoint": "api-export-preflight",
      "method": "POST",
      "mcpTool": "preview_export",
      "requiredScope": "export",
      "creditsCharged": 0,
      "reservesCredits": false,
      "countSource": "search_snapshot",
      "rateLimit": "shared_per_minute"
    },
    "saveRecordsBySearchType": {
      "people": {
        "parameter": "saveContacts",
        "enabled": true,
        "default": true
      },
      "company": {
        "parameter": "saveContacts",
        "enabled": true,
        "default": true
      }
    },
    "supportedFormats": [
      "csv"
    ],
    "fieldsBySearchType": {
      "people": [
        {
          "key": "jobLocation",
          "label": "Job Location",
          "group": "Profile",
          "kind": "text",
          "section": "profile"
        },
        {
          "key": "educationCompletionYear",
          "label": "Education Completion Year",
          "group": "Experience",
          "kind": "list",
          "section": "experience"
        },
        {
          "key": "emailLastVerifiedDate",
          "label": "Email Last Verified Date",
          "group": "Contact",
          "kind": "date",
          "section": "contact"
        },
        {
          "key": "contactMethodAvailable",
          "label": "Any Contact Method Available",
          "group": "Contact",
          "kind": "boolean",
          "section": "contact"
        },
        {
          "key": "persona",
          "label": "Persona",
          "group": "Profile",
          "kind": "list",
          "section": "profile"
        },
        {
          "key": "linkedinConnections",
          "label": "LinkedIn Connections",
          "group": "Profile",
          "kind": "number",
          "section": "profile"
        },
        {
          "key": "patents",
          "label": "Patents",
          "group": "Experience",
          "kind": "list",
          "section": "experience"
        },
        {
          "key": "publications",
          "label": "Publications",
          "group": "Experience",
          "kind": "list",
          "section": "experience"
        },
        {
          "key": "companyHasCio",
          "label": "Company Has CIO",
          "group": "Digital signals",
          "kind": "boolean",
          "section": "digital_signals"
        },
        {
          "key": "companyHasCiso",
          "label": "Company Has CISO",
          "group": "Digital signals",
          "kind": "boolean",
          "section": "digital_signals"
        },
        {
          "key": "companyLocationCount",
          "label": "Company Number of Locations",
          "group": "Digital signals",
          "kind": "number",
          "section": "digital_signals"
        },
        {
          "key": "companyOrganicTraffic",
          "label": "Company Organic Traffic",
          "group": "Digital signals",
          "kind": "number",
          "section": "digital_signals"
        },
        {
          "key": "companyPaidTraffic",
          "label": "Company Paid Traffic",
          "group": "Digital signals",
          "kind": "number",
          "section": "digital_signals"
        },
        {
          "key": "companySicCodes",
          "label": "Company SIC Codes",
          "group": "Digital signals",
          "kind": "list",
          "section": "digital_signals"
        },
        {
          "key": "companyLegalType",
          "label": "Company Legal Structure",
          "group": "Digital signals",
          "kind": "text",
          "section": "digital_signals"
        },
        {
          "key": "companyWebsiteForSale",
          "label": "Company Website for Sale",
          "group": "Digital signals",
          "kind": "boolean",
          "section": "digital_signals"
        },
        {
          "key": "workEmail",
          "label": "Work Email",
          "group": "Contact",
          "kind": "contact",
          "section": "contact"
        },
        {
          "key": "personalMobile",
          "label": "Personal Mobile",
          "group": "Contact",
          "kind": "contact",
          "section": "contact"
        },
        {
          "key": "emailStatus",
          "label": "Email Status",
          "group": "Contact",
          "kind": "text",
          "section": "contact"
        },
        {
          "key": "workEmailAvailable",
          "label": "Work Email Available",
          "group": "Contact",
          "kind": "boolean",
          "section": "contact"
        },
        {
          "key": "personalMobileAvailable",
          "label": "Personal Mobile Available",
          "group": "Contact",
          "kind": "boolean",
          "section": "contact"
        },
        {
          "key": "name",
          "label": "Full Name",
          "group": "Profile",
          "kind": "text",
          "section": "profile"
        },
        {
          "key": "firstName",
          "label": "First Name",
          "group": "Profile",
          "kind": "text",
          "section": "profile"
        },
        {
          "key": "lastName",
          "label": "Last Name",
          "group": "Profile",
          "kind": "text",
          "section": "profile"
        },
        {
          "key": "headline",
          "label": "Headline",
          "group": "Profile",
          "kind": "text",
          "section": "profile"
        },
        {
          "key": "title",
          "label": "Job Title",
          "group": "Profile",
          "kind": "text",
          "section": "profile"
        },
        {
          "key": "seniority",
          "label": "Seniority",
          "group": "Profile",
          "kind": "text",
          "section": "profile"
        },
        {
          "key": "department",
          "label": "Department",
          "group": "Profile",
          "kind": "text",
          "section": "profile"
        },
        {
          "key": "linkedin",
          "label": "LinkedIn URL",
          "group": "Profile",
          "kind": "text",
          "section": "profile"
        },
        {
          "key": "location",
          "label": "Location",
          "group": "Profile",
          "kind": "text",
          "section": "profile"
        },
        {
          "key": "city",
          "label": "City",
          "group": "Profile",
          "kind": "text",
          "section": "profile"
        },
        {
          "key": "state",
          "label": "State",
          "group": "Profile",
          "kind": "text",
          "section": "profile"
        },
        {
          "key": "country",
          "label": "Country",
          "group": "Profile",
          "kind": "text",
          "section": "profile"
        },
        {
          "key": "jobStartDate",
          "label": "Job Start Date",
          "group": "Experience",
          "kind": "date",
          "section": "experience"
        },
        {
          "key": "skills",
          "label": "Skills",
          "group": "Experience",
          "kind": "list",
          "section": "experience"
        },
        {
          "key": "certifications",
          "label": "Certifications",
          "group": "Experience",
          "kind": "list",
          "section": "experience"
        },
        {
          "key": "personalWebsite",
          "label": "Personal Website",
          "group": "Contact",
          "kind": "text",
          "section": "contact"
        },
        {
          "key": "educationDegree",
          "label": "Education Degree",
          "group": "Experience",
          "kind": "list",
          "section": "experience"
        },
        {
          "key": "company",
          "label": "Company Name",
          "group": "Current company",
          "kind": "text",
          "section": "current_company"
        },
        {
          "key": "companyDomain",
          "label": "Company Domain",
          "group": "Current company",
          "kind": "text",
          "section": "current_company"
        },
        {
          "key": "companyWebsite",
          "label": "Company Website",
          "group": "Current company",
          "kind": "text",
          "section": "current_company"
        },
        {
          "key": "companyLinkedin",
          "label": "Company LinkedIn URL",
          "group": "Current company",
          "kind": "text",
          "section": "current_company"
        },
        {
          "key": "companyLocation",
          "label": "Company Location",
          "group": "Current company",
          "kind": "text",
          "section": "current_company"
        },
        {
          "key": "companyDescription",
          "label": "Company Description",
          "group": "Current company",
          "kind": "text",
          "section": "current_company"
        },
        {
          "key": "companyIndustry",
          "label": "Company Industry",
          "group": "Current company",
          "kind": "text",
          "section": "current_company"
        },
        {
          "key": "companyNaics",
          "label": "Company NAICS",
          "group": "Current company",
          "kind": "text",
          "section": "current_company"
        },
        {
          "key": "companyType",
          "label": "Company Type",
          "group": "Current company",
          "kind": "text",
          "section": "current_company"
        },
        {
          "key": "companyEmployees",
          "label": "Company Employees",
          "group": "Current company",
          "kind": "number",
          "section": "current_company"
        },
        {
          "key": "companyRevenue",
          "label": "Company Revenue",
          "group": "Current company",
          "kind": "number",
          "section": "current_company"
        },
        {
          "key": "companyFoundedYear",
          "label": "Company Founded Year",
          "group": "Current company",
          "kind": "number",
          "section": "current_company"
        },
        {
          "key": "companyHeadcountGrowth",
          "label": "Company Headcount Growth",
          "group": "Growth and hiring",
          "kind": "number",
          "section": "growth_hiring"
        },
        {
          "key": "companyDepartmentEmployees",
          "label": "Company Employees by Department",
          "group": "Growth and hiring",
          "kind": "list",
          "section": "growth_hiring"
        },
        {
          "key": "companyHiringDepartments",
          "label": "Company Hiring Departments",
          "group": "Growth and hiring",
          "kind": "list",
          "section": "growth_hiring"
        },
        {
          "key": "companyOpenRoles",
          "label": "Company Open Roles",
          "group": "Growth and hiring",
          "kind": "list",
          "section": "growth_hiring"
        },
        {
          "key": "companyLastFundingType",
          "label": "Company Last Funding Type",
          "group": "Funding",
          "kind": "text",
          "section": "funding_technology"
        },
        {
          "key": "companyLastFundingAmount",
          "label": "Company Last Funding Amount",
          "group": "Funding",
          "kind": "number",
          "section": "funding_technology"
        },
        {
          "key": "companyTotalFunding",
          "label": "Company Total Funding",
          "group": "Funding",
          "kind": "number",
          "section": "funding_technology"
        },
        {
          "key": "companyLastFundingDate",
          "label": "Company Last Funding Date",
          "group": "Funding",
          "kind": "date",
          "section": "funding_technology"
        },
        {
          "key": "companyLeadInvestors",
          "label": "Company Lead Investors",
          "group": "Funding",
          "kind": "list",
          "section": "funding_technology"
        },
        {
          "key": "companyInvestorCount",
          "label": "Company Investor Count",
          "group": "Funding",
          "kind": "number",
          "section": "funding_technology"
        },
        {
          "key": "companyTechnologies",
          "label": "Company Technologies",
          "group": "Technology",
          "kind": "list",
          "section": "funding_technology"
        },
        {
          "key": "companyKeywords",
          "label": "Company Keywords",
          "group": "Technology",
          "kind": "list",
          "section": "funding_technology"
        },
        {
          "key": "companyTraffic",
          "label": "Company Traffic",
          "group": "Digital signals",
          "kind": "number",
          "section": "digital_signals"
        },
        {
          "key": "companyAdvertisingSpend",
          "label": "Company Advertising Spend",
          "group": "Digital signals",
          "kind": "number",
          "section": "digital_signals"
        },
        {
          "key": "companyMobileAppPresence",
          "label": "Company Mobile App Presence",
          "group": "Digital signals",
          "kind": "boolean",
          "section": "digital_signals"
        },
        {
          "key": "companyWebAppPresence",
          "label": "Company Web App Presence",
          "group": "Digital signals",
          "kind": "boolean",
          "section": "digital_signals"
        },
        {
          "key": "companyAppRating",
          "label": "Company App Rating",
          "group": "Digital signals",
          "kind": "number",
          "section": "digital_signals"
        },
        {
          "key": "companyAppReviews",
          "label": "Company App Reviews",
          "group": "Digital signals",
          "kind": "number",
          "section": "digital_signals"
        },
        {
          "key": "companyIosAppRating",
          "label": "Company iOS App Rating",
          "group": "Digital signals",
          "kind": "number",
          "section": "digital_signals"
        },
        {
          "key": "companyGooglePlayAppRating",
          "label": "Company Google Play App Rating",
          "group": "Digital signals",
          "kind": "number",
          "section": "digital_signals"
        },
        {
          "key": "companyIosAppReviews",
          "label": "Company iOS App Reviews",
          "group": "Digital signals",
          "kind": "number",
          "section": "digital_signals"
        },
        {
          "key": "companyGooglePlayAppReviews",
          "label": "Company Google Play App Reviews",
          "group": "Digital signals",
          "kind": "number",
          "section": "digital_signals"
        },
        {
          "key": "companyAppDownloads",
          "label": "Company App Downloads",
          "group": "Digital signals",
          "kind": "number",
          "section": "digital_signals"
        }
      ],
      "company": [
        {
          "key": "hasCio",
          "label": "Has CIO",
          "group": "Digital signals",
          "kind": "boolean"
        },
        {
          "key": "hasCiso",
          "label": "Has CISO",
          "group": "Digital signals",
          "kind": "boolean"
        },
        {
          "key": "locationCount",
          "label": "Number of Locations",
          "group": "Digital signals",
          "kind": "number"
        },
        {
          "key": "organicTraffic",
          "label": "Organic Traffic",
          "group": "Digital signals",
          "kind": "number"
        },
        {
          "key": "paidTraffic",
          "label": "Paid Traffic",
          "group": "Digital signals",
          "kind": "number"
        },
        {
          "key": "sicCodes",
          "label": "SIC Codes",
          "group": "Digital signals",
          "kind": "list"
        },
        {
          "key": "legalType",
          "label": "Legal Structure",
          "group": "Digital signals",
          "kind": "text"
        },
        {
          "key": "websiteForSale",
          "label": "Website for Sale",
          "group": "Digital signals",
          "kind": "boolean"
        },
        {
          "key": "websiteWorking",
          "label": "Working Website",
          "group": "Digital signals",
          "kind": "boolean"
        },
        {
          "key": "linkedinFollowers",
          "label": "Company LinkedIn Followers",
          "group": "Digital signals",
          "kind": "number"
        },
        {
          "key": "ukSicCodes",
          "label": "UK SIC Codes",
          "group": "Digital signals",
          "kind": "list"
        },
        {
          "key": "name",
          "label": "Company Name",
          "group": "Identity",
          "kind": "text"
        },
        {
          "key": "domain",
          "label": "Domain",
          "group": "Identity",
          "kind": "text"
        },
        {
          "key": "website",
          "label": "Website",
          "group": "Identity",
          "kind": "text"
        },
        {
          "key": "linkedin",
          "label": "LinkedIn URL",
          "group": "Identity",
          "kind": "text"
        },
        {
          "key": "location",
          "label": "Location",
          "group": "Identity",
          "kind": "text"
        },
        {
          "key": "city",
          "label": "City",
          "group": "Identity",
          "kind": "text"
        },
        {
          "key": "state",
          "label": "State",
          "group": "Identity",
          "kind": "text"
        },
        {
          "key": "country",
          "label": "Country",
          "group": "Identity",
          "kind": "text"
        },
        {
          "key": "description",
          "label": "Description",
          "group": "Identity",
          "kind": "text"
        },
        {
          "key": "industry",
          "label": "Industry",
          "group": "Firmographics",
          "kind": "text"
        },
        {
          "key": "naics",
          "label": "NAICS",
          "group": "Firmographics",
          "kind": "list"
        },
        {
          "key": "companyType",
          "label": "Company Type",
          "group": "Firmographics",
          "kind": "text"
        },
        {
          "key": "foundedYear",
          "label": "Founded Year",
          "group": "Firmographics",
          "kind": "number"
        },
        {
          "key": "employees",
          "label": "Employees",
          "group": "Firmographics",
          "kind": "number"
        },
        {
          "key": "revenue",
          "label": "Revenue",
          "group": "Firmographics",
          "kind": "number"
        },
        {
          "key": "headcountGrowth",
          "label": "Headcount Growth",
          "group": "Growth and hiring",
          "kind": "number"
        },
        {
          "key": "departmentEmployees",
          "label": "Employees by Department",
          "group": "Growth and hiring",
          "kind": "list"
        },
        {
          "key": "hiringDepartments",
          "label": "Hiring Departments",
          "group": "Growth and hiring",
          "kind": "list"
        },
        {
          "key": "openRoles",
          "label": "Open Roles",
          "group": "Growth and hiring",
          "kind": "list"
        },
        {
          "key": "lastFundingType",
          "label": "Last Funding Type",
          "group": "Funding",
          "kind": "text"
        },
        {
          "key": "lastFundingAmount",
          "label": "Last Funding Amount",
          "group": "Funding",
          "kind": "number"
        },
        {
          "key": "totalFunding",
          "label": "Total Funding",
          "group": "Funding",
          "kind": "number"
        },
        {
          "key": "lastFundingDate",
          "label": "Last Funding Date",
          "group": "Funding",
          "kind": "date"
        },
        {
          "key": "leadInvestors",
          "label": "Lead Investors",
          "group": "Funding",
          "kind": "list"
        },
        {
          "key": "investorCount",
          "label": "Investor Count",
          "group": "Funding",
          "kind": "number"
        },
        {
          "key": "technologies",
          "label": "Technologies",
          "group": "Technology",
          "kind": "list"
        },
        {
          "key": "productsServices",
          "label": "Products and Services",
          "group": "Technology",
          "kind": "list"
        },
        {
          "key": "companyKeywords",
          "label": "Company Keywords",
          "group": "Technology",
          "kind": "list"
        },
        {
          "key": "traffic",
          "label": "Traffic",
          "group": "Digital signals",
          "kind": "number"
        },
        {
          "key": "advertisingSpend",
          "label": "Advertising Spend",
          "group": "Digital signals",
          "kind": "number"
        },
        {
          "key": "mobileAppPresence",
          "label": "Mobile App Presence",
          "group": "Digital signals",
          "kind": "boolean"
        },
        {
          "key": "webAppPresence",
          "label": "Web App Presence",
          "group": "Digital signals",
          "kind": "boolean"
        },
        {
          "key": "appRating",
          "label": "App Rating",
          "group": "Digital signals",
          "kind": "number"
        },
        {
          "key": "appReviews",
          "label": "App Reviews",
          "group": "Digital signals",
          "kind": "number"
        },
        {
          "key": "iosAppRating",
          "label": "iOS App Rating",
          "group": "Digital signals",
          "kind": "number"
        },
        {
          "key": "googlePlayAppRating",
          "label": "Google Play App Rating",
          "group": "Digital signals",
          "kind": "number"
        },
        {
          "key": "iosAppReviews",
          "label": "iOS App Reviews",
          "group": "Digital signals",
          "kind": "number"
        },
        {
          "key": "googlePlayAppReviews",
          "label": "Google Play App Reviews",
          "group": "Digital signals",
          "kind": "number"
        },
        {
          "key": "appDownloads",
          "label": "App Downloads",
          "group": "Digital signals",
          "kind": "number"
        }
      ]
    },
    "bulkDefaultFieldsBySearchType": {
      "people": [
        "workEmail",
        "emailStatus",
        "name",
        "firstName",
        "lastName",
        "headline",
        "title",
        "seniority",
        "department",
        "linkedin",
        "location",
        "city",
        "state",
        "country",
        "company",
        "companyDomain",
        "companyWebsite",
        "companyLinkedin",
        "companyLocation",
        "companyIndustry",
        "companyNaics",
        "companyType",
        "companyEmployees",
        "companyRevenue",
        "companyFoundedYear"
      ],
      "company": [
        "name",
        "domain",
        "industry",
        "location",
        "employees"
      ]
    },
    "maxRequestedLeads": 100000,
    "csvMaxRequestedLeads": 100000,
    "pitWorkerEnabled": true,
    "noDataHalfCreditEnabled": true,
    "maxConcurrentJobs": 10,
    "createRateLimits": {
      "perMinute": null,
      "perHour": null,
      "perDay": null,
      "unlimited": true
    },
    "statusRateLimits": {
      "perMinute": null,
      "perHour": null,
      "unlimited": true
    },
    "requestSizing": {
      "requestedLeadsField": "requested_leads",
      "minimumRows": 1,
      "availableSnapshotCountPath": "results.totalElements",
      "mustNotExceedSnapshotCount": true,
      "guidance": "Choose no more than the saved search snapshot count and the account maximum. Use the total count, not the current page length. Do not create an export for an empty search; an approximate total is not proof of the entire audience size.",
      "sizeExceeded": {
        "restStatus": 422,
        "code": "export_size_exceeds_search_total",
        "availableRecordsField": "available_records",
        "useNewIdempotencyKeyForChangedRequest": true,
        "recovery": "Reduce the intentional request to available_records or less and use a fresh idempotency key. An uncertain unchanged transport retry must keep the original key and identical body. MCP forwards this refusal as result.isError with the same structured payload."
      }
    },
    "lifecycle": {
      "states": [
        "queued",
        "processing",
        "completed",
        "failed",
        "cancelled"
      ],
      "terminalStates": [
        "completed",
        "failed",
        "cancelled"
      ],
      "pollIntervalSeconds": 5,
      "downloadUrlField": "download_url",
      "downloadExpiryField": "download_expires_at",
      "downloadMethod": "GET",
      "expiredUrlRecovery": "Poll export status again to obtain a fresh signed URL.",
      "failureField": "error_message",
      "retrySafety": "Reuse the same Idempotency-Key for an uncertain create result. Do not repeatedly create new jobs."
    }
  }
}