# Use B2Benrich in Clay with an HTTP API column

> Call the B2Benrich API from a Clay table: set up the HTTP API column, map the request and the response fields, and run it on a whole list.

Source: https://www.b2benrich.com/guides/clay-http-api  
Author: Dag Holmen, B2Benrich · Updated 2026-10-28

Clay’s HTTP API column lets you call any REST API from a table, once per row, and turn the response into new columns. B2Benrich fits it well. Every endpoint is a POST request with a JSON body and one header for your API key, so the setup is the same whether you’re finding emails, enriching companies or pulling people at an account.

This guide sets up two columns, an email finder and a company enrichment, then covers testing, running it on a full table and chaining columns together.

## What you need

- A Clay table with the inputs for the call. For the email finder that’s `First Name`, `Last Name` and `Domain`.
- A B2Benrich API key. You get one when you [sign up](https://app.b2benrich.com/auth/sign-up).
- The endpoint reference at [docs.b2benrich.com](https://docs.b2benrich.com), for the exact request and response of each call.

## Set up the HTTP API column

In your table, add an enrichment and choose HTTP API. Then fill in the request:

1. **Method:** `POST`. Every B2Benrich endpoint uses POST.
2. **URL:** the base URL plus the endpoint path.
3. **Headers:** `X-Api-Key` set to your key, and `Content-Type` set to `application/json`.
4. **Body:** JSON, with column references where the row values go.

For the [email finder API](https://www.b2benrich.com/guides/email-finder-api), the full config looks like this:

```json
{
  "method": "POST",
  "url": "https://api.b2benrich.com/v1/enrich/person/name-domain-to-email",
  "headers": {
    "X-Api-Key": "YOUR_B2BENRICH_API_KEY",
    "Content-Type": "application/json"
  },
  "body": {
    "first_name": "{{First Name}}",
    "last_name": "{{Last Name}}",
    "domain": "{{Domain}}"
  }
}
```

Insert the column references with Clay’s own column picker rather than typing them, so they point at the right columns. Keep the quotes around each reference. The API expects strings.

## Map the response to columns

For each row, the cell holds the JSON response. For the email finder it looks like this:

```json
{ "status": "found", "email": "maya.chen@acme.com" }
```

Pull `email` and `status` out as their own columns. Keep the status column, because it’s how you filter later. Only rows where an email was found should move on to a sequence or to an [email verification](https://www.b2benrich.com/guides/email-verification-api) step.

## Example two: company enrichment from a domain

The [company enrichment API](https://www.b2benrich.com/guides/company-enrichment-api) works the same way with a different path and a one-field body.

```json
{
  "method": "POST",
  "url": "https://api.b2benrich.com/v1/enrich/companies/domain-to-company",
  "headers": { "X-Api-Key": "YOUR_B2BENRICH_API_KEY", "Content-Type": "application/json" },
  "body": { "input": "{{Domain}}" }
}
```

The response has `status`, `company_id` and `data`. Map `company_id` to a column, because other endpoints accept it, and pick the company fields you need from `data`, such as industry and size.

The `input` field takes a plain domain like `acme.com`. If your column holds full website URLs, add a formula column that strips the protocol and path first.

## Test on a few rows, then run the table

Run the new column on five or ten rows before you run it on everything. Check three things:

- **Every row returns a response.** An authentication error almost always means a typo in the key or the header name.
- **The mapped columns fill in.** If they’re empty, open one cell and compare the JSON to your mapping.
- **Rows with missing inputs.** Set the column to run only when the input columns aren’t empty, so blank rows don’t send empty requests.

When the sample looks right, run the whole table. Because B2Benrich is unlimited API usage for $500 a month, with no credits, you can run it on big tables without per-row credit costs on the B2Benrich side. Re-running a column after you fix a mapping costs nothing extra either.

## Chain columns together

Each column’s output can feed the next column’s body. A common chain for building a list from a column of domains:

1. **Company enrichment:** `domain-to-company`, to confirm the account and get firmographics.
2. **People at the account:** `POST /v1/search/company-employees` with `{ "domain": "{{Domain}}", "job_level": "VP", "page": 1, "page_size": 3 }`, to find the buyers. This returns a list of people, so split it into rows with Clay before the next step.
3. **Email finder:** `name-domain-to-email` on each person, with the config above.

You can also use B2Benrich as one step in a Clay waterfall. Run it first, then let the next providers in the waterfall handle the rows it didn’t fill. The [people enrichment API](https://www.b2benrich.com/guides/people-enrichment-api) is another good waterfall step when you start from LinkedIn profile URLs.

## Intent data in Clay

B2Benrich is adding intent data to its API, and it’ll work in Clay the same way: an HTTP API column with your domains in the body and the topics or signals mapped to columns. That lets you filter a table down to accounts researching your topics before you spend any time on buyers and emails. The [signal-based outbound](https://www.b2benrich.com/guides/signal-based-outbound) guide shows the full workflow that column would feed.

## Troubleshooting

| What you see | Likely cause | Fix |
|---|---|---|
| Authentication error on every row | Key or header name wrong | Header must be exactly `X-Api-Key` |
| Error about the request body | Body isn’t valid JSON, or a reference is missing quotes | Wrap each column reference in quotes |
| Empty result for some rows | Input column blank or holds a full URL | Add a run condition, clean domains first |
| Mapped columns empty | Field path doesn’t match the response | Open one cell and copy the field name from the JSON |

## Frequently asked questions

### What is the Clay HTTP API column?

It’s an enrichment in Clay that calls any REST API once per row. You set the method, URL, headers and a JSON body with column references, then map fields from the response to new columns.

### How do I add a custom API to Clay?

Add an enrichment, choose HTTP API, and enter the endpoint URL, method, headers and body. For B2Benrich the method is POST and the key goes in the X-Api-Key header.

### Can I use B2Benrich in a Clay waterfall?

Yes. Add B2Benrich as an HTTP API step in the waterfall, for example as the first email or company lookup, and let the later steps handle rows it doesn’t fill.

### Does running B2Benrich in Clay cost credits on the B2Benrich side?

No. B2Benrich is one plan with unlimited API usage and no credits, so the number of rows you run doesn’t change your B2Benrich bill.

### Will B2Benrich intent data work in Clay?

Yes. Once the intent endpoints are documented, you call them from an HTTP API column the same way as the email finder and company enrichment endpoints.
