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

# CrustData V2: Persondb Search

> Search millions of professional profiles in the Crustdata database with advanced filters. Includes inputs, outputs, SDK V2 examples, and Deepline cost.

Search millions of professional profiles in the Crustdata database with advanced filters.

> [!NOTE]
>
> Tool ID: `crustdata_v2_persondb_search`

## Run this action

Use the TypeScript SDK for one call. Use `ctx.tools.execute(...)` inside a Play for durable calls, scheduled calls, or CSV processing.

```ts theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
import { Deepline } from 'deepline';

const deepline = await Deepline.connect();
const result = await deepline.tools.execute(
  'crustdata_v2_persondb_search',
  {
    "filters": {
      "column": "example",
      "type": "=",
      "value": "example"
    }
  },
);

console.log(result.toolResponse.raw);
```

### CLI

```bash theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
deepline tools execute crustdata_v2_persondb_search --input '{
  "filters": {
    "column": "example",
    "type": "=",
    "value": "example"
  }
}' --json
```

## Example response

The SDK returns this shape at `result.toolResponse.raw`. The example values illustrate the response.

```json theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
{
  "data": {
    "profiles": [
      {
        "person_id": 123,
        "name": "Example",
        "first_name": "Jane"
      }
    ],
    "total_count": 123
  }
}
```

Use `deepline describe crustdata_v2_persondb_search --json` for the latest machine-readable contract.

## Input reference

