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

# Enrow API

> Overview of the Enrow API to find and verify professional emails and phone numbers at scale, with async searches, webhooks, and bulk processing

The Enrow API lets you find and verify professional contact information at scale. Every request is authenticated with an [API key](/authentication) in the `x-api-key` header, and every search runs asynchronously so you can process large volumes without blocking.

<Note>
  **Base URL** — All API requests go to `https://api.enrow.io`
</Note>

## What can I do with the Enrow API?

The Enrow API exposes three core features, each available in both single and bulk mode:

<CardGroup cols={2}>
  <Card title="Email Finder" icon="envelope" href="/api-reference/email-finder/find-single">
    Find professional email addresses from a name and company domain
  </Card>

  <Card title="Email Verifier" icon="shield-check" href="/api-reference/email-verifier/verify-single">
    Verify any email address with determinist catch-all verification
  </Card>

  <Card title="Phone Finder" icon="phone" href="/api-reference/phone/find-single">
    Find direct phone numbers from a LinkedIn URL or name + company
  </Card>
</CardGroup>

## How does the Enrow API work?

All endpoints are **asynchronous** and follow the same pattern: you submit a search, then collect the result via webhook or polling.

<Steps>
  <Step title="POST your request">
    Send your search parameters. You receive a unique search ID immediately.
  </Step>

  <Step title="Get notified or poll">
    **Webhook (recommended):** Pass a `webhook` URL in `settings` and get the result POSTed to your server instantly. See [How webhooks work](/how-webhooks-work).

    **Polling:** Call the GET endpoint with the search ID.
  </Step>

  <Step title="Use the result">
    The `qualification` field tells you if the result is `valid`, `invalid`, `found`, or `not_found`.
  </Step>
</Steps>

## How do I make my first request?

Authenticate with your API key in the `x-api-key` header and POST a search to the relevant endpoint. The example below runs a single email search:

<Tabs>
  <Tab title="cURL">
    ```bash theme={null}
    curl -X POST https://api.enrow.io/email/find/single \
      -H "x-api-key: YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "fullname": "Dwight Schrute",
        "company_domain": "dundermifflin.com"
      }'
    ```
  </Tab>

  <Tab title="Node.js">
    ```javascript theme={null}
    const response = await fetch('https://api.enrow.io/email/find/single', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': process.env.ENROW_API_KEY
      },
      body: JSON.stringify({
        fullname: 'Dwight Schrute',
        company_domain: 'dundermifflin.com'
      })
    });

    const data = await response.json();
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    import requests, os

    response = requests.post(
        "https://api.enrow.io/email/find/single",
        headers={"x-api-key": os.getenv("ENROW_API_KEY")},
        json={
            "fullname": "Dwight Schrute",
            "company_domain": "dundermifflin.com"
        }
    )
    print(response.json())
    ```
  </Tab>
</Tabs>

**Response:**

```json theme={null}
{
  "message": "Single search operating",
  "id": "910f3e13-b2bf-442d-ab0b-4cf44d...",
  "credits_used": 1
}
```

The POST is asynchronous — the `email` and `qualification` are retrieved later via the [GET endpoint](/api-reference/email-finder/get-single-result) or a [webhook](/how-webhooks-work).

## Should I use single or bulk mode?

Use single mode for real-time, one-off lookups, and bulk mode for large-scale enrichment. Every endpoint supports both:

|                | Single                 | Bulk                          |
| -------------- | ---------------------- | ----------------------------- |
| **Batch size** | 1                      | Up to 5,000 (3,000 for phone) |
| **Best for**   | Real-time lookups      | Large-scale enrichment        |
| **Webhook**    | Full result in payload | Notification, then GET        |

For bulk jobs, see [Find Bulk Emails](/api-reference/email-finder/find-bulk), [Verify Bulk Emails](/api-reference/email-verifier/verify-bulk), and [Find Bulk Phones](/api-reference/phone/find-bulk).

## What makes the Enrow API different?

The Enrow API combines determinist verification with flexible result delivery, so you get accurate data without extra tooling:

<CardGroup cols={2}>
  <Card title="Catch-all verification" icon="check-double">
    Determinist verification that works even on catch-all domains. No debouncer needed.
  </Card>

  <Card title="Custom fields" icon="tag">
    Pass your own `custom` data with each search — it's returned as-is in the result.
  </Card>
</CardGroup>

<Card title="Webhooks" icon="bolt" href="/how-webhooks-work">
  Get results in real-time. No polling, no wasted API calls.
</Card>

## FAQ

<AccordionGroup>
  <Accordion title="How do I authenticate API requests?">
    Every request must include your API key in the `x-api-key` header — there are no OAuth flows or bearer tokens. See [Authentication](/authentication) for setup and examples.
  </Accordion>

  <Accordion title="Why are responses asynchronous?">
    A POST request starts a search and returns a unique `id` immediately. The `email`, `phone`, or `qualification` is delivered later via a [webhook](/how-webhooks-work) or by polling the matching GET endpoint with that `id`.
  </Accordion>

  <Accordion title="How many searches can I run in one bulk request?">
    Bulk email and email verification requests accept up to 5,000 searches, and bulk phone requests accept up to 3,000. For single requests, the batch size is 1.
  </Accordion>

  <Accordion title="How are credits consumed?">
    Credits are deducted per search and the amount is returned in `credits_used`. See [Credits & billing](/credits-billing) for per-endpoint costs and [Rate limits](/rate-limits) before scaling up.
  </Accordion>
</AccordionGroup>

## Next steps

<CardGroup cols={2}>
  <Card title="Authentication" icon="key" href="/authentication">
    Set up your API key in the x-api-key header
  </Card>

  <Card title="How webhooks work" icon="bolt" href="/how-webhooks-work">
    Get results in real-time, no polling needed
  </Card>

  <Card title="Credits & billing" icon="coins" href="/credits-billing">
    Understand how credits are consumed per endpoint
  </Card>

  <Card title="Error handling" icon="circle-info" href="/error-handling">
    Status codes, qualifications, and error formats
  </Card>
</CardGroup>