Clay API Review 2026: Can You Actually Build on It?

The question behind any API evaluation is whether the surface gives you enough programmatic control to justify the dependency. With Clay, the question is more basic: is there an API to build on at all?

Clay's programmatic access is not what most developers expect when they hear "API." There is no versioned REST endpoint catalogue, no public base URL, and no OpenAPI spec.

What Clay offers instead is a set of programmatic access points (inbound webhooks, an enterprise-only lookup API, MCP server connections, and an HTTP API tool for calling external services) built around a workflow-first platform where tables, enrichment columns, and credit-based marketplace queries do the work.

Clay's own documentation is explicit: "Clay isn't built like a typical SaaS tool where you send a request to an endpoint and get data back in milliseconds."

That is not a criticism. It is an architectural choice that shapes everything a developer can and cannot do.

The Clay API is likely the right choice if:

• You want to trigger enrichment workflows by POSTing JSON to a webhook endpoint rather than building enrichment logic yourself.

• You need to orchestrate data from 150+ providers through one platform without managing individual provider contracts and API integrations.

• You are building an AI agent workflow and need Clay's enrichment capabilities exposed via MCP to ChatGPT, Claude, or Codex.

• You are on Clay's Enterprise plan and need lightweight person or company lookups from Clay's proprietary data layer.

• Your pipeline already runs inside Clay tables and you need programmatic entry points to feed data in or push results out.

However, it might not be the right fit if:

• You need a conventional REST API with documented endpoints, structured request/response schemas, and millisecond-range latency.

• You need direct, programmatic access to B2B contact and company data (emails, phone numbers, org charts, intent signals) without routing through a workflow platform.

• You need OAuth 2.0, scoped permissions, or token rotation for a multi-tenant integration.

• You want official SDKs or an OpenAPI specification to generate client code.

• You need published rate limits and throughput guarantees for a production data pipeline.

• Your build requires bulk enrichment via API at volumes beyond 50,000 records without enterprise-tier auto-delete.

In this case, you should consider ZoomInfo, a GTM platform with a conventional API surface. Its Enterprise API is a REST suite at https://api.zoominfo.com/gtm covering search, enrichment, AI intelligence, and audience management across 500M contacts and 100M companies, with OAuth 2.0 authentication, tiered rate limits up to 35 req/sec, and an MCP server for AI-agent workflows.

This article reviews both: Clay's programmatic surfaces, then ZoomInfo's API for builds that need a conventional REST layer.

Clay API at a Glance

Clay API: What Works Well & What to Plan Around

Clay API: Authentication & Getting Started

Clay's authentication model varies by programmatic surface because there is no single API with a unified auth layer.

Workspace API key: Found in Settings > Account. This static key handles Clay-native enrichments like cross-table row lookups. There is no OAuth flow, no token rotation, and no scoped access. One key per workspace, and it never changes.

Inbound webhooks: Every Clay table can become a webhook source, generating a unique HTTPS POST URL. The URL itself is the authentication: secret by default, shown only once at creation. You can add an authentication token in the request header for additional security. No API key is required to POST to a webhook endpoint, which simplifies integration but means anyone with the URL can submit data.

HTTP API enrichment tool (calling external APIs from Clay): When Clay calls an external API on your behalf, it stores credentials at the workspace level as reusable HTTP header key-value pairs. Clay supports any header-based auth scheme: API key headers, static bearer tokens, or custom headers.

For APIs that issue short-lived tokens, a dedicated JWT authentication action performs a two-step flow: Clay calls the token endpoint with stored credentials, receives a JWT, and attaches it as a bearer token on subsequent requests. Tokens auto-refresh approximately every 55 minutes.

MCP server: Authentication runs through the MCP settings in the workspace. Workspace admins control which Clay Functions AI tools can access and set per-user credit limits. MCP credit limits reset on the 1st of each month at midnight UTC.

There is no getting-started flow that resembles typical developer onboarding (register an app, get credentials, make your first call). The closest path is creating a webhook table, copying the URL, and POSTing a JSON payload:

curl -X POST "https://app.clay.com/webhook/YOUR_UNIQUE_WEBHOOK_URL" \

-H "Content-Type: application/json" \

-d '{"email": "test@example.com", "company": "Acme Corp"}'

The payload creates a new row in the Clay table, and any enrichment columns on that table run automatically against the incoming data.

Clay API: Core Endpoints & Capabilities

Calling these "endpoints" requires qualification. Clay's programmatic surfaces are not a REST API with resource-oriented URLs. They are entry points into a workflow platform. Here is what each surface does and what you would build with it.

