> ## Documentation Index
> Fetch the complete documentation index at: https://docs.fuseai.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Count people matching a search (free)

> Count how many people match a plain-English sentence, a saved search or people-search filters (job title, seniority, department, employer, industry, location, headcount). Free: no credits are charged, and no names or contact details come back.

Send the filter source POST /prospects/search takes, exactly one of: `query`, e.g. "VPs of sales at fintech companies in New York"; `filters` in the POST /prospects/search vocabulary; or one of your people saved searches by `savedSearchId` or `savedSearchName`. A count has no paging and no `linkedinUrl` lookup. Each source is resolved, and its filters translated and looked up, exactly as the search does it, so a count is of the people that body would search. The answer carries `status`, `total` (the people matching), `filters` (what was counted: send them to POST /prospects/search to list the people), `unresolvedCriteria` (parts of a `query` that could not be mapped to a filter, only with `query`), `closestCompanyMatches` (each company the `query` named that Smart Search chose between same-named companies for, only with `query`), `ignoredFilterKeys` (stored keys with no search field, only with a saved search) and `creditsCharged` (always 0).

A new count runs in the background, for up to about a minute and a half: the first call answers 202 with `status` `pending`, `total` null and the `filters` being counted. Repeat the request every few seconds with those `filters` (not the `query`, which would be converted again and could count a different search) until it answers 200 with `status` `ready`. A counted search stays cached for 15 minutes, so repeating it answers at once. Each account starts at most 10 new counts a minute and 500 a day; past that, a new count answers 503 for a minute.

Only keys whose usage plan includes `people_count` may call it. Rate limit: the plan's `people_count` entry.

Errors:
- `403` `API_NOT_ON_PLAN` — The key's usage plan does not include `people_count`.
- `404` `SAVED_SEARCH_NOT_FOUND` — No saved search of yours has that id or exact title.
- `409` `SAVED_SEARCH_NAME_AMBIGUOUS` — Two of your saved searches share that title: reference it by `savedSearchId` instead.
- `422` `SAVED_SEARCH_TYPE_MISMATCH` — The saved search exists but stores the other kind of filters; `param` is `savedSearchId`.
- `422` `SAVED_SEARCH_INVALID` — The stored filters no longer form a runnable search: every value was retired, or nothing in them is a filter.
- `422` `QUERY_FILTERS_INVALID` — The `query` could not be turned into filters. Name concrete criteria: titles, locations, industries, company sizes.
- `422` `FILTER_VALUE_UNRESOLVED` — No company or place named in one filter could be found; `param` names the filter and `values` the values nothing matched.
- `429` `RATE_LIMITED` — The plan's per-minute or per-day limit for `people_count` is spent, or too many `query` sentences were converted today.

Requires one of the following token scopes: data.



## OpenAPI

````yaml /openapi.json post /business/data/people/count
openapi: 3.1.0
info:
  title: Fuse Business API
  version: 1.0.0
  description: >-
    External API for lists, campaigns, prospect search and contacts.
    Authenticate with your API token as HTTP Basic. All paths are under /api/v1.
servers:
  - url: https://api.tryfuse.ai/api/v1
    description: Production
security:
  - basicAuth: []
tags:
  - name: Lists
  - name: Custom columns
  - name: Smart columns
  - name: Exports
  - name: Campaigns
  - name: Knowledge hubs
  - name: Analytics
  - name: Website intent
  - name: Account
  - name: Data
  - name: Prospect search
  - name: Campaign steps
  - name: Scheduled sends
  - name: Campaign templates
  - name: Agents
  - name: Research
  - name: Company search
  - name: Saved searches
  - name: Folders
  - name: Contacts