In-database search API for people data, enabling you to search across millions of professional profiles with advanced filtering capabilities. [Show Docs](https://docs.crustdata.com/docs/discover/people-apis/people-discovery-api-in-db)

| Name | Type | Required | Default | Details |
| - | - | - | - | - |
| `payload.filters` | `object` | Yes | — | Filter conditions for searching people. Can be a simple condition or complex nested conditions with AND/OR logic. |
| `payload.cursor` | `string` | No | — | Pagination cursor from previous response. Used for fetching the next page of results. |
| `payload.limit` | `integer` | No | `20` | The number of results to return in a single request. Default value is 20. Maximum is 1,000. Maximum: 1000. |
| `payload.post_processing` | `object` | No | — | Additional filtering options applied to search results. |

<details>
  <summary>Show raw input schema</summary>

  ### Input JSON Schema

  ```json theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
  {
    "type": "object",
    "description": "In-database search API for people data, enabling you to search across millions of professional profiles with advanced filtering capabilities. [Show Docs](https://docs.crustdata.com/docs/discover/people-apis/people-discovery-api-in-db)",
    "properties": {
      "filters": {
        "description": "Filter conditions for searching people. Can be a simple condition or complex nested conditions with AND/OR logic.",
        "anyOf": [
          {
            "type": "object",
            "description": "Basic filter condition for PersonDB search",
            "properties": {
              "column": {
                "type": "string",
                "description": "The field to filter on (e.g., \"current_employers.title\", \"region\", \"skills\")"
              },
              "type": {
                "type": "string",
                "description": "The operator to use for comparison. - `(.)` — case-insensitive fuzzy contains (substring match, typo-tolerant). On location fields, multi-word values are split into per-word matches: `(.) \"San Francisco\"` matches rows that contain both \"San\" and \"Francisco\" anywhere in the location, in any order. - `(!)` — case-insensitive fuzzy negation: excludes profiles whose value contains the substring (typo-tolerant). Use this instead of `!=` / `not_in` when you want a substring-based exclusion (e.g. excluding `VP` also drops `VP of Sales`). Multi-word values are matched as a literal phrase, not word-split: `(!) \"New York\"` excludes only rows whose location contains the substring `New York`; a row whose region is `New Yorker` is **not** excluded. To exclude on each word independently, send them as separate `(!)` conditions inside an `AND` group.",
                "enum": [
                  "=",
                  "!=",
                  "in",
                  "not_in",
                  ">",
                  "<",
                  "=>",
                  "=<",
                  "(.)",
                  "(!)"
                ]
              },
              "value": {
                "description": "The value(s) to match against",
                "anyOf": [
                  {
                    "type": "string"
                  },
                  {
                    "type": "number"
                  },
                  {
                    "type": "boolean"
                  },
                  {
                    "type": "array",
                    "items": {
                      "anyOf": [
                        {
                          "type": "string"
                        },
                        {
                          "type": "number"
                        }
                      ]
                    }
                  }
                ]
              }
            },
            "required": [
              "column",
              "type",
              "value"
            ],
            "additionalProperties": false
          },
          {
            "type": "object",
            "description": "Complex filter group for PersonDB search with AND/OR logic",
            "properties": {
              "op": {
                "type": "string",
                "description": "Logical operator to combine conditions",
                "enum": [
                  "and",
                  "or"
                ]
              },
              "conditions": {
                "type": "array",
                "description": "Array of conditions to combine",
                "items": {
                  "anyOf": [
                    {
                      "type": "object",
                      "description": "Basic filter condition for PersonDB search",
                      "properties": {
                        "column": {
                          "type": "string",
                          "description": "The field to filter on (e.g., \"current_employers.title\", \"region\", \"skills\")"
                        },
                        "type": {
                          "type": "string",
                          "description": "The operator to use for comparison. - `(.)` — case-insensitive fuzzy contains (substring match, typo-tolerant). On location fields, multi-word values are split into per-word matches: `(.) \"San Francisco\"` matches rows that contain both \"San\" and \"Francisco\" anywhere in the location, in any order. - `(!)` — case-insensitive fuzzy negation: excludes profiles whose value contains the substring (typo-tolerant). Use this instead of `!=` / `not_in` when you want a substring-based exclusion (e.g. excluding `VP` also drops `VP of Sales`). Multi-word values are matched as a literal phrase, not word-split: `(!) \"New York\"` excludes only rows whose location contains the substring `New York`; a row whose region is `New Yorker` is **not** excluded. To exclude on each word independently, send them as separate `(!)` conditions inside an `AND` group.",
                          "enum": [
                            "=",
                            "!=",
                            "in",
                            "not_in",
                            ">",
                            "<",
                            "=>",
                            "=<",
                            "(.)",
                            "(!)"
                          ]
                        },
                        "value": {
                          "description": "The value(s) to match against",
                          "anyOf": [
                            {
                              "type": "string"
                            },
                            {
                              "type": "number"
                            },
                            {
                              "type": "boolean"
                            },
                            {
                              "type": "array",
                              "items": {
                                "anyOf": [
                                  {
                                    "type": "string"
                                  },
                                  {
                                    "type": "number"
                                  }
                                ]
                              }
                            }
                          ]
                        }
                      },
                      "required": [
                        "column",
                        "type",
                        "value"
                      ],
                      "additionalProperties": false
                    },
                    {
                      "type": "object",
                      "description": "Recursive OpenAPI schema reference #/components/schemas/PersonDBConditionGroup.",
                      "additionalProperties": true
                    }
                  ]
                }
              }
            },
            "required": [
              "op",
              "conditions"
            ],
            "additionalProperties": false
          }
        ]
      },
      "cursor": {
        "type": "string",
        "description": "Pagination cursor from previous response. Used for fetching the next page of results."
      },
      "limit": {
        "type": "integer",
        "description": "The number of results to return in a single request. Default value is 20. Maximum is 1,000.",
        "default": 20,
        "maximum": 1000
      },
      "post_processing": {
        "type": "object",
        "description": "Additional filtering options applied to search results.",
        "properties": {
          "exclude_profiles": {
            "type": "array",
            "description": "List of LinkedIn profile URLs to exclude from results.",
            "items": {
              "type": "string",
              "format": "uri"
            }
          },
          "exclude_names": {
            "type": "array",
            "description": "List of names to exclude from results.",
            "items": {
              "type": "string"
            }
          }
        },
        "additionalProperties": false
      }
    },
    "required": [
      "filters"
    ],
    "additionalProperties": false
  }
  ```
</details>

## Output reference

Standard tool result payload.

| Name | Type | Required | Default | Details |
| - | - | - | - | - |
| `result.data` | `object` | Yes | — | Provider response payload. |
| `result.data.profiles` | `array` | Yes | — | Array of person profiles matching the search criteria |
| `result.data.profiles[].person_id` | `integer` | No | — | Unique identifier for the person |
| `result.data.profiles[].name` | `string` | No | — | Full name of the person |
| `result.data.profiles[].first_name` | `string` | No | — | First name |
| `result.data.profiles[].last_name` | `string` | No | — | Last name |
| `result.data.profiles[].region` | `string` | No | — | Current location/region |
| `result.data.profiles[].headline` | `string` | No | — | Professional headline from LinkedIn |
| `result.data.profiles[].summary` | `string \| null` | No | — | Professional summary |
| `result.data.profiles[].skills` | `array` | No | — | List of professional skills |
| `result.data.profiles[].languages` | `array` | No | — | Languages spoken |
| `result.data.profiles[].profile_language` | `string` | No | — | Language of the LinkedIn profile |
| `result.data.profiles[].linkedin_profile_url` | `string` | No | — | LinkedIn profile URL Format: `uri`. |
| `result.data.profiles[].flagship_profile_url` | `string` | No | — | LinkedIn flagship URL (vanity URL) Format: `uri`. |
| `result.data.profiles[].emails` | `array` | No | — | Email addresses |
| `result.data.profiles[].profile_picture_url` | `string \| null` | No | — | URL of the profile picture Format: `uri`. |
| `result.data.profiles[].profile_picture_permalink` | `string \| null` | No | — | Permanent URL of the profile picture Format: `uri`. |
| `result.data.profiles[].twitter_handle` | `string \| null` | No | — | Twitter/X username |
| `result.data.profiles[].num_of_connections` | `integer` | No | — | Number of LinkedIn connections |
| `result.data.profiles[].recently_changed_jobs` | `boolean` | No | — | Indicates if the person recently changed jobs |
| `result.data.profiles[].years_of_experience` | `string` | No | — | Categorical years of experience |
| `result.data.profiles[].years_of_experience_raw` | `number` | No | — | Numeric years of experience |
| `result.data.profiles[].last_updated` | `string` | No | — | When the profile was last updated in the database Format: `date-time`. |
| `result.data.profiles[].updated_at` | `string` | No | — | When the profile data was last refreshed Format: `date-time`. |
| `result.data.profiles[].current_employers` | `array` | No | — | Current employment positions |
| `result.data.profiles[].current_employers[].name` | `string` | No | — | Company name |
| `result.data.profiles[].current_employers[].linkedin_id` | `string` | No | — | Company's LinkedIn ID |
| `result.data.profiles[].current_employers[].logo_url` | `string \| null` | No | — | Company logo URL Format: `uri`. |
| `result.data.profiles[].current_employers[].linkedin_description` | `string \| null` | No | — | Company description from LinkedIn |
| `result.data.profiles[].current_employers[].company_id` | `integer \| null` | No | — | Internal company ID |
| `result.data.profiles[].current_employers[].company_website_domain` | `string \| null` | No | — | Company website domain |
| `result.data.profiles[].current_employers[].company_website` | `string \| null` | No | — | Company website URL Format: `uri`. |
| `result.data.profiles[].current_employers[].company_linkedin_profile_url` | `string \| null` | No | — | Company's LinkedIn profile URL Format: `uri`. |
| `result.data.profiles[].current_employers[].position_id` | `integer \| null` | No | — | Internal position ID |
| `result.data.profiles[].current_employers[].title` | `string` | No | — | Job title at this company |
| `result.data.profiles[].current_employers[].description` | `string \| null` | No | — | Job description |
| `result.data.profiles[].current_employers[].location` | `string \| null` | No | — | Job location |
| `result.data.profiles[].current_employers[].start_date` | `string \| null` | No | — | Position start date Format: `date-time`. |
| `result.data.profiles[].current_employers[].end_date` | `string \| null` | No | — | Position end date (null if current) Format: `date-time`. |
| `result.data.profiles[].current_employers[].employment_type` | `"Full-time" \| "Part-time" \| "Internship" \| "Contract" \| "Self-employed" \| "Freelance" \| "Permanent" \| "Permanent Full-time" \| "Apprenticeship"` | No | — | Employment type for the position. One of the values listed in the enum, or `null` when the person did not specify an employment type on LinkedIn. Allowed: `Full-time`, `Part-time`, `Internship`, `Contract`, `Self-employed`, `Freelance`, `Permanent`, `Permanent Full-time`, `Apprenticeship`. |
| `result.data.profiles[].current_employers[].company_headquarters_country` | `string \| null` | No | — | Country of company headquarters |
| `result.data.profiles[].current_employers[].company_headquarters_address` | `string \| null` | No | — | Address of company headquarters |
| `result.data.profiles[].current_employers[].company_headcount_range` | `string \| null` | No | — | Employee count range (e.g., "10,001+") |
| `result.data.profiles[].current_employers[].company_headcount_latest` | `integer \| null` | No | — | Latest known employee count |
| `result.data.profiles[].current_employers[].company_industries` | `array` | No | — | Industries the company operates in |
| `result.data.profiles[].current_employers[].company_type` | `string \| null` | No | — | Type of company (e.g., "Public Company", "Privately Held") |
| `result.data.profiles[].current_employers[].seniority_level` | `string \| null` | No | — | Seniority level of the position |
| `result.data.profiles[].current_employers[].function_category` | `string \| null` | No | — | Job function category |
| `result.data.profiles[].current_employers[].years_at_company` | `string \| null` | No | — | Categorical years at company |
| `result.data.profiles[].current_employers[].years_at_company_raw` | `number \| null` | No | — | Numeric years at company |

The table shows the first 50 fields. Use the live contract below for every field.

> [!NOTE]
>
> This output schema is too large for an inline display. Read the complete live contract with `deepline describe crustdata_v2_persondb_search --json`.

## Deepline cost

* Pricing model: `per_result` (per result).
* Estimated Deepline credits: `0.4` per pricing unit.

## Related documentation

* [CrustData V2 provider guide](https://deepline.com/docs/providers/crustdata-v2/guide.md)
* [SDK V2 quickstart](https://deepline.com/docs/sdk-v2/quickstart.md)
* [SDK reference](https://deepline.com/docs/sdk-v2/sdk-reference.md)
* [Run tools across a CSV](https://deepline.com/docs/sdk-v2/batch-csv.md)


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