Inbound Webhooks (All Plans Including Free)

Source: Loops.so

Every Clay table can become a "Monitor webhook" source, generating a unique HTTPS POST URL that accepts JSON payloads. When a payload arrives, Clay creates a new row in the table, and every enrichment column runs against that row automatically.

This is the most API-like workflow Clay offers. You POST structured data in, Clay's enrichment engine processes it through whichever providers you have configured (waterfall enrichment across 150+ sources), and the enriched results sit in the table ready for export or downstream action.

What you would build with this: A CRM integration that pushes new leads to Clay via webhook, triggers waterfall email verification and company enrichment, then exports enriched records back to the CRM via Clay's outbound HTTP API action. The webhook triggers; Clay's table processes.

Constraints:

• Capacity is capped at 50,000 submissions per webhook table, and this limit persists even after you delete rows. When you hit the limit, you must create a new webhook.

• Enterprise plan only: the auto-delete (passthrough) feature removes rows after enrichment completes, enabling unlimited submissions for high-volume continuous workflows.

• Clay does not document webhook delivery retry or failure behavior for outbound webhooks.

HTTP API Enrichment Tool (Within Clay Tables)

This is a tool Clay uses, not an API Clay exposes. From within a Clay table, you can add an HTTP API action column that calls any external REST API (GET, POST, PUT, DELETE) on a per-row basis. Clay maps the response JSON to table columns, with support for extracting nested fields.

The same tool can serve as a data source, importing up to 50,000 rows from an external API into a Clay table. Pagination options include page-based, offset, cursor, and full URL methods.

What you would build with this: A workflow that pulls leads from your internal database via API, enriches them in Clay with marketplace providers, then pushes enriched records to your CRM via another HTTP API call, all orchestrated within a single Clay table. You build the pipeline inside Clay's UI rather than in your own codebase.

Enterprise People & Company API (Enterprise Plan Only)

Clay offers a limited, fast lookup API for Enterprise customers that accepts an email address or LinkedIn URL and returns basic person details, or accepts a domain and returns basic company info. This is the closest surface to a traditional API that Clay exposes.

Constraints:

• The API returns only basic fields, not deep enrichment data (emails, phone numbers, revenue).

• It queries Clay's proprietary data layer only, not the full 150+ provider marketplace.

• No public endpoint documentation, no base URL, no request/response schema. Access requires contacting Clay's GTM engineers.

• No throughput figures are published.

Clay API Key (Cross-Table Lookups)

The workspace API key enables cross-table row lookups within Clay: look up a single row or multiple rows in another Clay table. This operates entirely within the platform and is not a general-purpose external API.

MCP Server

Clay's MCP server connects the Clay workspace to AI assistants including ChatGPT, Codex, and Claude. Workspace admins create reusable enrichment workflows called "Functions", enable them for MCP, and reps invoke them via natural language in their AI tool of choice.

Source: Clay

What you would build with this: An AI agent that queries Clay's enrichment capabilities conversationally ("find the VP of Engineering at Acme Corp and enrich with their work email and company tech stack") without writing any API integration code. The MCP server translates between natural language and Clay's enrichment engine.

Enterprise beta: reps can query Salesforce-synced account data through the AI tool via Clay's Audiences feature.

Clay API: Webhooks & Events

Clay supports webhooks in both directions, but the capabilities and constraints differ.

Inbound webhooks are Clay's primary programmatic entry point. Each table can receive HTTP POST payloads at a unique URL. Data arrives in real time and immediately triggers enrichment columns. The 50,000-submission lifetime cap per table is the hard constraint for non-enterprise users.

Outbound webhooks work through the HTTP API action: Clay tables can send enriched data to any webhook endpoint, including Zapier, Make (Integromat), or custom receivers.

A dedicated Zapier integration uses Zapier's native webhook trigger for simpler setups.

Signals and triggers provide event-driven automation inside Clay. Built-in signal monitors fire when specific real-world events occur: job changes, promotions, new hires, news, fundraising, and web intent (visitor tracking).

These are inbound events that trigger Clay workflow runs automatically rather than outbound webhooks.

Two things to plan around:

• Clay does not publicly document webhook delivery retry or failure behavior for outbound calls. Design your receiver to be idempotent regardless.

• Inbound webhook URLs are the sole authentication mechanism by default. Treat them as secrets; anyone with the URL can submit data to your table.

Clay API: SDKs, Docs & Rate Limits

SDKs & Libraries

Clay does not publish official SDKs in any language. There are no maintained client libraries, no GitHub repositories, and no community-endorsed wrappers. This follows from Clay's architecture: no conventional public REST API means no SDK surface to wrap.