paths:
  /business/data/people/count:
    post:
      tags:
        - Data
      summary: Count people matching a search (free)
      description: >-
        Count how many people match a plain-English sentence, a saved search or
        people-search filters (job title, seniority, department, employer,
        industry, location, headcount). Free: no credits are charged, and no
        names or contact details come back.


        Send the filter source POST /prospects/search takes, exactly one of:
        `query`, e.g. "VPs of sales at fintech companies in New York"; `filters`
        in the POST /prospects/search vocabulary; or one of your people saved
        searches by `savedSearchId` or `savedSearchName`. A count has no paging
        and no `linkedinUrl` lookup. Each source is resolved, and its filters
        translated and looked up, exactly as the search does it, so a count is
        of the people that body would search. The answer carries `status`,
        `total` (the people matching), `filters` (what was counted: send them to
        POST /prospects/search to list the people), `unresolvedCriteria` (parts
        of a `query` that could not be mapped to a filter, only with `query`),
        `closestCompanyMatches` (each company the `query` named that Smart
        Search chose between same-named companies for, only with `query`),
        `ignoredFilterKeys` (stored keys with no search field, only with a saved
        search) and `creditsCharged` (always 0).


        A new count runs in the background, for up to about a minute and a half:
        the first call answers 202 with `status` `pending`, `total` null and the
        `filters` being counted. Repeat the request every few seconds with those
        `filters` (not the `query`, which would be converted again and could
        count a different search) until it answers 200 with `status` `ready`. A
        counted search stays cached for 15 minutes, so repeating it answers at
        once. Each account starts at most 10 new counts a minute and 500 a day;
        past that, a new count answers 503 for a minute.


        Only keys whose usage plan includes `people_count` may call it. Rate
        limit: the plan's `people_count` entry.


        Errors:

        - `403` `API_NOT_ON_PLAN` — The key's usage plan does not include
        `people_count`.

        - `404` `SAVED_SEARCH_NOT_FOUND` — No saved search of yours has that id
        or exact title.

        - `409` `SAVED_SEARCH_NAME_AMBIGUOUS` — Two of your saved searches share
        that title: reference it by `savedSearchId` instead.

        - `422` `SAVED_SEARCH_TYPE_MISMATCH` — The saved search exists but
        stores the other kind of filters; `param` is `savedSearchId`.

        - `422` `SAVED_SEARCH_INVALID` — The stored filters no longer form a
        runnable search: every value was retired, or nothing in them is a
        filter.

        - `422` `QUERY_FILTERS_INVALID` — The `query` could not be turned into
        filters. Name concrete criteria: titles, locations, industries, company
        sizes.

        - `422` `FILTER_VALUE_UNRESOLVED` — No company or place named in one
        filter could be found; `param` names the filter and `values` the values
        nothing matched.

        - `429` `RATE_LIMITED` — The plan's per-minute or per-day limit for
        `people_count` is spent, or too many `query` sentences were converted
        today.


        Requires one of the following token scopes: data.
      operationId: countPeople
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                filters:
                  type: object
                  properties:
                    industry:
                      anyOf:
                        - type: string
                          maxLength: 500
                        - type: array
                          items:
                            anyOf:
                              - type: string
                                maxLength: 500
                              - type: object
                                properties:
                                  status:
                                    type: string
                                    enum:
                                      - include
                                      - exclude
                                    description: >-
                                      `include` matches the value; `exclude`
                                      removes profiles carrying it (includes OR
                                      together, every exclude applies).
                                  value:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      The filter value (max 500 chars); for
                                      enum-backed fields use a value GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool)
                                      lists for the field — other values match
                                      nothing.
                                  label:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      Optional display label as returned by GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool);
                                      accepted and ignored.
                                  liOrgId:
                                    type: string
                                    minLength: 1
                                    maxLength: 32
                                    description: >-
                                      Company filters only: the company's
                                      LinkedIn organization id, as the company
                                      typeahead returns it.
                                  domain:
                                    type: string
                                    minLength: 1
                                    maxLength: 500
                                    description: >-
                                      Company filters only: the company's
                                      website domain (e.g. stripe.com).
                                required:
                                  - status
                                  - value
                          maxItems: 1000
                      description: >-
                        Industry of the person themselves; include/exclude
                        entries whose `value` is one of the 147 `industry`
                        values from GET /prospects/filter-options (the
                        get_people_search_filter_options tool) (e.g. financial
                        services). Include values are OR-joined and every
                        exclude applies; at most 1000 entries. A bare string or
                        an array of strings are includes.
                    job_title_levels:
                      anyOf:
                        - type: string
                          maxLength: 500
                        - type: array
                          items:
                            anyOf:
                              - type: string
                                maxLength: 500
                              - type: object
                                properties:
                                  status:
                                    type: string
                                    enum:
                                      - include
                                      - exclude
                                    description: >-
                                      `include` matches the value; `exclude`
                                      removes profiles carrying it (includes OR
                                      together, every exclude applies).
                                  value:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      The filter value (max 500 chars); for
                                      enum-backed fields use a value GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool)
                                      lists for the field — other values match
                                      nothing.
                                  label:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      Optional display label as returned by GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool);
                                      accepted and ignored.
                                  liOrgId:
                                    type: string
                                    minLength: 1
                                    maxLength: 32
                                    description: >-
                                      Company filters only: the company's
                                      LinkedIn organization id, as the company
                                      typeahead returns it.
                                  domain:
                                    type: string
                                    minLength: 1
                                    maxLength: 500
                                    description: >-
                                      Company filters only: the company's
                                      website domain (e.g. stripe.com).
                                required:
                                  - status
                                  - value
                          maxItems: 1000
                      description: >-
                        Seniority of the current job title; entries with `value`
                        one of exactly: cxo, vp, director, manager, senior,
                        entry, owner, partner, training, unpaid (the
                        `job_title_levels` list in GET /prospects/filter-options
                        (the get_people_search_filter_options tool)). Include
                        values are OR-joined and every exclude applies; at most
                        1000 entries. A bare string or an array of strings are
                        includes.
                    job_title_role:
                      anyOf:
                        - type: string
                          maxLength: 500
                        - type: array
                          items:
                            anyOf:
                              - type: string
                                maxLength: 500
                              - type: object
                                properties:
                                  status:
                                    type: string
                                    enum:
                                      - include
                                      - exclude
                                    description: >-
                                      `include` matches the value; `exclude`
                                      removes profiles carrying it (includes OR
                                      together, every exclude applies).
                                  value:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      The filter value (max 500 chars); for
                                      enum-backed fields use a value GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool)
                                      lists for the field — other values match
                                      nothing.
                                  label:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      Optional display label as returned by GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool);
                                      accepted and ignored.
                                  liOrgId:
                                    type: string
                                    minLength: 1
                                    maxLength: 32
                                    description: >-
                                      Company filters only: the company's
                                      LinkedIn organization id, as the company
                                      typeahead returns it.
                                  domain:
                                    type: string
                                    minLength: 1
                                    maxLength: 500
                                    description: >-
                                      Company filters only: the company's
                                      website domain (e.g. stripe.com).
                                required:
                                  - status
                                  - value
                          maxItems: 1000
                      description: >-
                        Department of the current job title; entries with
                        `value` one of the 24 `job_title_role` values in GET
                        /prospects/filter-options (the
                        get_people_search_filter_options tool) (e.g.
                        engineering, sales, finance); `jobTitleRoleToSubRole` on
                        GET /business/prospects/filter-options lists each role's
                        sub-roles, which are no longer a filter. Include values
                        are OR-joined and every exclude applies; at most 1000
                        entries. A bare string or an array of strings are
                        includes.
                    job_company_size:
                      anyOf:
                        - type: string
                          maxLength: 500
                        - type: array
                          items:
                            anyOf:
                              - type: string
                                maxLength: 500
                              - type: object
                                properties:
                                  status:
                                    type: string
                                    enum:
                                      - include
                                      - exclude
                                    description: >-
                                      `include` matches the value; `exclude`
                                      removes profiles carrying it (includes OR
                                      together, every exclude applies).
                                  value:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      The filter value (max 500 chars); for
                                      enum-backed fields use a value GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool)
                                      lists for the field — other values match
                                      nothing.
                                  label:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      Optional display label as returned by GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool);
                                      accepted and ignored.
                                  liOrgId:
                                    type: string
                                    minLength: 1
                                    maxLength: 32
                                    description: >-
                                      Company filters only: the company's
                                      LinkedIn organization id, as the company
                                      typeahead returns it.
                                  domain:
                                    type: string
                                    minLength: 1
                                    maxLength: 500
                                    description: >-
                                      Company filters only: the company's
                                      website domain (e.g. stripe.com).
                                required:
                                  - status
                                  - value
                          maxItems: 1000
                      description: >-
                        Headcount bracket of the current employer; entries with
                        `value` one of exactly: 1-10, 11-50, 51-200, 201-500,
                        501-1000, 1001-5000, 5001-10000, 10001+ — brackets only,
                        so use `rangeInputs.job_company_employee_count` for an
                        arbitrary headcount range. Each bracket is searched as
                        its own band: include values are OR-joined and every
                        exclude applies; at most 1000 entries. A bare string or
                        an array of strings are includes.
                    job_company_inferred_revenue:
                      anyOf:
                        - type: string
                          maxLength: 500
                        - type: array
                          items:
                            anyOf:
                              - type: string
                                maxLength: 500
                              - type: object
                                properties:
                                  status:
                                    type: string
                                    enum:
                                      - include
                                      - exclude
                                    description: >-
                                      `include` matches the value; `exclude`
                                      removes profiles carrying it (includes OR
                                      together, every exclude applies).
                                  value:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      The filter value (max 500 chars); for
                                      enum-backed fields use a value GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool)
                                      lists for the field — other values match
                                      nothing.
                                  label:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      Optional display label as returned by GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool);
                                      accepted and ignored.
                                  liOrgId:
                                    type: string
                                    minLength: 1
                                    maxLength: 32
                                    description: >-
                                      Company filters only: the company's
                                      LinkedIn organization id, as the company
                                      typeahead returns it.
                                  domain:
                                    type: string
                                    minLength: 1
                                    maxLength: 500
                                    description: >-
                                      Company filters only: the company's
                                      website domain (e.g. stripe.com).
                                required:
                                  - status
                                  - value
                          maxItems: 1000
                      description: >-
                        Inferred annual revenue bracket of the current employer;
                        entries with `value` one of exactly: $0-$1m, $1m-$10m,
                        $10m-$25m, $25m-$50m, $50m-$100m, $100m-$250m,
                        $250m-$500m, $500m-$1b, $1b-$10b, $10b+ (matched
                        case-insensitively, so $1M-$10M also works). Each
                        bracket is searched as its own band: include values are
                        OR-joined and every exclude applies; at most 1000
                        entries. A bare string or an array of strings are
                        includes.
                    job_company_industry:
                      anyOf:
                        - type: string
                          maxLength: 500
                        - type: array
                          items:
                            anyOf:
                              - type: string
                                maxLength: 500
                              - type: object
                                properties:
                                  status:
                                    type: string
                                    enum:
                                      - include
                                      - exclude
                                    description: >-
                                      `include` matches the value; `exclude`
                                      removes profiles carrying it (includes OR
                                      together, every exclude applies).
                                  value:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      The filter value (max 500 chars); for
                                      enum-backed fields use a value GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool)
                                      lists for the field — other values match
                                      nothing.
                                  label:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      Optional display label as returned by GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool);
                                      accepted and ignored.
                                  liOrgId:
                                    type: string
                                    minLength: 1
                                    maxLength: 32
                                    description: >-
                                      Company filters only: the company's
                                      LinkedIn organization id, as the company
                                      typeahead returns it.
                                  domain:
                                    type: string
                                    minLength: 1
                                    maxLength: 500
                                    description: >-
                                      Company filters only: the company's
                                      website domain (e.g. stripe.com).
                                required:
                                  - status
                                  - value
                          maxItems: 1000
                      description: >-
                        Industry of the current employer; entries with `value`
                        one of the same 147 industry values, listed under
                        `job_company_industry` in GET /prospects/filter-options
                        (the get_people_search_filter_options tool). Include
                        values are OR-joined and every exclude applies; at most
                        1000 entries. A bare string or an array of strings are
                        includes.
                    job_company_location_country:
                      anyOf:
                        - type: string
                          maxLength: 500
                        - type: array
                          items:
                            anyOf:
                              - type: string
                                maxLength: 500
                              - type: object
                                properties:
                                  status:
                                    type: string
                                    enum:
                                      - include
                                      - exclude
                                    description: >-
                                      `include` matches the value; `exclude`
                                      removes profiles carrying it (includes OR
                                      together, every exclude applies).
                                  value:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      The filter value (max 500 chars); for
                                      enum-backed fields use a value GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool)
                                      lists for the field — other values match
                                      nothing.
                                  label:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      Optional display label as returned by GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool);
                                      accepted and ignored.
                                  liOrgId:
                                    type: string
                                    minLength: 1
                                    maxLength: 32
                                    description: >-
                                      Company filters only: the company's
                                      LinkedIn organization id, as the company
                                      typeahead returns it.
                                  domain:
                                    type: string
                                    minLength: 1
                                    maxLength: 500
                                    description: >-
                                      Company filters only: the company's
                                      website domain (e.g. stripe.com).
                                required:
                                  - status
                                  - value
                          maxItems: 1000
                      description: >-
                        Country of the current employer's headquarters; entries
                        with a lower-case `value` from the 249
                        `job_company_location_country` values in GET
                        /prospects/filter-options (the
                        get_people_search_filter_options tool) (e.g. united
                        states, germany) — country NAMES, never ISO codes.
                        Include values are OR-joined and every exclude applies;
                        at most 1000 entries. A bare string or an array of
                        strings are includes.
                    job_company_location_region:
                      anyOf:
                        - type: string
                          maxLength: 500
                        - type: array
                          items:
                            anyOf:
                              - type: string
                                maxLength: 500
                              - type: object
                                properties:
                                  status:
                                    type: string
                                    enum:
                                      - include
                                      - exclude
                                    description: >-
                                      `include` matches the value; `exclude`
                                      removes profiles carrying it (includes OR
                                      together, every exclude applies).
                                  value:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      The filter value (max 500 chars); for
                                      enum-backed fields use a value GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool)
                                      lists for the field — other values match
                                      nothing.
                                  label:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      Optional display label as returned by GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool);
                                      accepted and ignored.
                                  liOrgId:
                                    type: string
                                    minLength: 1
                                    maxLength: 32
                                    description: >-
                                      Company filters only: the company's
                                      LinkedIn organization id, as the company
                                      typeahead returns it.
                                  domain:
                                    type: string
                                    minLength: 1
                                    maxLength: 500
                                    description: >-
                                      Company filters only: the company's
                                      website domain (e.g. stripe.com).
                                required:
                                  - status
                                  - value
                          maxItems: 1000
                      description: >-
                        Region or state of the current employer's headquarters;
                        entries with a free-text lower-case `value` such as
                        california — resolve names with GET
                        /prospects/autocomplete?field=region. A bare string or
                        an array of strings are includes.
                    experience.title.levels:
                      anyOf:
                        - type: string
                          maxLength: 500
                        - type: array
                          items:
                            anyOf:
                              - type: string
                                maxLength: 500
                              - type: object
                                properties:
                                  status:
                                    type: string
                                    enum:
                                      - include
                                      - exclude
                                    description: >-
                                      `include` matches the value; `exclude`
                                      removes profiles carrying it (includes OR
                                      together, every exclude applies).
                                  value:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      The filter value (max 500 chars); for
                                      enum-backed fields use a value GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool)
                                      lists for the field — other values match
                                      nothing.
                                  label:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      Optional display label as returned by GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool);
                                      accepted and ignored.
                                  liOrgId:
                                    type: string
                                    minLength: 1
                                    maxLength: 32
                                    description: >-
                                      Company filters only: the company's
                                      LinkedIn organization id, as the company
                                      typeahead returns it.
                                  domain:
                                    type: string
                                    minLength: 1
                                    maxLength: 500
                                    description: >-
                                      Company filters only: the company's
                                      website domain (e.g. stripe.com).
                                required:
                                  - status
                                  - value
                          maxItems: 1000
                      description: >-
                        Seniority held in a PAST job (the current job does not
                        count), matched on the past job's title words; entries
                        with `value` one of exactly: cxo, vp, director, manager,
                        senior, entry, owner, partner, training, unpaid. Next to
                        `experience.title.role` both must hold in the same past
                        job. Include values are OR-joined and every exclude
                        applies; at most 1000 entries. A bare string or an array
                        of strings are includes.
                    experience.title.role:
                      anyOf:
                        - type: string
                          maxLength: 500
                        - type: array
                          items:
                            anyOf:
                              - type: string
                                maxLength: 500
                              - type: object
                                properties:
                                  status:
                                    type: string
                                    enum:
                                      - include
                                      - exclude
                                    description: >-
                                      `include` matches the value; `exclude`
                                      removes profiles carrying it (includes OR
                                      together, every exclude applies).
                                  value:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      The filter value (max 500 chars); for
                                      enum-backed fields use a value GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool)
                                      lists for the field — other values match
                                      nothing.
                                  label:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      Optional display label as returned by GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool);
                                      accepted and ignored.
                                  liOrgId:
                                    type: string
                                    minLength: 1
                                    maxLength: 32
                                    description: >-
                                      Company filters only: the company's
                                      LinkedIn organization id, as the company
                                      typeahead returns it.
                                  domain:
                                    type: string
                                    minLength: 1
                                    maxLength: 500
                                    description: >-
                                      Company filters only: the company's
                                      website domain (e.g. stripe.com).
                                required:
                                  - status
                                  - value
                          maxItems: 1000
                      description: >-
                        Department of a PAST job (the current job does not
                        count), matched on the past job's title words; entries
                        with `value` one of the 24 `experience.title.role`
                        values in GET /prospects/filter-options (the
                        get_people_search_filter_options tool) — the same list
                        as `job_title_role`. Include values are OR-joined and
                        every exclude applies; at most 1000 entries. A bare
                        string or an array of strings are includes.
                    languages.name:
                      anyOf:
                        - type: string
                          maxLength: 500
                        - type: array
                          items:
                            anyOf:
                              - type: string
                                maxLength: 500
                              - type: object
                                properties:
                                  status:
                                    type: string
                                    enum:
                                      - include
                                      - exclude
                                    description: >-
                                      `include` matches the value; `exclude`
                                      removes profiles carrying it (includes OR
                                      together, every exclude applies).
                                  value:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      The filter value (max 500 chars); for
                                      enum-backed fields use a value GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool)
                                      lists for the field — other values match
                                      nothing.
                                  label:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      Optional display label as returned by GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool);
                                      accepted and ignored.
                                  liOrgId:
                                    type: string
                                    minLength: 1
                                    maxLength: 32
                                    description: >-
                                      Company filters only: the company's
                                      LinkedIn organization id, as the company
                                      typeahead returns it.
                                  domain:
                                    type: string
                                    minLength: 1
                                    maxLength: 500
                                    description: >-
                                      Company filters only: the company's
                                      website domain (e.g. stripe.com).
                                required:
                                  - status
                                  - value
                          maxItems: 1000
                      description: >-
                        Languages the person lists; entries with a lower-case
                        `value` from the 187 `languages.name` values in GET
                        /prospects/filter-options (the
                        get_people_search_filter_options tool) (e.g. english,
                        german) — language NAMES, never ISO codes. Common other
                        names are read as the listed language: farsi as persian,
                        bangla as bengali, panjabi as punjabi, slovene as
                        slovenian, chinese and mandarin as putonghua (Mandarin),
                        tagalog and filipino as Tagalog/Filipino. Include values
                        are OR-joined and every exclude applies; at most 1000
                        entries. A bare string or an array of strings are
                        includes.
                    location_country:
                      anyOf:
                        - type: string
                          maxLength: 500
                        - type: array
                          items:
                            anyOf:
                              - type: string
                                maxLength: 500
                              - type: object
                                properties:
                                  status:
                                    type: string
                                    enum:
                                      - include
                                      - exclude
                                    description: >-
                                      `include` matches the value; `exclude`
                                      removes profiles carrying it (includes OR
                                      together, every exclude applies).
                                  value:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      The filter value (max 500 chars); for
                                      enum-backed fields use a value GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool)
                                      lists for the field — other values match
                                      nothing.
                                  label:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      Optional display label as returned by GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool);
                                      accepted and ignored.
                                  liOrgId:
                                    type: string
                                    minLength: 1
                                    maxLength: 32
                                    description: >-
                                      Company filters only: the company's
                                      LinkedIn organization id, as the company
                                      typeahead returns it.
                                  domain:
                                    type: string
                                    minLength: 1
                                    maxLength: 500
                                    description: >-
                                      Company filters only: the company's
                                      website domain (e.g. stripe.com).
                                required:
                                  - status
                                  - value
                          maxItems: 1000
                      description: >-
                        Country the person lives in; entries with a lower-case
                        `value` from the 249 `location_country` values in GET
                        /prospects/filter-options (the
                        get_people_search_filter_options tool) (e.g. united
                        states, united kingdom) — country NAMES, never ISO
                        codes. Include values are OR-joined and every exclude
                        applies; at most 1000 entries. A bare string or an array
                        of strings are includes.
                    location_region:
                      anyOf:
                        - type: string
                          maxLength: 500
                        - type: array
                          items:
                            anyOf:
                              - type: string
                                maxLength: 500
                              - type: object
                                properties:
                                  status:
                                    type: string
                                    enum:
                                      - include
                                      - exclude
                                    description: >-
                                      `include` matches the value; `exclude`
                                      removes profiles carrying it (includes OR
                                      together, every exclude applies).
                                  value:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      The filter value (max 500 chars); for
                                      enum-backed fields use a value GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool)
                                      lists for the field — other values match
                                      nothing.
                                  label:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      Optional display label as returned by GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool);
                                      accepted and ignored.
                                  liOrgId:
                                    type: string
                                    minLength: 1
                                    maxLength: 32
                                    description: >-
                                      Company filters only: the company's
                                      LinkedIn organization id, as the company
                                      typeahead returns it.
                                  domain:
                                    type: string
                                    minLength: 1
                                    maxLength: 500
                                    description: >-
                                      Company filters only: the company's
                                      website domain (e.g. stripe.com).
                                required:
                                  - status
                                  - value
                          maxItems: 1000
                      description: >-
                        Region or state the person lives in; entries with a
                        free-text lower-case `value` such as california —
                        resolve names with GET
                        /prospects/autocomplete?field=region. A region outside
                        the United States is matched through a table of each
                        country's regions; one the table does not hold is only
                        searched next to a single `location_country`, and
                        otherwise answers 422 FILTER_VALUE_UNRESOLVED. A bare
                        string or an array of strings are includes.
                    education.degrees:
                      anyOf:
                        - type: string
                          maxLength: 500
                        - type: array
                          items:
                            anyOf:
                              - type: string
                                maxLength: 500
                              - type: object
                                properties:
                                  status:
                                    type: string
                                    enum:
                                      - include
                                      - exclude
                                    description: >-
                                      `include` matches the value; `exclude`
                                      removes profiles carrying it (includes OR
                                      together, every exclude applies).
                                  value:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      The filter value (max 500 chars); for
                                      enum-backed fields use a value GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool)
                                      lists for the field — other values match
                                      nothing.
                                  label:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      Optional display label as returned by GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool);
                                      accepted and ignored.
                                  liOrgId:
                                    type: string
                                    minLength: 1
                                    maxLength: 32
                                    description: >-
                                      Company filters only: the company's
                                      LinkedIn organization id, as the company
                                      typeahead returns it.
                                  domain:
                                    type: string
                                    minLength: 1
                                    maxLength: 500
                                    description: >-
                                      Company filters only: the company's
                                      website domain (e.g. stripe.com).
                                required:
                                  - status
                                  - value
                          maxItems: 1000
                      description: >-
                        Degrees held; entries with `value` one of the 171
                        `education.degrees` values in GET
                        /prospects/filter-options (the
                        get_people_search_filter_options tool) (e.g. bachelors,
                        masters, master of business administration). Include
                        values are OR-joined; include only, so an exclude entry
                        is dropped (the Business API refuses it with 422
                        VALIDATION_FAILED); at most 1000 entries. A bare string
                        or an array of strings are includes.
                    job_company_name:
                      anyOf:
                        - type: string
                          maxLength: 500
                        - type: array
                          items:
                            anyOf:
                              - type: string
                                maxLength: 500
                              - type: object
                                properties:
                                  status:
                                    type: string
                                    enum:
                                      - include
                                      - exclude
                                    description: >-
                                      `include` matches the value; `exclude`
                                      removes profiles carrying it (includes OR
                                      together, every exclude applies).
                                  value:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      The filter value (max 500 chars); for
                                      enum-backed fields use a value GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool)
                                      lists for the field — other values match
                                      nothing.
                                  label:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      Optional display label as returned by GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool);
                                      accepted and ignored.
                                  liOrgId:
                                    type: string
                                    minLength: 1
                                    maxLength: 32
                                    description: >-
                                      Company filters only: the company's
                                      LinkedIn organization id, as the company
                                      typeahead returns it.
                                  domain:
                                    type: string
                                    minLength: 1
                                    maxLength: 500
                                    description: >-
                                      Company filters only: the company's
                                      website domain (e.g. stripe.com).
                                required:
                                  - status
                                  - value
                          maxItems: 1000
                      description: >-
                        The current employer, matched by the company itself:
                        send entries `{ status, value, liOrgId?, domain? }`
                        where `value` is the company name and `liOrgId` (its
                        LinkedIn organization id) or `domain` identify it. An
                        entry with only a name matches every company with
                        exactly that name. A bare string or an array of strings
                        are includes by name. A field none of whose companies
                        can be identified answers 422 FILTER_VALUE_UNRESOLVED;
                        unidentified ones next to identified ones are dropped.
                    job_company_website:
                      anyOf:
                        - type: string
                          maxLength: 500
                        - type: array
                          items:
                            anyOf:
                              - type: string
                                maxLength: 500
                              - type: object
                                properties:
                                  status:
                                    type: string
                                    enum:
                                      - include
                                      - exclude
                                    description: >-
                                      `include` matches the value; `exclude`
                                      removes profiles carrying it (includes OR
                                      together, every exclude applies).
                                  value:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      The filter value (max 500 chars); for
                                      enum-backed fields use a value GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool)
                                      lists for the field — other values match
                                      nothing.
                                  label:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      Optional display label as returned by GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool);
                                      accepted and ignored.
                                  liOrgId:
                                    type: string
                                    minLength: 1
                                    maxLength: 32
                                    description: >-
                                      Company filters only: the company's
                                      LinkedIn organization id, as the company
                                      typeahead returns it.
                                  domain:
                                    type: string
                                    minLength: 1
                                    maxLength: 500
                                    description: >-
                                      Company filters only: the company's
                                      website domain (e.g. stripe.com).
                                required:
                                  - status
                                  - value
                          maxItems: 1000
                      description: >-
                        Website domain of the current employer (e.g. stripe.com
                        — scheme, www and trailing slash are stripped); same
                        value shapes as `job_company_name`; resolve with GET
                        /prospects/autocomplete?field=website.
                    linkedin_url:
                      anyOf:
                        - type: string
                          maxLength: 500
                        - type: array
                          items:
                            anyOf:
                              - type: string
                                maxLength: 500
                              - type: object
                                properties:
                                  status:
                                    type: string
                                    enum:
                                      - include
                                      - exclude
                                    description: >-
                                      `include` matches the value; `exclude`
                                      removes profiles carrying it (includes OR
                                      together, every exclude applies).
                                  value:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      The filter value (max 500 chars); for
                                      enum-backed fields use a value GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool)
                                      lists for the field — other values match
                                      nothing.
                                  label:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      Optional display label as returned by GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool);
                                      accepted and ignored.
                                  liOrgId:
                                    type: string
                                    minLength: 1
                                    maxLength: 32
                                    description: >-
                                      Company filters only: the company's
                                      LinkedIn organization id, as the company
                                      typeahead returns it.
                                  domain:
                                    type: string
                                    minLength: 1
                                    maxLength: 500
                                    description: >-
                                      Company filters only: the company's
                                      website domain (e.g. stripe.com).
                                required:
                                  - status
                                  - value
                          maxItems: 1000
                      description: >-
                        A LinkedIn profile, matched by its profile slug (older
                        slugs of the same person match too): a profile URL in
                        any form (scheme, www. or a country subdomain, a
                        trailing slash or query string and letter case are
                        ignored), `in/<slug>` or the bare slug. A string, an
                        array of profiles that are OR-joined, or include/exclude
                        entries ({ status, value }); every exclude applies, at
                        most 1000 entries. Includes none of which names a
                        profile answer 422 FILTER_VALUE_UNRESOLVED.
                    experience.company.name:
                      anyOf:
                        - type: string
                          minLength: 1
                          maxLength: 500
                        - type: array
                          items:
                            anyOf:
                              - type: string
                                minLength: 1
                                maxLength: 500
                              - type: object
                                properties:
                                  value:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      The filter value (max 500 chars); for
                                      enum-backed fields use a value GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool)
                                      lists for the field — other values match
                                      nothing.
                                  label:
                                    type: string
                                    maxLength: 500
                                    description: >-
                                      Optional display label as returned by GET
                                      /prospects/filter-options (the
                                      get_people_search_filter_options tool);
                                      accepted and ignored.
                                  liOrgId:
                                    type: string
                                    minLength: 1
                                    maxLength: 32
                                    description: >-
                                      Company filters only: the company's
                                      LinkedIn organization id, as the company
                                      typeahead returns it.
                                  domain:
                                    type: string
                                    minLength: 1
                                    maxLength: 500
                                    description: >-
                                      Company filters only: the company's
                                      website domain (e.g. stripe.com).
                                  status:
                                    type: string
                                    enum:
                                      - include
                                required:
                                  - value
                                  - status
                          maxItems: 1000
                      description: >-
                        A PAST employer, matched by the company itself the same
                        way as `job_company_name` (`{ status: include, value,
                        liOrgId?, domain? }` entries, or names as a string or an
                        array). Include only.
                    full_name:
                      anyOf:
                        - type: string
                        - type: number
                        - type: boolean
                        - type: array
                          items:
                            type: string
                      description: >-
                        Free text, matched FUZZILY against the person's name
                        (e.g. Ada Nwosu also finds close spellings), in any
                        case. A string, or an array of names that are OR-joined.
                    first_name:
                      anyOf:
                        - type: string
                        - type: number
                        - type: boolean
                        - type: array
                          items:
                            type: string
                      description: >-
                        Free text, matched fuzzily; sent next to `last_name` the
                        two are matched as one full name. A string, or an array
                        of names that are OR-joined. Cannot be stored in a saved
                        search (422 SAVED_SEARCH_FILTERS_UNSUPPORTED).
                    last_name:
                      anyOf:
                        - type: string
                        - type: number
                        - type: boolean
                        - type: array
                          items:
                            type: string
                      description: >-
                        Free text, matched fuzzily; sent next to `first_name`
                        the two are matched as one full name. A string, or an
                        array of names that are OR-joined. Cannot be stored in a
                        saved search (422 SAVED_SEARCH_FILTERS_UNSUPPORTED).
                    work_email:
                      anyOf:
                        - type: string
                          minLength: 1
                          maxLength: 254
                        - type: array
                          items:
                            type: string
                            minLength: 1
                            maxLength: 254
                          maxItems: 10
                      description: >-
                        An email address: the provider's best match for it is
                        looked up, then searched with every other filter. A
                        string, or an array of up to 10 addresses that are
                        OR-joined; when none of them finds anyone the search
                        gives no rows and bills nothing. Work and personal
                        addresses are looked up alike (`personal_emails` works
                        the same way); sent with `personal_emails` or
                        `mobile_phone`, the person must have all of them. A
                        field none of whose values is an email address answers
                        422 FILTER_VALUE_UNRESOLVED.
                    personal_emails:
                      anyOf:
                        - type: string
                          minLength: 1
                          maxLength: 254
                        - type: array
                          items:
                            type: string
                            minLength: 1
                            maxLength: 254
                          maxItems: 10
                      description: >-
                        An email address, looked up exactly as `work_email` is:
                        the two are interchangeable. A string, or an array of up
                        to 10 addresses that are OR-joined; sent with
                        `work_email` or `mobile_phone`, the person must have all
                        of them.
                    mobile_phone:
                      anyOf:
                        - type: string
                          minLength: 1
                          maxLength: 254
                        - type: array
                          items:
                            type: string
                            minLength: 1
                            maxLength: 254
                          maxItems: 10
                      description: >-
                        A phone number in E.164 with the leading + (e.g.
                        +14155552671); one without a country code is read as a
                        US number. The provider's best match for it is looked
                        up, then searched with every other filter; a company's
                        number finds nobody. A string, or an array of up to 10
                        numbers that are OR-joined; when none of them finds
                        anyone the search gives no rows and bills nothing. Sent
                        with `work_email` or `personal_emails`, the person must
                        have all of them. A field none of whose values is a
                        phone number answers 422 FILTER_VALUE_UNRESOLVED.
                    job_title:
                      anyOf:
                        - type: string
                        - type: number
                        - type: boolean
                        - type: array
                          items:
                            type: string
                      description: >-
                        Current job title (e.g. chief financial officer),
                        matched exactly in any case together with its common
                        forms (cfo, vp of sales / vice president of sales / vp
                        sales); a string or an array of titles — use `keywords`
                        for partial matches and GET
                        /prospects/autocomplete?field=title for suggestions.
                    job_company_location_name:
                      anyOf:
                        - type: string
                        - type: number
                        - type: boolean
                        - type: array
                          items:
                            type: string
                      description: >-
                        City of the current employer's headquarters as a
                        location name (e.g. san francisco, california, united
                        states), searched as the area the city covers; resolve
                        with GET /prospects/autocomplete?field=location.
                    location_name:
                      anyOf:
                        - type: string
                        - type: number
                        - type: boolean
                        - type: array
                          items:
                            type: string
                      description: >-
                        City the person lives in, as a location name (e.g.
                        london, greater london, united kingdom), searched as the
                        area the city covers, so some suburbs count; resolve
                        with GET /prospects/autocomplete?field=location.
                    education.school.name:
                      anyOf:
                        - type: string
                        - type: number
                        - type: boolean
                        - type: array
                          items:
                            type: string
                      description: >-
                        Lower-case name of a school attended (e.g. stanford
                        university); resolve with GET
                        /prospects/autocomplete?field=school.
                    experience.title.name:
                      anyOf:
                        - type: string
                        - type: number
                        - type: boolean
                        - type: array
                          items:
                            type: string
                      description: >-
                        Exact lower-case title held at any past job; a string or
                        an array of titles.
                    experience.company.website:
                      anyOf:
                        - type: string
                        - type: number
                        - type: boolean
                        - type: array
                          items:
                            type: string
                      description: >-
                        Free text: the website host of any past employer (e.g.
                        stripe.com). The scheme, www. and a trailing slash are
                        stripped and both the host+path and host-only forms are
                        tried, so a full URL still matches; a host the provider
                        does not store matches nothing. A string, or an array of
                        hosts that are OR-joined.
                    job_start_date:
                      anyOf:
                        - type: string
                        - type: number
                        - type: boolean
                        - type: array
                          items:
                            type: string
                      description: >-
                        Months in current role: finds people who started their
                        current role within the last N months. Send N as a
                        number (6 finds people who started in the last 6
                        months), or the earliest start month as YYYY-MM or
                        YYYY-MM-DD (started on or after the first day of that
                        month); with several values the earliest start applies,
                        and 0 is no filter.
                    skills:
                      anyOf:
                        - type: string
                        - type: number
                        - type: boolean
                        - type: array
                          items:
                            type: string
                      description: >-
                        Lower-case skill (e.g. python); a string, or an array of
                        skills any of which may match — resolve with GET
                        /prospects/autocomplete?field=skill.
                    certifications.name:
                      anyOf:
                        - type: string
                        - type: number
                        - type: boolean
                        - type: array
                          items:
                            type: string
                      description: >-
                        Lower-case certification name (e.g. pmp); a string or an
                        array.
                    keywords:
                      type: array
                      items:
                        type: string
                        minLength: 1
                        maxLength: 200
                      maxItems: 50
                      description: >-
                        Free text: up to 50 terms (200 chars each), each matched
                        against the current job title only and OR-joined, so any
                        one may match. Terms match WHOLE words in any case
                        (growth matches Head of Growth, not Growthwise); plural
                        and related forms are added (engineer also finds
                        engineers and engineering), and * or ? are ignored. A
                        term with no text other than wildcards is ignored, and a
                        list holding only such terms does not count as search
                        criteria.
                    excludedKeywords:
                      type: array
                      items:
                        type: string
                        minLength: 1
                        maxLength: 200
                      maxItems: 50
                      description: >-
                        Free text: up to 50 terms (200 chars each) using exactly
                        the same matching rules as `keywords`, but REMOVING
                        every prospect whose current job title matches any one
                        of them — keywords [engineer] with excludedKeywords
                        [infrastructure] keeps Engineer VP and drops Engineer VP
                        Infrastructure. It reads the whole job title, so it also
                        removes rows matched by `job_title`. A term with no text
                        other than wildcards is ignored, since it would remove
                        every prospect that has a job title. Exclusions only
                        narrow a result set: on their own they are not search
                        criteria and a request carrying nothing else is
                        rejected.
                    rangeInputs:
                      type: object
                      properties:
                        job_company_employee_count:
                          type: object
                          properties:
                            min:
                              type: number
                              description: >-
                                Inclusive lower bound (0 is treated as no
                                bound).
                            max:
                              type: number
                              description: >-
                                Inclusive upper bound (0 is treated as no
                                bound).
                          description: >-
                            Headcount of the current employer; accepted values
                            are whole numbers and both bounds are inclusive. A
                            min of 0 is ignored rather than applied, so cap
                            headcount with max alone.
                        inferred_years_experience:
                          type: object
                          properties:
                            min:
                              type: number
                              description: >-
                                Inclusive lower bound (0 is treated as no
                                bound).
                            max:
                              type: number
                              description: >-
                                Inclusive upper bound (0 is treated as no
                                bound).
                          description: >-
                            Total years of professional experience; accepted
                            values are whole numbers of years and both bounds
                            are inclusive. A min of 0 is ignored rather than
                            applied.
                        job_company_total_funding_raised:
                          type: object
                          properties:
                            min:
                              type: number
                              description: >-
                                Inclusive lower bound (0 is treated as no
                                bound).
                            max:
                              type: number
                              description: >-
                                Inclusive upper bound (0 is treated as no
                                bound).
                          description: >-
                            Total funding raised by the current employer;
                            accepted values are whole US dollars, not millions
                            (10000000 means $10M), and both bounds are
                            inclusive. A min of 0 is ignored rather than
                            applied.
                      description: >-
                        Numeric range filters, each key one of exactly:
                        `job_company_employee_count`,
                        `inferred_years_experience`,
                        `job_company_total_funding_raised` (any other key is
                        rejected). Each value is `{ min?, max? }` with at least
                        one bound and min <= max; several ranges AND with each
                        other and with every other filter.
                    company_filters:
                      type: object
                      properties:
                        status:
                          type: array
                          items:
                            type: object
                            properties:
                              label:
                                type: string
                                minLength: 1
                                maxLength: 500
                                description: >-
                                  Display label for the value (required; repeat
                                  the value when you have no label).
                              status:
                                type: string
                                enum:
                                  - include
                                  - exclude
                                description: >-
                                  `include` matches the value; `exclude` removes
                                  companies carrying it (includes OR together,
                                  every exclude applies).
                              value:
                                type: string
                                enum:
                                  - active
                                  - acquired
                                  - closed
                            required:
                              - label
                              - status
                              - value
                          description: >-
                            Entries whose `value` is one of exactly: active,
                            acquired, closed. Include values are OR-joined and
                            every exclude value is removed; this filter ANDs
                            with the others.
                        tags:
                          type: array
                          items:
                            type: object
                            properties:
                              label:
                                type: string
                                minLength: 1
                                maxLength: 500
                                description: >-
                                  Display label for the value (required; repeat
                                  the value when you have no label).
                              status:
                                type: string
                                enum:
                                  - include
                                  - exclude
                                description: >-
                                  `include` matches the value; `exclude` removes
                                  companies carrying it (includes OR together,
                                  every exclude applies).
                              value:
                                type: string
                                enum:
                                  - venture-backed-startup
                                  - is-school
                                  - is-government
                                  - raised-from-top-vc
                            required:
                              - label
                              - status
                              - value
                          description: >-
                            Entries whose `value` is one of exactly:
                            venture-backed-startup, is-school, is-government,
                            raised-from-top-vc. Include values are OR-joined and
                            every exclude value is removed; this filter ANDs
                            with the others.
                        acceleratorsV2:
                          type: array
                          items:
                            type: object
                            properties:
                              value:
                                type: string
                                minLength: 1
                                maxLength: 500
                                description: >-
                                  The filter value — see the field's own
                                  description for its vocabulary.
                              label:
                                type: string
                                minLength: 1
                                maxLength: 500
                                description: >-
                                  Display label for the value (required; repeat
                                  the value when you have no label).
                              status:
                                type: string
                                enum:
                                  - include
                                  - exclude
                                description: >-
                                  `include` matches the value; `exclude` removes
                                  companies carrying it (includes OR together,
                                  every exclude applies).
                            required:
                              - value
                              - label
                              - status
                          description: >-
                            Accelerator entries whose `value` is the
                            `acceleratorSlug` from `accelerators` in GET
                            /companies/filter-options (e.g. ycombinator,
                            techstars); the `acceleratorName` in the same row is
                            NOT accepted. An off-list value is refused with 422
                            SEARCH_FILTERS_INVALID, whose `details.param` names
                            this filter and `details.values` the entry. Include
                            values are OR-joined (provider `anyOf`) and every
                            exclude value is removed (`noneOf`); this filter
                            ANDs with the others.
                        stage:
                          type: array
                          items:
                            type: object
                            properties:
                              label:
                                type: string
                                minLength: 1
                                maxLength: 500
                                description: >-
                                  Display label for the value (required; repeat
                                  the value when you have no label).
                              status:
                                type: string
                                enum:
                                  - include
                                  - exclude
                                description: >-
                                  `include` matches the value; `exclude` removes
                                  companies carrying it (includes OR together,
                                  every exclude applies).
                              value:
                                type: string
                                enum:
                                  - no_funding_yet
                                  - pre_seed
                                  - seed
                                  - series_a
                                  - series_b
                                  - series_c
                                  - series_d
                                  - series_e
                                  - series_f
                                  - series_g
                                  - series_h
                                  - series_i
                                  - series_j
                                  - private_equity
                                  - venture_other
                                  - public
                                  - acquired
                                  - closed
                                  - unknown
                            required:
                              - label
                              - status
                              - value
                          description: >-
                            Entries whose `value` is one of exactly:
                            no_funding_yet, pre_seed, seed, series_a, series_b,
                            series_c, series_d, series_e, series_f, series_g,
                            series_h, series_i, series_j, private_equity,
                            venture_other, public, acquired, closed, unknown.
                            Include values are OR-joined and every exclude value
                            is removed; this filter ANDs with the others.
                        investors:
                          type: array
                          items:
                            type: object
                            properties:
                              value:
                                type: string
                                minLength: 1
                                maxLength: 500
                                description: >-
                                  The filter value — see the field's own
                                  description for its vocabulary.
                              label:
                                type: string
                                minLength: 1
                                maxLength: 500
                                description: >-
                                  Display label for the value (required; repeat
                                  the value when you have no label).
                              status:
                                type: string
                                enum:
                                  - include
                                  - exclude
                                description: >-
                                  `include` matches the value; `exclude` removes
                                  companies carrying it (includes OR together,
                                  every exclude applies).
                            required:
                              - value
                              - label
                              - status
                          description: >-
                            Investor entries whose `value` is the investor's
                            website domain — resolve names with GET
                            /companies/autocomplete?field=company&orgType=investor
                            and send the `domain` from that response, never the
                            investor's name. An off-list value is not rejected:
                            the search comes back empty with no error naming the
                            field, so check the value against the list first.
                            Include values are OR-joined (provider `anyOf`) and
                            every exclude value is removed (`noneOf`); this
                            filter ANDs with the others.
                        technologies:
                          type: array
                          items:
                            type: object
                            properties:
                              value:
                                type: string
                                minLength: 1
                                maxLength: 500
                                description: >-
                                  The filter value — see the field's own
                                  description for its vocabulary.
                              label:
                                type: string
                                minLength: 1
                                maxLength: 500
                                description: >-
                                  Display label for the value (required; repeat
                                  the value when you have no label).
                              status:
                                type: string
                                enum:
                                  - include
                                  - exclude
                                description: >-
                                  `include` matches the value; `exclude` removes
                                  companies carrying it (includes OR together,
                                  every exclude applies).
                            required:
                              - value
                              - label
                              - status
                          description: >-
                            Technology-in-use entries whose `value` is a name
                            from the provider's predefined technology
                            vocabulary, forwarded verbatim, so it must carry the
                            product's own spelling and casing — e.g. Salesforce,
                            Kubernetes, Next.js, Google Analytics, and `AWS` for
                            Amazon Web Services. No endpoint serves this
                            vocabulary yet; the product's own picker offers a
                            curated 141-name subset. An off-list value is
                            refused with 422 SEARCH_FILTERS_INVALID, whose
                            `details.param` names this filter and
                            `details.values` the entry. Include values are
                            OR-joined (provider `anyOf`) and every exclude value
                            is removed (`noneOf`); this filter ANDs with the
                            others.
                        industriesV2:
                          type: array
                          items:
                            type: object
                            properties:
                              value:
                                type: string
                                minLength: 1
                                maxLength: 500
                                description: >-
                                  The filter value — see the field's own
                                  description for its vocabulary.
                              label:
                                type: string
                                minLength: 1
                                maxLength: 500
                                description: >-
                                  Display label for the value (required; repeat
                                  the value when you have no label).
                              status:
                                type: string
                                enum:
                                  - include
                                  - exclude
                                description: >-
                                  `include` matches the value; `exclude` removes
                                  companies carrying it (includes OR together,
                                  every exclude applies).
                            required:
                              - value
                              - label
                              - status
                          description: >-
                            Industry entries whose `value` is one of the
                            `fiberIndustries` values in GET
                            /companies/filter-options, copied exactly as listed
                            (e.g. Software, Finance). An off-list value is
                            refused with 422 SEARCH_FILTERS_INVALID, whose
                            `details.param` names this filter and
                            `details.values` the entry. Include values are
                            OR-joined (provider `anyOf`) and every exclude value
                            is removed (`noneOf`); this filter ANDs with the
                            others.
                        linkedinIndustries:
                          type: array
                          items:
                            type: object
                            properties:
                              value:
                                type: string
                                minLength: 1
                                maxLength: 500
                                description: >-
                                  The filter value — see the field's own
                                  description for its vocabulary.
                              label:
                                type: string
                                minLength: 1
                                maxLength: 500
                                description: >-
                                  Display label for the value (required; repeat
                                  the value when you have no label).
                              status:
                                type: string
                                enum:
                                  - include
                                  - exclude
                                description: >-
                                  `include` matches the value; `exclude` removes
                                  companies carrying it (includes OR together,
                                  every exclude applies).
                            required:
                              - value
                              - label
                              - status
                          description: >-
                            LinkedIn-industry entries whose `value` is one of
                            the `linkedinIndustries` values in GET
                            /companies/filter-options, copied exactly as listed
                            (e.g. Software Development) — a much finer taxonomy
                            than `industriesV2`. An off-list value is not
                            rejected: the search comes back empty with no error
                            naming the field, so check the value against the
                            list first. Include values are OR-joined (provider
                            `anyOf`) and every exclude value is removed
                            (`noneOf`); this filter ANDs with the others.
                        crunchbaseCategories:
                          type: array
                          items:
                            type: object
                            properties:
                              value:
                                type: string
                                minLength: 1
                                maxLength: 500
                                description: >-
                                  The filter value — see the field's own
                                  description for its vocabulary.
                              label:
                                type: string
                                minLength: 1
                                maxLength: 500
                                description: >-
                                  Display label for the value (required; repeat
                                  the value when you have no label).
                              status:
                                type: string
                                enum:
                                  - include
                                  - exclude
                                description: >-
                                  `include` matches the value; `exclude` removes
                                  companies carrying it (includes OR together,
                                  every exclude applies).
                            required:
                              - value
                              - label
                              - status
                          description: >-
                            Crunchbase-category entries whose `value` is one of
                            the `crunchbaseIndustries` values in GET
                            /companies/filter-options, copied exactly as listed
                            (e.g. Financial Services). An off-list value is not
                            rejected: the search comes back empty with no error
                            naming the field, so check the value against the
                            list first. Include values are OR-joined (provider
                            `anyOf`) and every exclude value is removed
                            (`noneOf`); this filter ANDs with the others.
                        naicsCodes:
                          type: array
                          items:
                            type: object
                            properties:
                              value:
                                type: string
                                minLength: 1
                                maxLength: 500
                                description: >-
                                  The filter value — see the field's own
                                  description for its vocabulary.
                              label:
                                type: string
                                minLength: 1
                                maxLength: 500
                                description: >-
                                  Display label for the value (required; repeat
                                  the value when you have no label).
                              status:
                                type: string
                                enum:
                                  - include
                                  - exclude
                                description: >-
                                  `include` matches the value; `exclude` removes
                                  companies carrying it (includes OR together,
                                  every exclude applies).
                            required:
                              - value
                              - label
                              - status
                          description: >-
                            NAICS entries whose `value` is the code, not the
                            title (`naicsCodes[].code` in GET
                            /companies/filter-options, e.g. 513210 for Software
                            Publishers; 2- to 6-digit codes are all accepted, a
                            shorter code being the broader sector). An off-list
                            value is not rejected: the search comes back empty
                            with no error naming the field, so check the value
                            against the list first. Include values are OR-joined
                            (provider `anyOf`) and every exclude value is
                            removed (`noneOf`); this filter ANDs with the
                            others.
                        officeLocationsV2:
                          type: array
                          items:
                            type: object
                            properties:
                              value:
                                type: string
                                minLength: 1
                                maxLength: 500
                                description: >-
                                  The filter value — see the field's own
                                  description for its vocabulary.
                              label:
                                type: string
                                minLength: 1
                                maxLength: 500
                                description: >-
                                  Display label for the value (required; repeat
                                  the value when you have no label).
                              status:
                                type: string
                                enum:
                                  - include
                                  - exclude
                                description: >-
                                  `include` matches the value; `exclude` removes
                                  companies carrying it (includes OR together,
                                  every exclude applies).
                            required:
                              - value
                              - label
                              - status
                          description: >-
                            Office-location entries whose `value` is a country's
                            three-letter `apiCode` from `countries` in GET
                            /companies/filter-options (e.g. USA) — the same
                            vocabulary as `headquartersCountryCode`, but
                            matching ANY office rather than only the
                            headquarters. The two-letter `isoCodeAlpha2` (US) is
                            also accepted and converted to the `apiCode`. Any
                            other value is refused with 422
                            SEARCH_FILTERS_INVALID, whose `details.param` names
                            this filter and `details.values` the entry. Include
                            values are OR-joined (provider `anyOf`) and every
                            exclude value is removed (`noneOf`); this filter
                            ANDs with the others.
                        fortuneRankings:
                          type: array
                          items:
                            type: object
                            properties:
                              label:
                                type: string
                                minLength: 1
                                maxLength: 500
                                description: >-
                                  Display label for the value (required; repeat
                                  the value when you have no label).
                              value:
                                type: string
                                enum:
                                  - fortune-500
                                  - forbes-global-2000
                              status:
                                type: string
                                enum:
                                  - include
                            required:
                              - label
                              - value
                              - status
                          description: >-
                            People whose current employer is on a list: entries
                            whose `value` is one of exactly: fortune-500 (the
                            Fortune 500), forbes-global-2000 (the Forbes Global
                            2000). Include only; several lists are OR-joined.
                        keywords:
                          type: array
                          items:
                            type: string
                          description: >-
                            Free-text keywords matched against company names and
                            descriptions; any may match.
                        crunchbaseCategoryGroups:
                          type: array
                          items:
                            type: string
                          description: >-
                            Crunchbase category groups as plain strings copied
                            verbatim (case-sensitive) from
                            `crunchbaseCategoryGroups` in GET
                            /companies/filter-options (e.g. Financial Services)
                            — the broad parent of `crunchbaseCategories`. An
                            off-list value is not rejected: the search comes
                            back empty with no error naming the field, so check
                            the value against the list first. Several groups are
                            OR-joined (provider `anyOf`); this filter has no
                            exclude form.
                        linkedinSlugs:
                          type: array
                          items:
                            type: string
                          description: >-
                            Free text: LinkedIn company slugs (e.g. stripe). A
                            full company URL is accepted and reduced to the part
                            after linkedin.com/company/, and the value is
                            lower-cased, because the provider matches the slug
                            exactly. Several slugs are OR-joined.
                        lastFundingUSD:
                          type: object
                          properties:
                            min:
                              type: number
                              description: >-
                                Lower bound, inclusive — except on
                                `employeeCountV2`, whose lower bound is
                                exclusive (see that field). 0 or less is no
                                bound.
                            max:
                              type: number
                              description: Inclusive upper bound; 0 or less is no bound.
                          description: >-
                            Size range of the most recent funding round `{ min?,
                            max? }`; the accepted values are whole US dollars,
                            not millions (5000000 means $5M), and both bounds
                            are inclusive.
                        foundedOn:
                          type: object
                          properties:
                            start:
                              type: string
                              description: Earliest date, ISO-8601 (e.g. 2020-01-01).
                            end:
                              type: string
                              description: Latest date, ISO-8601 (e.g. 2024-12-31).
                          description: >-
                            Founding-date range `{ start?, end? }` as ISO-8601
                            dates.
                        lastFundedOn:
                          type: object
                          properties:
                            start:
                              type: string
                              description: Earliest date, ISO-8601 (e.g. 2020-01-01).
                            end:
                              type: string
                              description: Latest date, ISO-8601 (e.g. 2024-12-31).
                          description: >-
                            Date range of the most recent funding round, `{
                            start?, end? }` as ISO-8601 dates.
                      description: >-
                        Filters on the person's CURRENT employer, in the company
                        search vocabulary and value shapes (the same as POST
                        /companies/search `filters`, limited to these keys):
                        include/exclude fields take `[{ status, value, label }]`
                        entries, list fields arrays of strings, `lastFundingUSD`
                        `{ min, max }` and the date ranges `{ start, end }`.
                        Every filter here ANDs with the rest of the search, and
                        any of them makes it a search of people at matching
                        companies. Only people whose current employer the
                        provider has identified can match.
                  description: >-
                    Literal filters, one of the four filter sources, in the
                    vocabulary of POST /prospects/search. People filters in the
                    search vocabulary: include/exclude fields take `[{ status,
                    value }]` entries, term fields a string or an array of
                    strings, `rangeInputs` `{ min, max }` ranges — every field
                    and its accepted values are listed by GET
                    /prospects/filter-options. On this endpoint a value outside
                    a field's listed vocabulary is refused with 422
                    VALIDATION_FAILED, naming the field and the value, before
                    anything is billed; so is a filter the search no longer
                    serves (sex, github_url, github_username, facebook_url,
                    job_title_sub_role, experience.title.sub_role,
                    experience.company.industry,
                    experience.company.location.country,
                    experience.company.location.name,
                    experience.company.location.continent,
                    experience.company.type, location_continent,
                    job_company_location_continent) and an `exclude` entry on
                    education.degrees (the degree filter takes includes only;
                    size and revenue excludes are searched). One exception:
                    `languages.name` also accepts these other names of listed
                    languages, searched as the listed one: bangla, farsi,
                    panjabi, slovene, chinese, mandarin, putonghua, tagalog,
                    filipino, sinhala, khmer, central khmer, hakka chinese,
                    hokkien, taiwanese, newari, northern frisian, western
                    frisian, ndebele, north ndebele, south ndebele, assyrian
                    neo-aramaic. Must contain at least one non-empty value.
                savedSearchId:
                  type: string
                  description: >-
                    Id of one of your PEOPLE saved searches to take the filters
                    from instead of `filters` (a company saved search answers
                    422 SAVED_SEARCH_TYPE_MISMATCH).
                savedSearchName:
                  type: string
                  minLength: 1
                  maxLength: 255
                  description: >-
                    Exact title of one of your people saved searches to take the
                    filters from instead of `filters`; two searches sharing the
                    title answer 409 SAVED_SEARCH_NAME_AMBIGUOUS.
                query:
                  type: string
                  minLength: 1
                  maxLength: 2000
                  description: >-
                    Natural-language description of who to find (max 2000
                    chars), converted into filters server-side instead of
                    `filters`; criteria that could not be mapped come back as
                    `unresolvedCriteria`, and a query yielding no filter answers
                    422 QUERY_FILTERS_INVALID.
              description: >-
                Exactly one filter source, as POST /prospects/search takes it:
                `filters`, `savedSearchId`, `savedSearchName` or `query`. A
                count has no paging and no `linkedinUrl` lookup.
      responses:
        '200':
          description: Success
          headers:
            RateLimit-Limit:
              schema:
                type: integer
              description: Requests permitted in the current window.
            RateLimit-Remaining:
              schema:
                type: integer
              description: Requests remaining in the current window.
            RateLimit-Reset:
              schema:
                type: integer
              description: Seconds until the current window resets.
          content:
            application/json:
              schema:
                type: object
                required:
                  - status
                  - total
                  - filters
                  - creditsCharged
                properties:
                  status:
                    type: string
                    enum:
                      - ready
                      - pending
                    description: >-
                      `ready` (200) with the `total`, or `pending` (202) while
                      the count runs: repeat the request.
                  total:
                    type:
                      - integer
                      - 'null'
                    description: People matching the filters; null while `pending`.
                  filters:
                    type: object
                    additionalProperties: true
                    description: >-
                      The filters counted, in the POST /prospects/search
                      vocabulary.
                  unresolvedCriteria:
                    type: array
                    items:
                      type: string
                    description: >-
                      Only with `query`: the parts of the sentence no filter
                      could express.
                  closestCompanyMatches:
                    type: array
                    items:
                      type: object
                      required:
                        - requestedName
                        - name
                      properties:
                        requestedName:
                          type: string
                        name:
                          type: string
                        domain:
                          type: string
                    description: >-
                      Only with `query`: each company the sentence named that
                      Smart Search chose between same-named companies for, and
                      the one it chose; empty when it guessed nothing.
                  ignoredFilterKeys:
                    type: array
                    items:
                      type: string
                    description: >-
                      Only with a saved search: stored keys with no search
                      field, left out of the count.
                  creditsCharged:
                    type: integer
                    description: 'Always 0: counting is free.'
              example:
                status: ready
                total: 18432
                filters:
                  job_title_levels:
                    - status: include
                      value: vp
                  job_title_role:
                    - status: include
                      value: sales
                  location_country:
                    - status: include
                      value: united states
                unresolvedCriteria: []
                closestCompanyMatches: []
                creditsCharged: 0
        '202':
          description: >-
            The count is still running: repeat the request with the returned
            `filters` until it answers 200.
          headers:
            RateLimit-Limit:
              schema:
                type: integer
              description: Requests permitted in the current window.
            RateLimit-Remaining:
              schema:
                type: integer
              description: Requests remaining in the current window.
            RateLimit-Reset:
              schema:
                type: integer
              description: Seconds until the current window resets.
          content:
            application/json:
              schema:
                type: object
                properties:
                  status:
                    type: string
                  total:
                    type:
                      - string
                      - 'null'
                  filters:
                    type: object
                    properties:
                      job_title_levels:
                        type: array
                        items:
                          type: object
                          properties:
                            status:
                              type: string
                            value:
                              type: string
                      job_title_role:
                        type: array
                        items:
                          type: object
                          properties:
                            status:
                              type: string
                            value:
                              type: string
                      location_country:
                        type: array
                        items:
                          type: object
                          properties:
                            status:
                              type: string
                            value:
                              type: string
                  unresolvedCriteria:
                    type: array
                    items: {}
                  closestCompanyMatches:
                    type: array
                    items: {}
                  creditsCharged:
                    type: integer
              example:
                status: pending
                total: null
                filters:
                  job_title_levels:
                    - status: include
                      value: vp
                  job_title_role:
                    - status: include
                      value: sales
                  location_country:
                    - status: include
                      value: united states
                unresolvedCriteria: []
                closestCompanyMatches: []
                creditsCharged: 0
        '400':
          description: Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '401':
          description: Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '402':
          description: Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '403':
          description: Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '404':
          description: Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '409':
          description: Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '422':
          description: Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '429':
          description: Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '500':
          description: Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
      security:
        - basicAuth: []
components:
  schemas:
    Error:
      type: object
      properties:
        error:
          type: object
          properties:
            code:
              type: string
            message:
              type: string
            param:
              type:
                - string
                - 'null'
            doc_url:
              type:
                - string
                - 'null'
            request_id:
              type:
                - string
                - 'null'
          required:
            - code
            - message
      required:
        - error
  securitySchemes:
    basicAuth:
      type: http
      scheme: basic
      description: >-
        Your API token (`af_…`) as the Basic-auth username, with an empty
        password.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.