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

# What is Business Search?

> Business Search is an entity search API that returns ranked people and company records as JSON. Compare its 3 modes by speed, depth, cost and precision.

<Note>
  Business Search is in early access. Email [sales@brightdata.com](mailto:sales@brightdata.com) to request access.
</Note>

An entity search returns the thing you searched for, not documents about it. Describe a person or a company and Business Search returns the matching records as structured JSON, rather than a list of pages that mention them.

One request searches an index of more than 700 million people and companies, refreshed daily. Two entity types are available:

<CardGroup cols={2}>
  <Card title="Company" icon="building" href="/products/business-search/company-search">
    Find companies by industry, headquarters country, size band, founding year and funding stage, with structured conditions or a plain-language sentence.
  </Card>

  <Card title="People" icon="user" href="/products/business-search/people-search">
    Find people by title, current company, location and follower count, with structured conditions or a plain-language sentence.
  </Card>
</CardGroup>

## Search modes

Business Search supports a range of workflows, from looking up one company to discovering every candidate in a market, so it offers three modes that trade speed, depth, cost and precision against each other. The `mode` property selects one:

* **Ludicrous** runs structured conditions you write with [Business Search query syntax](/products/business-search/query-syntax), exactly as written. It is the fastest mode and returns up to 100 records per page.
* **Instant** takes a plain-language sentence, turns it into one structured query and returns its matches. It also returns up to 100 records per page, at the same rate as Ludicrous.
* **Smart** takes the same kind of sentence, then ranks the candidates by how well each record answers the request. It is the most precise mode, the slowest and the most expensive, and returns 10 records per page.

In every mode, `documents` come back in ranked order.