The closest programmatic interfaces are:

• The MCP server, which integrates Clay with AI tools using the Model Context Protocol standard.

• The Zapier integration, which lets non-technical users trigger Clay workflows from Zapier's ecosystem.

• Make (Integromat), which can wrap Clay via HTTP modules to create pseudo-API endpoints that proxy into Clay enrichment workflows.

Developers who need to interact with Clay programmatically outside these channels use direct HTTP calls to webhook URLs or the HTTP API enrichment tool within Clay tables.

Documentation & Developer Experience

Clay's documentation lives at university.clay.com/docs, organized around workflow stages (Getting Started, Find, Enrich, Transform, Web Scraping, Gen AI, Export, Settings & Admin, Signals & Triggers) covering 100+ integrations. An AI-powered search assistant is built into the docs.

The documentation includes how-to guides for individual integrations and dedicated articles for API-adjacent topics: HTTP API setup, JWT authentication, webhook configuration, API key location, and MCP settings.

What the documentation does not include:

• No OpenAPI or Swagger specification

• No Postman collection

• No interactive API explorer (because there is no public REST API to explore)

• No API changelog distinct from the main product changelog

• No public endpoint reference for the Enterprise People & Company API

• No documentation of rate limits, error codes, or retry behavior for webhook delivery

Developer support runs through Clay's Slack community and, for Enterprise customers, a dedicated Growth Strategist. There is no developer support tier for API integrators. Companion courses at Clay University offer structured learning paths and certifications, but they target workflow builders, not API developers.

Rate Limits & Constraints

Clay does not publish rate-limit numbers (requests per second, per minute, or per hour) for any of its programmatic interfaces. The documented constraints are structural rather than throughput-based:

• Webhook table capacity: 50,000 submissions per table, lifetime. Enterprise auto-delete lifts this for passthrough workflows.

• HTTP API source imports: Up to 50,000 rows per import when using the HTTP API tool as a data source.

• Credit-based consumption: All enrichment actions consume Actions and Data Credits. Admins can set credit budgets per workspace (Enterprise only) and per-user credit limits for MCP usage.

• Processing latency: Enrichments run asynchronously, row by row. Responses take minutes, not milliseconds, as Clay processes each row through its enrichment pipeline.

The absence of published rate limits matters. A developer building a production pipeline against Clay's webhook endpoints has no documented ceiling for requests per second, and no documented behavior for what happens when that ceiling is hit.

Clay API Pricing & Access Costs

Clay's pricing uses two usage currencies rather than per-API-call charges.

Actions measure platform orchestration: enriching data, running a table, calling an AI model, sending data to a third-party system, or exporting data. Actions start at less than $0.01 each and reset monthly without rollover.

Data Credits purchase data from Clay's marketplace of 150+ providers: finding emails, phone numbers, company data. Data credits start at $0.05 each and roll over (Launch and Growth plans accumulate up to 2x the monthly credit amount; Enterprise gets custom rollover terms).

Programmatic access is gated by plan tier:

The Enterprise People & Company API, the only surface that resembles a traditional lookup API, is available exclusively on Enterprise plans with custom pricing.

For a developer sizing costs: the free tier gives you 500 actions and 100 data credits per month, enough to test webhook-triggered enrichment workflows at small scale. Production usage on the Growth plan at $446/month annual gives you 40,000 actions and 6,000 data credits.

At $0.05 per data credit, each enrichment that returns a result costs at least one data credit ($0.05), plus one action. Data credits are only charged when a result is found, not for every provider attempted in a waterfall sequence.

Additional cost variables: variable-price AI models (the reasoning models for Claygent prompts and research) are charged based on actual token consumption, with Clay withholding estimated credits upfront and reconciling after execution.

Final costs can differ from estimates. Mid-period data credit top-ups on Launch and Growth plans carry a 30% premium.

Where the Clay API Falls Short

These are the practical limits a developer should plan around when building on Clay's programmatic surfaces.

There is no conventional REST API to build against. Clay's architecture is workflow-first, not API-first. There is no base URL you can call with a structured request and receive a structured response in milliseconds. The inbound webhook, the closest thing to an API endpoint, triggers an asynchronous enrichment pipeline. Developers who need to call an endpoint, get data back, and proceed cannot do that with Clay.

The Enterprise People & Company API has no public documentation. The only surface that resembles a traditional lookup API is gated behind an Enterprise plan, has no public endpoint reference, no request/response schema, and no published throughput figures. A developer cannot evaluate it without contacting Clay's sales team.

