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

# Company Identify

> Resolve a company from partial information — a name, domain, profile URL, or Crustdata company ID — and get back matched company records ranked by confidence.

**Use this when** you have partial company information and need to resolve it
to a specific Crustdata company record — for CRM deduplication, lead routing,
entity resolution, or pre-enrichment matching.

The Company Identify API takes an identifier you have — a website domain, a
profile URL, a company name, or a Crustdata company ID — and returns one or
more matched companies ranked by confidence score. Identify is designed for
entity resolution rather than deep profiling.

<Note>
  This page documents the live Identify response directly. Current platform
  behavior returns match metadata plus `company_data.basic_info`. If you
  need the broader company sections used in full profiles, see
  [Enrich reference](/company-docs/enrichment/reference).
</Note>

Every request goes to the same endpoint:

```
POST https://api.crustdata.com/company/identify
```

<Note>
  Replace `YOUR_API_KEY` in each example with your actual API key. All
  requests require the `x-api-version: 2025-11-01` header.
</Note>

### Request body

| Parameter                                                                           | Type    | Required       | Description                               |
| ----------------------------------------------------------------------------------- | ------- | -------------- | ----------------------------------------- |
| `domains` / `professional_network_profile_urls` / `names` / `crustdata_company_ids` | array   | Yes — one only | Submit exactly one identifier type.       |
| `exact_match`                                                                       | boolean | No             | Set to `true` for strict domain matching. |

### Response body

The response is a top-level array. Each entry corresponds to one input
identifier.

| Field                        | Type   | Description                                                                  |
| ---------------------------- | ------ | ---------------------------------------------------------------------------- |
| `matched_on`                 | string | The input identifier you submitted                                           |
| `match_type`                 | string | `domain`, `name`, `crustdata_company_id`, `professional_network_profile_url` |
| `matches`                    | array  | Candidate matches ranked by relevance. Empty for no-match inputs.            |
| `matches[].confidence_score` | number | Higher is better.                                                            |
| `matches[].company_data`     | object | Match metadata plus `basic_info`.                                            |

### Rate limits and pricing

<Callout icon="gift" color="#16a34a">
  <strong>Pricing:</strong> <code>Free</code>.
</Callout>

* **Rate limits:** For current plan-specific limits, see
  [Rate limits](/general/rate-limits).

<Info>
  Use Identify first when your input is ambiguous. You can resolve the right
  company for free, then call [Enrich](/company-docs/enrichment/introduction) only for
  the records you want in full detail.
</Info>

<Card title="Reference" icon="book" href="#reference">
  Request parameters, validation, no-match behavior, errors.
</Card>

***

## Your first identification: look up a company by domain

Pass a website domain in the `domains` array to find the matching company.

<CodeGroup>
  ```bash Request theme={"theme":"vitesse-black"}
  curl --request POST \
    --url https://api.crustdata.com/company/identify \
    --header 'authorization: Bearer YOUR_API_KEY' \
    --header 'content-type: application/json' \
    --header 'x-api-version: 2025-11-01' \
    --data '{
      "domains": ["serverobotics.com"]
    }'
  ```

  ```json Response theme={"theme":"vitesse-black"}
  [
      {
          "matched_on": "serverobotics.com",
          "match_type": "domain",
          "matches": [
              {
                  "confidence_score": 1.0,
                  "company_data": {
                      "crustdata_company_id": 628895,
                      "basic_info": {
                          "crustdata_company_id": 628895,
                          "name": "Serve Robotics",
                          "primary_domain": "serverobotics.com",
                          "all_domains": ["serverobotics.com"],
                          "website": "https://www.serverobotics.com/",
                          "professional_network_url": "https://www.linkedin.com/company/serverobotics",
                          "professional_network_id": "72049930",
                          "profile_name": "Serve Robotics",
                          "employee_count_range": "51-200",
                          "industries": [
                              "Technology, Information and Internet",
                              "Technology, Information and Media"
                          ]
                      }
                  }
              }
          ]
      }
  ]
  ```
</CodeGroup>

### Understanding the response

<Note>
  The live Identify endpoint returns a
  top-level array, not an object with a `results` wrapper.
</Note>

The Identify API returns a top-level array — one entry per identifier you
submitted. Each entry has three fields:

* **`matched_on`** — the identifier you submitted (the domain, URL, name, or ID).
* **`match_type`** — which identifier type was used. Values: `domain`, `name`, `crustdata_company_id`, `professional_network_profile_url`.
* **`matches`** — an array of candidate companies ranked by relevance. Each
  match includes a `confidence_score` and a `company_data` object. Current
  platform behavior returns `basic_info` here.

