canonical: https://jentic.com/apis/enrow.com/enrow

# Enrow API

Jentic publishes the only available OpenAPI specification for Enrow API, keeping it validated and agent-ready. Enrow provides email finding, email verification, and phone number discovery for B2B prospecting workflows. The API exposes single and bulk variants for each capability - find a professional email, verify deliverability, and discover phone numbers - plus an account info endpoint to monitor remaining credits. Both POST (start a job) and GET (retrieve a job) variants exist for each capability so integrations can submit asynchronously and poll for results.

## For AI agents

Find professional emails, verify deliverability, and discover phone numbers for B2B contacts via single or bulk operations.

## Scope

Does not handle company firmographics, LinkedIn profile enrichment, or outbound email sending - use for email finding, email verification, and phone discovery only.

## Capabilities

- Find a single professional email address from a person's name and company domain
- Submit a bulk email-finding job and retrieve the results when ready
- Verify whether a single email address is deliverable before outreach
- Run bulk email verification across a captured prospect list
- Discover a phone number for a contact via single or bulk lookup
- Pull account information to monitor remaining credits and plan limits

## Use cases

### Outbound Prospect List Enrichment

Sales operations teams take a list of LinkedIn-derived contacts and run them through POST `/email/find/bulk` and POST `/email/verify/bulk` to attach verified, deliverable emails before importing into a sequencing tool. The bulk endpoints return a job identifier that the integration polls via the matching GET endpoint until the job is complete. Replaces multi-tool workflows that previously required separate finder and verifier vendors.

Example prompt: Submit POST `/email/find/bulk` with a 200-row payload of (full_name, company_domain), then poll GET `/email/find/bulk` with the job_id until status is 'done' and download the results.

### Real-Time Email Verification at Form Submit

Embed POST `/email/verify/single` into a marketing form submission flow so risky and undeliverable addresses are rejected before they reach the CRM. The single-call endpoint returns within sub-second latency, suitable for synchronous validation. Keeps the database clean and protects the sender domain.

Example prompt: Call POST `/email/verify/single` for the submitted email and reject the form if the response is not 'deliverable'.

### Phone Discovery for Sales Outreach

Sales reps run a list of high-priority accounts through POST `/phone/bulk` to attach phone numbers for cold-calling outreach. The bulk job returns a downloadable result set when complete, and POST `/phone/single` covers ad-hoc, in-the-moment lookups during research. Useful for SDRs who blend multi-channel outreach.

Example prompt: Submit POST `/phone/bulk` with a list of 50 prospects and poll GET `/phone/bulk` until the job completes.

### AI Agent Prospect Enrichment Through Jentic

An AI sales agent uses Jentic to discover Enrow operations by intent and chains email finding, verification, and phone lookup into a single qualification pipeline. The Enrow x-api-key value stays in your Jentic One instance and never enters the agent's prompt context. The agent submits bulk jobs and polls for completion without bespoke wiring.

Example prompt: Search Jentic for 'find a professional email at a company', load POST `/email/find/single`, and execute it for the captured contact.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/email/find/single` | Find a single professional email |
| POST | `/email/find/bulk` | Submit a bulk email-finder job |
| GET | `/email/find/bulk` | Retrieve results for a bulk email-finder job |
| POST | `/email/verify/single` | Verify a single email address |
| POST | `/email/verify/bulk` | Submit a bulk email-verification job |
| POST | `/phone/single` | Discover a single phone number |
| POST | `/phone/bulk` | Submit a bulk phone-finder job |
| GET | `/account/info` | Read account info and remaining credit |

## Key resources

- **Email Finder** — Single and bulk endpoints for discovering a professional email from name and company domain.
- **Email Verifier** — Single and bulk endpoints for checking email deliverability.
- **Phone Finder** — Single and bulk endpoints for discovering phone numbers.
- **Account** — Read account information including remaining credits via GET `/account/info.`

## Why Jentic

- **Setup:** Wiring Enrow by hand means handling its x-api-key header auth, tracking its POST-then-GET pattern for bulk finds, and building your own retries against api.enrow.io. Through Jentic you install once, import the Enrow API from the API Directory, store the API key once, and your agent calls it.
- **Permission scoping:** Enrow sends the email or phone target in the request body rather than the URL, so scope the agent to the operations it needs, such as POST `/email/find/single` or POST `/email/verify/single.` You pick that allowed set, so an operation like phone discovery at POST `/phone/single` is only reachable if you include it.
- **Credential handling:** Your Enrow API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'find a professional email at a company' or 'verify an email address', and Jentic returns the matching Enrow operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Hunter** — Email finder and domain search with broader pattern coverage
- **Snov.io** — Email finder, verifier, and outreach platform
- **HubSpot** — Write enriched and verified contacts directly into the CRM

## FAQ

### Why is there no official OpenAPI spec for Enrow API?

Enrow does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Enrow API via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Enrow API use?

The Enrow API uses an API key passed in the x-api-key header on every request. Through Jentic, the key is stored in your Jentic One instance and injected at execution time so it never enters the agent context.

### Can I run bulk email-finding jobs with the Enrow API?

Yes. Submit a job with POST `/email/find/bulk` and poll GET `/email/find/bulk` with the returned job_id until the status is complete. The same submit-then-poll pattern applies to bulk verification and phone discovery.

### How do I verify an email address in real time?

Call POST `/email/verify/single` with the address. The endpoint returns a deliverability status synchronously, so you can use it inside form-submit flows to reject undeliverable addresses before writing to the CRM.

### What are the rate limits for the Enrow API?

The Enrow API uses credit-based metering rather than per-minute rate limits. Each find, verify, or phone lookup consumes credits from the account balance - call GET `/account/info` to check the remaining quota.

### How do I find a professional email through Jentic?

Search Jentic for 'find a professional email at a company', load POST `/email/find/single`, and execute it with the contact's full name and the company domain. Get started with Jentic One, the self-hosted execution layer.

### Can I limit what my agent is allowed to do with the Enrow API?

Yes. Because you run Jentic One yourself, your own rules decide which Enrow operations the agent may call, so you can grant only what a task needs, such as POST `/email/find/single` or POST `/email/verify/single.` Enrow sends the email or phone target in the request body rather than the URL, so scoping is done at the operation level: an operation like phone discovery at POST `/phone/single` is reachable only if you include it in the allowed set. Your Enrow API key stays in your own Jentic One instance and is injected at execution time, so it never enters the agent's prompt or context.