No published rate limits. For any of Clay's programmatic surfaces, there is no documentation of requests per second, per minute, or per hour. A production pipeline has no way to know in advance when it will be throttled or how Clay will respond when limits are hit.

No SDKs, no OpenAPI spec. There are no client libraries in any language and no machine-readable API specification. Every integration requires raw HTTP to a webhook URL or manual configuration inside Clay's UI.

Webhook tables have a 50,000-submission lifetime cap. For non-enterprise users, each webhook table accepts 50,000 submissions total, and this limit does not reset when you delete rows. At production volumes, you cycle through webhook tables.

Processing is asynchronous and measured in minutes. Clay's enrichment pipeline processes rows one by one through marketplace providers. A developer who needs sub-second response times for data lookups is working against Clay's architecture.

Static API key with no scoped access. The workspace API key is a single, static credential with no OAuth, no token rotation, and no ability to scope permissions. For multi-tenant integrations where each customer authenticates independently, this model does not work.

ZoomInfo API: The Conventional REST Surface Clay Does Not Offer

Clay gives developers a workflow platform with programmatic triggers.

ZoomInfo gives developers a structured REST API with documented endpoints, OAuth 2.0, and direct access to B2B data at the request level. The API draws on ZoomInfo's GTM Context Graph, which processes 1.5B+ data points daily by combining ZoomInfo's B2B dataset with your first-party data.

The distinction is architectural: Clay processes data through enrichment tables; ZoomInfo returns data from API calls.

What the API Covers

ZoomInfo's Enterprise API is a REST suite served from https://api.zoominfo.com/gtm, organized into four areas documented in the interactive API reference:

Data API (Search & Enrich): Search endpoints cover Contacts, Companies, Intent, News, and Scoops, returning matched records without consuming credits.

Enrich endpoints return the full payload: business emails, direct dials, employment history, corporate hierarchy, org charts, technographics, and hashtag signals, up to 25 records per call.

The underlying dataset spans 500M contacts, 100M companies, 135M+ verified phone numbers, and 200M+ verified business email addresses. The search-then-enrich pattern lets you filter freely and pay only for the records you commit to.

Copilot API (AI Intelligence): These endpoints surface the AI capabilities built into GTM Workspace. Account Summary returns structured account intelligence with a free-form Q&A endpoint.

Find Similar Companies performs lookalike expansion.

Contact Recommendations returns AI-ranked buying-committee suggestions by motion (prospecting, deal acceleration, renewals).

Marketing API: CRUD endpoints for programmatic audience management.

Platform API (Engagements, Beta): Bidirectional engagement data via the Engagements API.

A developer building an enrichment pipeline calls ZoomInfo's search endpoint, filters to matching records (free, no credits consumed), enriches the records they want (one credit per new record), and processes the structured JSON response in their own code.

The entire round trip happens in a single HTTP request/response cycle.

Authentication & Access

ZoomInfo uses OAuth 2.0 with PKCE via Okta, supporting three flows: Authorization Code with PKCE (web applications), Client Credentials (server-to-server), and Refresh Token. Access tokens are 24-hour Bearer tokens with rotating refresh tokens.

Teams register applications through the ZoomInfo Developer Portal, where they generate credentials, define scopes, and test endpoints.

This differs from Clay's static workspace key. OAuth 2.0 supports delegated access, credential rotation, and scoped permissions, making it suitable for multi-tenant integrations and enterprise security requirements.

Rate Limits, Credits & Developer Experience

ZoomInfo publishes rate limits by tier: Builder (5 req/sec), Standard (25 req/sec), and Scaling (35 req/sec), with per-hour and per-day sliding-window limits enforced simultaneously. Every response includes quota headers with remaining capacity, and 429 responses include a Retry-After header with exact backoff timing.

Credits follow a rolling 12-month window: a record enriched for the first time consumes one credit; re-enriching the same record within the year is free. Search and lookup operations do not consume credits.

ZoomInfo does not publish official SDKs either, so both platforms require direct HTTP integration. The interactive API reference supports live testing with code generation in Shell, Node, Ruby, PHP, and Python.

An llms.txt index is available for AI development tools, and a Docs MCP server at https://docs.zoominfo.com/mcp lets AI coding tools generate integration code against the API spec.

For developers building AI agents, ZoomInfo's MCP server at https://mcp.zoominfo.com/mcp exposes search, enrich, and account research as native tools for MCP-compatible assistants, currently supporting Claude and ChatGPT.

ZoomInfo extended API access to all relevant plans, with consumption-based pricing quoted per customer.