<Tabs>
  <Tab title="Ludicrous">
    Ludicrous is a lexical, structured search: you name the fields and conditions yourself, text conditions match words with BM25, and no model interprets the request or reorders the results.

    **Sample request**

    <CodeGroup>
      ```bash cURL highlight={5} theme={null}
      curl --request POST "https://api.brightdata.com/search/company" \
        --header "Authorization: Bearer $BRIGHTDATA_API_KEY" \
        --header "Content-Type: application/json" \
        --data '{
          "mode": "ludicrous",
          "query": {
            "and": [
              { "text": { "industry": "software" } },
              { "equals": { "headquarters_country_code": "US" } },
              { "range": { "employees_in_linkedin": { ">=": 50, "<=": 500 } } }
            ]
          },
          "limit": 3,
          "view": "summary"
        }'
      ```

      ```python Python highlight={11} theme={null}
      import os
      import requests

      response = requests.post(
          "https://api.brightdata.com/search/company",
          headers={
              "Authorization": f"Bearer {os.environ['BRIGHTDATA_API_KEY']}",
              "Content-Type": "application/json",
          },
          json={
            "mode": "ludicrous",
            "query": {
              "and": [
                { "text": { "industry": "software" } },
                { "equals": { "headquarters_country_code": "US" } },
                { "range": { "employees_in_linkedin": { ">=": 50, "<=": 500 } } }
              ]
            },
            "limit": 3,
            "view": "summary"
          },
      )
      print(response.status_code, response.json())
      ```

      ```javascript Node.js highlight={8} theme={null}
      const response = await fetch("https://api.brightdata.com/search/company", {
        method: "POST",
        headers: {
          "Authorization": `Bearer ${process.env.BRIGHTDATA_API_KEY}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          "mode": "ludicrous",
          "query": {
            "and": [
              { "text": { "industry": "software" } },
              { "equals": { "headquarters_country_code": "US" } },
              { "range": { "employees_in_linkedin": { ">=": 50, "<=": 500 } } }
            ]
          },
          "limit": 3,
          "view": "summary"
        }),
      });
      console.log(response.status, await response.json());
      ```
    </CodeGroup>

    **Sample response**

    ```json theme={null}
    {
      "req_id": "r3417705745d9445bab3114d77d75f16d",
      "meta": { "coverage_percent": 100, "matched": 8, "offset": 0, "limit": 3 },
      "documents": [
        {
          "bright_id": "abc7d8b3719192a4f04197ab57cf352bdbda5abac31dfe1467cc61521d61741c",
          "data": {
            "name": "Braintrust",
            "slogan": "Active observability for agents in production.",
            "industry": "Software Development",
            "headquarters_location": "San Francisco",
            "headquarters_country_code": "US",
            "company_size_from": 51,
            "company_size_to": 200,
            "employees_in_linkedin": 169,
            "linkedin_followers": 15953,
            "website": "https://braintrust.dev/",
            "domain": "braintrust.dev"
          }
        }
      ]
    }
    ```

    `meta.matched` counts the records the search reached, not every company that satisfies the conditions. See [How to paginate Business Search results](/products/business-search/pagination).
  </Tab>

  <Tab title="Instant">
    Instant turns the sentence into one structured query and returns its matches in text-match order.

    **Sample request**

    <CodeGroup>
      ```bash cURL highlight={5} theme={null}
      curl --request POST "https://api.brightdata.com/search/company" \
        --header "Authorization: Bearer $BRIGHTDATA_API_KEY" \
        --header "Content-Type: application/json" \
        --data '{
          "mode": "instant",
          "query": "Developer infrastructure companies building tools for AI engineering teams",
          "limit": 3,
          "view": "summary"
        }'
      ```

      ```python Python highlight={11} theme={null}
      import os
      import requests

      response = requests.post(
          "https://api.brightdata.com/search/company",
          headers={
              "Authorization": f"Bearer {os.environ['BRIGHTDATA_API_KEY']}",
              "Content-Type": "application/json",
          },
          json={
            "mode": "instant",
            "query": "Developer infrastructure companies building tools for AI engineering teams",
            "limit": 3,
            "view": "summary"
          },
      )
      print(response.status_code, response.json())
      ```

      ```javascript Node.js highlight={8} theme={null}
      const response = await fetch("https://api.brightdata.com/search/company", {
        method: "POST",
        headers: {
          "Authorization": `Bearer ${process.env.BRIGHTDATA_API_KEY}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          "mode": "instant",
          "query": "Developer infrastructure companies building tools for AI engineering teams",
          "limit": 3,
          "view": "summary"
        }),
      });
      console.log(response.status, await response.json());
      ```
    </CodeGroup>

    **Sample response**

    ```json theme={null}
    {
      "req_id": "re5aefd1a0b9c4b9d813af52ce935c26d",
      "meta": { "coverage_percent": 100, "matched": 1314, "offset": 0, "limit": 3 },
      "documents": [
        {
          "bright_id": "cff2fcd9da9a150b16cbc855777265c8de34f3a360986903f23f7f4e73fcf497",
          "data": {
            "name": "Flamerix AI",
            "slogan": "Infrastructure for controlled AI-driven software development.",
            "industry": "IT Services and IT Consulting",
            "headquarters_location": "Tbilisi",
            "headquarters_country_code": "GE",
            "company_size_from": 2,
            "company_size_to": 10,
            "employees_in_linkedin": 1,
            "linkedin_followers": 3,
            "website": "https://flamerix.ai/",
            "domain": "flamerix.ai"
          }
        }
      ]
    }
    ```
  </Tab>

  <Tab title="Smart">
    Smart runs the same interpretation as Instant, then reads each candidate and reorders them by how well the record answers the request, so the first result changes.

    **Sample request**

    <CodeGroup>
      ```bash cURL highlight={5} theme={null}
      curl --request POST "https://api.brightdata.com/search/company" \
        --header "Authorization: Bearer $BRIGHTDATA_API_KEY" \
        --header "Content-Type: application/json" \
        --data '{
          "mode": "smart",
          "query": "Developer infrastructure companies building tools for AI engineering teams",
          "limit": 3,
          "view": "summary"
        }'
      ```

      ```python Python highlight={11} theme={null}
      import os
      import requests

      response = requests.post(
          "https://api.brightdata.com/search/company",
          headers={
              "Authorization": f"Bearer {os.environ['BRIGHTDATA_API_KEY']}",
              "Content-Type": "application/json",
          },
          json={
            "mode": "smart",
            "query": "Developer infrastructure companies building tools for AI engineering teams",
            "limit": 3,
            "view": "summary"
          },
      )
      print(response.status_code, response.json())
      ```

      ```javascript Node.js highlight={8} theme={null}
      const response = await fetch("https://api.brightdata.com/search/company", {
        method: "POST",
        headers: {
          "Authorization": `Bearer ${process.env.BRIGHTDATA_API_KEY}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          "mode": "smart",
          "query": "Developer infrastructure companies building tools for AI engineering teams",
          "limit": 3,
          "view": "summary"
        }),
      });
      console.log(response.status, await response.json());
      ```
    </CodeGroup>

    **Sample response**

    ```json theme={null}
    {
      "req_id": "r8f4b4e27936b40aaaa342a894f4ac460",
      "meta": { "coverage_percent": 100, "matched": 1294, "offset": 0, "limit": 3 },
      "documents": [
        {
          "bright_id": "c455ef8769b2656cfe67d4a534edb30ff0f55d0241ea95d04e32835684cf3bf8",
          "data": {
            "name": "Skyflo",
            "slogan": "AI engineering harness for coding agents, tools, context, and long-running work.",
            "industry": "Software Development",
            "headquarters_location": "Pune, Maharashtra",
            "headquarters_country_code": "IN",
            "company_size_from": 2,
            "company_size_to": 10,
            "employees_in_linkedin": 2,
            "linkedin_followers": 214,
            "website": "https://skyflo.ai/",
            "domain": "skyflo.ai"
          }
        }
      ]
    }
    ```

    <Note>
      If Smart's ranking step fails, the request returns the results Instant would have returned rather than an error, and it is still billed as Smart.
    </Note>
  </Tab>
</Tabs>

## Compare the modes

| Mode        | Query input             | Results per search (included / maximum) | Typical response time | When to use                                                                 |
| ----------- | ----------------------- | --------------------------------------- | --------------------- | --------------------------------------------------------------------------- |
| `ludicrous` | Structured conditions   | 100 / 1,000                             | \~50ms                | Your application already knows which fields to filter on                    |
| `instant`   | Plain-language sentence | 100 / 1,000                             | \~1 second            | Natural language at interactive speed; the default for interactive use      |
| `smart`     | Plain-language sentence | 10 / 100                                | \~2 to 3 seconds      | Result quality matters more than latency, or a wrong first result is costly |

## What is the rate limit?

Business Search allows 60 requests per minute by default, counted per account, per category and per mode. Company and people searches therefore have separate budgets, as do Ludicrous, Instant and Smart within each category. A request over the limit returns HTTP 429 with a `Retry-After` header and is neither searched nor billed. See [Business Search error codes](/products/business-search/error-codes#what-happens-when-the-rate-limit-is-exceeded) for the retry rule.

## Where do you go next?

<CardGroup cols={2}>
  <Card title="Quickstart" icon="rocket" href="/products/business-search/quickstart">
    Send your first company search and read the response.
  </Card>

  <Card title="Pricing" icon="tag" href="/products/business-search/pricing">
    Per-1,000-search rates by mode and what counts as billable.
  </Card>
</CardGroup>

## Frequently asked questions

### Is Business Search an enrichment product?

No. Business Search discovers and retrieves records. To add detail to records you already have, use [Scraper API](/products/scrapers/overview) or your own stack.

### How fresh is the Business Search index?

The index refreshes daily. A record added or changed at the source appears in Business Search results after the next daily refresh.