For detailed behavior when no identifier matches, see
[No-match behavior](#no-match-behavior).

***

## Identify vs Enrich

|              | Identify                                     | Enrich                         |
| ------------ | -------------------------------------------- | ------------------------------ |
| **Endpoint** | `/company/identify`                          | `/company/enrich`              |
| **Pricing**  | **Free**                                     | **2 credits per record**       |
| **Response** | Match results with `company_data.basic_info` | Full company profile           |
| **Best for** | Matching, deduplication, entity resolution   | Research, scoring, diligence   |
| **Use when** | You need to resolve "which company is this?" | You need detailed company data |

**Common pattern:** Use Identify to resolve ambiguous inputs, then pass the
`crustdata_company_id` from the best match into
[Enrich](/company-docs/enrichment/introduction) for the full profile.

***

## Examples

Worked recipes you can copy, paste, and adapt. Each example is a full working
request you can copy, paste, and adapt.

<Note>
  Replace `YOUR_API_KEY` in each example with your actual API key. All
  requests require the `x-api-version: 2025-11-01` header.
</Note>

<AccordionGroup>
  <Accordion title="Identify by company name">
    Name-based identification often returns multiple candidates. Check
    `confidence_score` and `primary_domain` to pick the right match.

    <CodeGroup>
      ```bash Request theme={"theme":"vitesse-black"}
      curl --request POST \
        --url https://api.crustdata.com/company/identify \
        --header 'authorization: Bearer YOUR_API_KEY' \
        --header 'content-type: application/json' \
        --header 'x-api-version: 2025-11-01' \
        --data '{
          "names": ["Serve Robotics"]
        }'
      ```

      ```json Response theme={"theme":"vitesse-black"}
      [
          {
              "matched_on": "Serve Robotics",
              "match_type": "name",
              "matches": [
                  {
                      "confidence_score": 1.0,
                      "company_data": {
                          "crustdata_company_id": 628895,
                          "basic_info": {
                              "name": "Serve Robotics",
                              "primary_domain": "serverobotics.com",
                              "employee_count_range": "51-200",
                              "industries": ["Technology, Information and Internet"]
                          }
                      }
                  },
                  {
                      "confidence_score": 1.0,
                      "company_data": {
                          "crustdata_company_id": 5825197,
                          "basic_info": {
                              "name": "Site Serve Robotics",
                              "primary_domain": "siteserverobotics.co.uk",
                              "employee_count_range": "2-10",
                              "industries": ["Construction"]
                          }
                      }
                  }
              ]
          }
      ]
      ```
    </CodeGroup>

    <Tip>
      When multiple matches are returned, use `primary_domain` and
      `employee_count_range` to disambiguate. The first match is not always the
      right one for name-based lookups.
    </Tip>
  </Accordion>

  <Accordion title="Identify by profile URL">
    If you have a company profile URL, pass it in
    `professional_network_profile_urls`. Profile URL lookups are direct matches —
    they typically return a single match with high confidence.

    <CodeGroup>
      ```bash Request theme={"theme":"vitesse-black"}
      curl --request POST \
        --url https://api.crustdata.com/company/identify \
        --header 'authorization: Bearer YOUR_API_KEY' \
        --header 'content-type: application/json' \
        --header 'x-api-version: 2025-11-01' \
        --data '{
          "professional_network_profile_urls": [
            "https://www.linkedin.com/company/mintlify"
          ]
        }'
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Identify by Crustdata company ID">
    Pass a Crustdata company ID (for example, from a previous search call) to
    `crustdata_company_ids` for an exact lookup.

    <CodeGroup>
      ```bash Request theme={"theme":"vitesse-black"}
      curl --request POST \
        --url https://api.crustdata.com/company/identify \
        --header 'authorization: Bearer YOUR_API_KEY' \
        --header 'content-type: application/json' \
        --header 'x-api-version: 2025-11-01' \
        --data '{
          "crustdata_company_ids": [628895]
        }'
      ```
    </CodeGroup>

    Company ID lookups return an exact match.
  </Accordion>

  <Accordion title="Common workflow: Inbound domain → Identify → Search for similar companies">
    An inbound lead arrives from a known domain. Use Identify to resolve the
    domain to a company record, then use Search to find similar companies for
    prospecting.

    ### Step 1: Identify the inbound company

    <CodeGroup>
      ```bash Request theme={"theme":"vitesse-black"}
      curl --request POST \
        --url https://api.crustdata.com/company/identify \
        --header 'authorization: Bearer YOUR_API_KEY' \
        --header 'content-type: application/json' \
        --header 'x-api-version: 2025-11-01' \
        --data '{"domains": ["retool.com"]}'
      ```

      ```json Response theme={"theme":"vitesse-black"}
      [
          {
              "matched_on": "retool.com",
              "match_type": "domain",
              "matches": [
                  {
                      "confidence_score": 1.0,
                      "company_data": {
                          "crustdata_company_id": 633593,
                          "basic_info": {
                              "name": "Retool",
                              "primary_domain": "retool.com",
                              "employee_count_range": "201-500",
                              "industries": ["Software Development"]
                          }
                      }
                  }
              ]
          }
      ]
      ```
    </CodeGroup>

    **Extract:** Take
    `response[0].matches[0].company_data.basic_info.industries[0]` →
    `"Software Development"` and `employee_count_range` → `"201-500"`.

    ### Step 2: Search for similar companies

    <CodeGroup>
      ```bash Request theme={"theme":"vitesse-black"}
      curl --request POST \
        --url https://api.crustdata.com/company/search \
        --header 'authorization: Bearer YOUR_API_KEY' \
        --header 'content-type: application/json' \
        --header 'x-api-version: 2025-11-01' \
        --data '{
          "filters": {
            "op": "and",
            "conditions": [
              {"field": "basic_info.industries", "type": "in", "value": ["Software Development"]},
              {"field": "headcount.total", "type": ">", "value": 200},
              {"field": "headcount.total", "type": "<", "value": 1000}
            ]
          },
          "sorts": [{"field": "headcount.total", "order": "desc"}],
          "limit": 10,
          "fields": ["crustdata_company_id", "basic_info.name", "basic_info.primary_domain", "headcount.total"]
        }'
      ```

      ```json Response theme={"theme":"vitesse-black"}
      {
          "companies": [
              {
                  "crustdata_company_id": 67890,
                  "basic_info": { "name": "Retool", "primary_domain": "retool.com" },
                  "headcount": { "total": 450 }
              },
              {
                  "crustdata_company_id": 12345,
                  "basic_info": { "name": "Notion", "primary_domain": "notion.so" },
                  "headcount": { "total": 800 }
              }
          ],
          "next_cursor": "H4sIAM_5zGkC...",
          "total_count": 1543
      }
      ```
    </CodeGroup>

    **Extract:** Take `companies[].crustdata_company_id` values and pass them to
    [Enrich](/company-docs/enrichment/introduction) for full profiles of promising matches.

    **If empty:** If `companies` is `[]`, broaden your filters (for example,
    wider headcount range or more industries). Use
    [Autocomplete](/company-docs/autocomplete/introduction) to verify valid filter values.
  </Accordion>

  <Accordion title="Identify by name: exact_match vs. fuzzy">
    Name-based identification supports two matching modes. With `exact_match: true`,
    the input must match the stored name **character for character**
    (case-insensitive) — and the stored name is not always how the company is
    commonly written. For example, "Tomo Credit" is stored as `"TomoCredit"`
    (no space), so an exact lookup for the spaced form returns no matches.

    **`exact_match: true` with a space → no match:**

    <CodeGroup>
      ```bash Request theme={"theme":"vitesse-black"}
      curl --request POST \
        --url https://api.crustdata.com/company/identify \
        --header 'authorization: Bearer YOUR_API_KEY' \
        --header 'content-type: application/json' \
        --header 'x-api-version: 2025-11-01' \
        --data '{
          "names": ["Tomo Credit"],
          "exact_match": true
        }'
      ```

      ```json Response theme={"theme":"vitesse-black"}
      [
          {
              "matched_on": "Tomo Credit",
              "match_type": "name",
              "matches": []
          }
      ]
      ```
    </CodeGroup>

    **`exact_match: false` (default) tolerates the variation → matches:**

    <CodeGroup>
      ```bash Request theme={"theme":"vitesse-black"}
      curl --request POST \
        --url https://api.crustdata.com/company/identify \
        --header 'authorization: Bearer YOUR_API_KEY' \
        --header 'content-type: application/json' \
        --header 'x-api-version: 2025-11-01' \
        --data '{
          "names": ["Tomo Credit"],
          "exact_match": false
        }'
      ```

      ```json Response theme={"theme":"vitesse-black"}
      [
          {
              "matched_on": "Tomo Credit",
              "match_type": "name",
              "matches": [
                  {
                      "confidence_score": 1.0,
                      "company_data": {
                          "crustdata_company_id": 634576,
                          "basic_info": {
                              "name": "TomoCredit",
                              "primary_domain": "tomocredit.ai",
                              "employee_count_range": "51-200",
                              "industries": ["Technology, Information and Internet"]
                          }
                      }
                  }
              ]
          }
      ]
      ```
    </CodeGroup>

    <Tip>
      **Recommended fallback:** try `exact_match: true` first; if `matches` is
      empty, retry with `exact_match: false`; then verify the returned `name` or
      `primary_domain` before using the result. Identify is free, so this
      two-step resolution costs nothing.
    </Tip>
  </Accordion>
</AccordionGroup>

***

## Reference

Reference material for Company Identify: the full
list of request parameters, validation rules, no-match behavior, and error
responses.

### Request parameter reference

| Parameter                           | Type       | Required                             | Description                               |
| ----------------------------------- | ---------- | ------------------------------------ | ----------------------------------------- |
| `domains`                           | string\[]  | Exactly one identifier type required | Website domains to identify.              |
| `professional_network_profile_urls` | string\[]  | Exactly one identifier type required | Company profile URLs to identify.         |
| `names`                             | string\[]  | Exactly one identifier type required | Company names to identify.                |
| `crustdata_company_ids`             | integer\[] | Exactly one identifier type required | Crustdata company IDs to identify.        |
| `exact_match`                       | boolean    | No                                   | Set to `true` for strict domain matching. |

<Note>
  Submit exactly one identifier type per
  request.
</Note>

<Note>
  `exact_match: true` enforces strict domain
  matching, but it can still return multiple matches when more than one
  company record shares that same domain.
</Note>

<Note>
  The OpenAPI model currently reuses the Enrich request schema, but this
  reference documents the live Identify behavior. Use
  [Enrich](/company-docs/enrichment/introduction) when you need the broader profile
  sections.
</Note>

### No-match behavior

When no company matches the identifier, current platform behavior returns
`200` with an empty `matches` array:

```json theme={"theme":"vitesse-black"}
[
    {
        "matched_on": "thisdomaindoesnotexist12345xyz.com",
        "match_type": "domain",
        "matches": []
    }
]
```

<Note>
  The OpenAPI spec also defines a `404` response for Identify. Current
  platform behavior returns `200` with empty `matches`, but integrations
  should handle both.
</Note>

### Errors

| Status | Meaning                                                                     |
| ------ | --------------------------------------------------------------------------- |
| `400`  | Invalid request — missing or multiple identifier types, or malformed input. |
| `401`  | Invalid or missing API key.                                                 |
| `403`  | Permission denied or endpoint unavailable for your account.                 |
| `404`  | No data found.                                                              |
| `500`  | Internal server error.                                                      |

```json 400 — Missing identifier theme={"theme":"vitesse-black"}
{
    "error": {
        "type": "invalid_request",
        "message": "Exactly one identifier must be provided: crustdata_company_ids, names, domains, or professional_network_profile_urls",
        "metadata": []
    }
}
```

```json 401 — Invalid API key theme={"theme":"vitesse-black"}
{
    "message": "Invalid API key in request"
}
```

### API reference summary

| Detail       | Value                                                                                                                              |
| ------------ | ---------------------------------------------------------------------------------------------------------------------------------- |
| **Endpoint** | `POST /company/identify`                                                                                                           |
| **Auth**     | Bearer token + `x-api-version: 2025-11-01`                                                                                         |
| **Pricing**  | Free                                                                                                                               |
| **Request**  | One identifier type: `domains`, `names`, `crustdata_company_ids`, or `professional_network_profile_urls`. Optional: `exact_match`. |
| **Response** | `[{ "matched_on", "match_type", "matches": [{ "confidence_score", "company_data" }] }]`                                            |
| **Errors**   | `400` (bad request), `401` (bad auth), `403` (permission), `404` (no match), `500` (server error)                                  |

See the [full API reference](/openapi-specs/2025-11-01/introduction) for the
complete OpenAPI schema.

***

## What to do next

* **Get the full profile** — pass the `crustdata_company_id` from Identify into [Enrich](/company-docs/enrichment/introduction) for detailed company data.
* **Search for similar companies** — use [Company Search](/company-docs/search/introduction) to find companies matching the same industry or headcount range.
* **Verify valid filter values** — use [Autocomplete](/company-docs/autocomplete/introduction) to check filter values before searching.