BDO Canada reported an 87% reduction in time spent updating internal data dashboards using the ZoomInfo API, with one analyst calling the integration plug-and-play across any process. (ZoomInfo)

Clay API vs. ZoomInfo API

Final Verdict

Clay's programmatic surfaces are not an API in the way most developers use the term. They are entry points into a GTM workflow platform: webhook triggers that fire enrichment pipelines, an MCP server that connects AI assistants to enrichment logic, and an enterprise-only lookup endpoint with no public documentation.

For teams already building inside Clay's table-based environment, these surfaces extend the platform to programmatic triggers and AI integrations without requiring separate data infrastructure.

Clay's programmatic surfaces fit if your build is workflow-first: you want to trigger enrichment across 150+ data providers by POSTing to a webhook, orchestrate data flows inside Clay's table UI, or connect AI agents to Clay's enrichment engine via MCP.

The free tier gives you a starting point for webhook-triggered workflows, and waterfall enrichment across multiple providers is something no single-source API replicates.

Choose the ZoomInfo API if your build needs direct, synchronous access to B2B data at the endpoint level: searching contacts and companies, enriching records with a structured response, detecting buyer intent, or generating AI-powered account intelligence, all through documented REST endpoints with OAuth 2.0, published rate limits, and predictable request/response patterns.

Explore the ZoomInfo Enterprise API or start with the developer docs to see the endpoint surface directly.

A developer who needs neither surface should know that Clay and ZoomInfo solve different problems at different architectural layers.

Clay orchestrates workflows across many data sources; ZoomInfo provides the data directly. If your pipeline needs both orchestration and direct data access, the two are complementary.

FAQ

Is the Clay API free?

Clay offers a permanent free tier with 500 actions/month and 100 data credits, which includes inbound webhook access and the HTTP API enrichment tool. This is enough to test webhook-triggered enrichment workflows at small scale. The MCP server requires a paid plan (Launch at $167/month annual or above).

The Enterprise People & Company API, Clay's only traditional lookup endpoint, is available exclusively on the Enterprise plan at custom pricing. There are no per-API-call charges; all usage is metered through Actions and Data Credits.

Does Clay have a REST API?

Not in the conventional sense. Clay's own documentation states it is not built like a typical SaaS tool where you send a request and get data back in milliseconds.

The platform offers inbound webhooks (HTTP POST to trigger workflows), an HTTP API enrichment tool (for calling external APIs from within Clay), cross-table lookup via the workspace API key, an MCP server for AI assistant integration, and an Enterprise-only People & Company API with no public documentation.

There is no versioned REST endpoint catalogue, no public base URL, and no OpenAPI specification.

What are Clay's API rate limits?

Clay does not publish rate-limit numbers for any of its programmatic interfaces. The documented constraints are structural: webhook tables accept up to 50,000 submissions (lifetime), HTTP API imports support up to 50,000 rows, and all enrichment actions consume Actions and Data Credits from the plan's monthly allocation.

Processing is asynchronous, with enrichments running row by row through marketplace providers at a pace measured in minutes, not milliseconds.

Are there official Clay SDKs?

No. Clay does not publish official SDKs in any language, and there are no maintained client libraries or GitHub repositories. The closest programmatic interfaces are the MCP server (for AI tool integration), the Zapier integration (for workflow automation), and Make/Integromat modules. Developers building direct integrations work with HTTP calls to webhook URLs or configure the HTTP API enrichment tool within Clay's UI.

Does Clay support webhooks?

Yes, in both directions. Inbound webhooks let you POST JSON to a unique per-table URL, which creates a row and triggers all enrichment columns automatically. Outbound webhooks work through the HTTP API action, which can send enriched data to any external endpoint, including Zapier and Make.

Clay also offers built-in signal monitors (job changes, funding events, web intent) that trigger workflows automatically. Clay does not publicly document webhook delivery retry and failure behavior for outbound calls.

What does ZoomInfo's API add to a Clay build?

ZoomInfo's API provides the structured, synchronous data access layer that Clay's programmatic surfaces do not offer. Where Clay triggers asynchronous enrichment workflows through webhook-based table processing, ZoomInfo's REST API returns search results and enriched records in real time via documented endpoints with predictable response schemas.

The practical pairing: use ZoomInfo's search endpoints to find contacts and companies matching your ICP (free, no credits consumed), enrich the records you want, and push the structured results into Clay tables via webhook for further workflow processing, sequencing, or CRM sync.

ZoomInfo's MCP server also extends this to AI agent workflows, with the same data accessible from Claude, ChatGPT, or any MCP-compatible assistant.