Clari API Review 2026: Can You Build a Revenue Data Pipeline on It?

The first question a developer asks about a revenue platform's API is not whether it exists, but whether it exposes enough data to justify building against it.

Clari's API is a REST surface documented as an OpenAPI 3.0 spec at developer.clari.com, currently at version 5.0.0. It covers forecast exports, opportunity data, activity logs, and audit events on the read side, plus an Ingestion API for pushing custom data into Clari's Account and Opportunity entities. A separate Clari Copilot API exposes conversation intelligence data: call recordings, transcripts, topics, and CRM objects linked to calls. The platform manages $5 trillion in revenue for 1,500+ customers including Adobe, IBM, and Zoom, and the underlying Revenue Database (RevDB) captures historical snapshots of every revenue signal change. That is a substantial data foundation.

But the API's scope and access model are narrower than the platform's breadth suggests.

Clari's API is built for one job: getting revenue execution data out of Clari (forecasts, opportunities, activities, audit trails) and pushing custom entity data in. It does not expose the platform's AI predictions, deal health scores, or Revenue Cadences programmatically. It does not provide contact enrichment, company intelligence, org charts, technographics, or buyer intent signals. And it is not self-serve: API access requires a feature flag enabled by Clari's support team, meaning you open a support ticket and CC your Customer Success Manager before you write your first line of integration code.

This is where ZoomInfo enters the picture. ZoomInfo exposes a REST API suite 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. The two APIs sit at different layers of the revenue stack: Clari's API moves revenue execution data through your pipeline, ZoomInfo's API provides the B2B intelligence that Clari's surface was never designed to cover.

This review covers the Clari API in full technical depth first (authentication, endpoints, rate limits, documentation, and pricing), then reviews ZoomInfo's API as the intelligence layer that fills the data gaps a revenue operations API leaves open.

Clari API at a Glance

Clari API: What Works Well & What to Plan Around

Clari API: Authentication & Getting Started

API access starts with a paid Clari subscription, but a subscription alone is not enough. The community documentation is explicit: Clari's support team must enable a feature flag. The recommended process is to open a support ticket and CC your Customer Success Manager (CSM) to activate access. There is no developer portal signup, no free sandbox, and no trial API environment.

Once Clari enables the flag, authentication uses a static API key generated inside the platform. Navigate to your user avatar, then Settings, then the API Token tab, and select "Generate New API Token." The platform shows the token only once at generation time, so store it securely. Revoking a token breaks any active integration using it, and deactivating a user automatically revokes all tokens that user created.

Pass the token as an apikey header on every request:

curl -X GET "https://api.clari.com/v4/opportunity?oppId=006XXXXXXXXXXXX" \

-H "apikey: YOUR_API_TOKEN" \

-H "Content-Type: application/json"

The Ingestion API (base URL https://api.clari.com/v2) requires a second header: a partnerkey issued to formal integration partners. This dual-header model gates write access more tightly than read access.

Two constraints to know before you build:

• There is no OAuth 2.0 flow. Authentication is a static key with no token rotation, no scoped permissions, and no delegated access model. For multi-tenant integrations where each customer authenticates independently, this is limiting.

• There is no credential scoping. Every token has the same level of access. You cannot create a read-only key for a reporting integration and a write-enabled key for an ingestion pipeline.

The Clari Copilot API uses its own separate authentication, documented at its own reference site. Access requires an active Copilot subscription.

Source: Clari Copilot API

Clari API: Core Endpoints & Capabilities

The main Clari API is organized around six resource areas. All endpoints return JSON. Exports can also produce CSV. The API handles revenue data extraction and custom data ingestion, not programmatic control of Clari's AI features.

Forecast Export

Endpoint: POST /export/forecast/{forecastId}

This is the primary data extraction endpoint. It queues an asynchronous bulk export of a Forecast Tab. Parameters include:

• timePeriod: fiscal quarter to export

• dataTypes: one or more of forecast, quota, forecast_updated, adjustment, crm_total, crm_closed

• currency: output currency

• format: JSON or CSV

• includeHistorical: when set to true, includes week-over-week historical data (the data unique to Clari that CRM exports cannot replicate)

The endpoint returns a jobId for async polling. A schedule parameter controls retry behavior if the job fails: NONE (no retry), ONCE (one retry after 30 minutes), or MAX (three retries with 30-minute gaps).

What you would build with this: a nightly pipeline that exports submitted forecast calls and quota history from Clari into a data warehouse (Snowflake, BigQuery) for custom reporting, trend analysis, or board-level dashboards that combine Clari's forecast data with financial actuals.

Source: Clari API

Bulk Export Framework

All async export jobs share a common lifecycle managed by these endpoints:

• GET /export/jobs/{jobId}: check status (SCHEDULED, STARTED, DONE, FAILED, CANCELLED, ABORTED)

• GET /export/jobs/{jobId}/results: retrieve the export file once status is DONE

• PATCH /export/jobs/{jobId}: cancel an in-progress job

• GET /export/jobs: list all jobs initiated by the authenticated user

The polling model is straightforward but lacks push notifications. There is no callback URL parameter, no webhook when a job completes, and no event subscription. Your integration polls until the status changes.

Source: Clari API

Opportunity API

Endpoint: GET /opportunity

Retrieves opportunity records by Salesforce opportunity ID. Accepts up to 100 oppId values per request. The response includes:

• Fields with trend history: old value, new value, date of change, and direction (positive, negative, neutral)

• A CRM score with both a message string and a numeric score

The trend history is the developer-facing surface of what Clari calls "time-series intelligence." Where Salesforce gives you the current state of a field, this endpoint gives you the trajectory: when close dates moved, how amounts changed, and in which direction.

Activity Export

Endpoint: POST /export/activity

Async bulk export of sales activity data. Supports filtering by activityTypes (MEETING, EMAIL_SENT, EMAIL_RECEIVED, ATTACHMENT_SENT, ATTACHMENT_RECEIVED), startDate, and endDate in ISO-8601 format. Output includes participant details, account and opportunity mappings, and email/attachment metadata.

What you would build with this: an activity-based scoring model that pulls engagement data from Clari (which captures activities from email and calendar without manual CRM logging) and feeds it into a custom lead or deal scoring pipeline.

Source: Clari API

Audit API

Two access patterns for compliance and operational visibility:

• POST /export/audit/events: async bulk export of audit events, filterable by actor, session type (WEB, IOS, ANDROID), date range, and event category

• GET /audit/events: paginated real-time query with limit (1 to 1,000, default 100) and nextLink for cursor-based pagination

The real-time query endpoint is useful for monitoring: tracking who submits forecasts, when they do it, and whether patterns indicate adoption issues or process gaps.

Ingestion API

Base URL: https://api.clari.com/v2

For integration partners pushing data into Clari's Account and Opportunity entities:

• POST /ingest/entity/{entity}: incremental upload, up to 100 records per JSON payload

• POST /ingest/bulk/entity/{entity}: bulk upload via multipart/form-data, max 10 MB per file, returns a jobId for async status polling

• GET /ingest/job/{jobId}: check bulk ingestion job status (SUCCESS, IN_PROGRESS, FAILED, QUEUED, VALIDATION_FAILED)

• POST /ingest/schema/{entity}/field and GET /ingest/schema/{entity}/field: manage picklist and multi-picklist field values for partner schemas

If validation fails on a bulk upload, Clari rejects the entire batch. You must correct and retry it. The incremental endpoint at 100 records per request is safer for pipelines where partial failures need isolation.

Source: Clari API

Administrative API

Endpoint: GET /admin/limits

Returns the org's concurrent export limit, monthly quota, running job IDs, submitted job IDs, and remaining quota. This is a pre-flight check: call it before queuing exports to confirm you have capacity, especially when multiple integrations share the same quota pool.

Clari Copilot API (Separate Product)

The Copilot API is a separate surface for conversation intelligence data:

• GET /calls: paginated list of recorded calls, filterable by status, date range, and participants

• GET /call-details?id=CALL_ID: full transcript, summary, and analytics for a single call

• GET /users: workspace users

• GET /topics and GET /v2/topics: topics discussed across calls

• GET /accounts, GET /opportunities: CRM objects linked to calls

• POST /create-call: ingest externally recorded calls (from Zoom, Twilio, or other sources) for transcription and analysis

All list endpoints support limit/skip pagination and date-range filters (filterModifiedGt/filterModifiedLt). What you would build with this: an automated pipeline that pulls call transcripts after every sales meeting, extracts key topics and objections via your own NLP layer, and feeds the results into a deal risk model alongside Clari's opportunity trend data.

Clari API: Webhooks & Events

Clari does not offer webhooks. Neither the main API spec nor the Copilot API documentation documents webhook endpoints, event subscriptions, or callback URLs.

The main API's export pipeline uses a polling model: you POST an export job, receive a jobId, then poll GET /export/jobs/{jobId} until the status returns DONE. There is no push notification when a job completes, no event stream for forecast changes, and no real-time notification when an opportunity's fields update.

For a developer building event-driven workflows (triggering a Slack alert when a forecast lands, updating a BI dashboard when a deal's close date slips, kicking off enrichment when a new contact appears), the absence of webhooks means you either poll on a schedule or accept latency. This is the most significant architectural constraint for real-time integration patterns.

Clari API: SDKs, Docs & Rate Limits

SDKs & Libraries

Clari does not publish official SDKs in any language. The community documentation recommends using a generic API client to test calls, then pairing that with an ETL tool or custom script to automate recurring exports. For the Copilot API, a Python sample file (copilot_calls_example.py) is linked from the docs, but this is example code, not a maintained SDK.

No official SDK means you own the auth layer, the polling logic, the error handling, the retry strategy, and the response parsing. For a nightly forecast export pipeline, this is manageable. For a production integration making dozens of endpoint calls with job-lifecycle management, the engineering overhead adds up.

Documentation & Developer Experience

The main API is documented as a full OpenAPI 3.0 spec at developer.clari.com. The interactive spec includes endpoint descriptions, request/response schemas with examples, and in-page "Authorize" functionality for testing authenticated calls. This is a standard Swagger/Redoc experience: navigate by tag (Bulk Export Framework, Forecast API, Audit API, Opportunity API, Activity API, Ingestion API), expand an endpoint, and test it with your token.

Supplementary documentation lives in the Clari Knowledge Base (authenticated customer portal), with articles on topics like "How to Read the Forecast Export" and "Generating a Token for Clari's API." The community forum has a Product Q&A section with developer-facing posts, including the key "Clari API: All You Need to Know" guide that explains the access provisioning process.

Source: Clari Community

The Copilot API has its own separate reference site. It is a JavaScript-rendered single-page app, so its content is not indexable without browser execution and is harder for AI developer tools to consume than a static spec.

Three things the documentation lacks:

• No public changelog or versioning history at developer.clari.com

• No Postman collection or downloadable OpenAPI spec file

• No developer sandbox or trial environment

Developer support is via email at support@clari.com, as listed in the API spec itself. For access provisioning, customers open support tickets and loop in their CSM. There is no dedicated developer community, Slack channel, or forum beyond the general Clari Community.

Rate Limits & Constraints

The Clari API operates under three rate-limiting models depending on which surface you call.

Main Export API:

Two overlapping org-level constraints, visible via GET /admin/limits:

• A concurrent job limit: a cap on how many export jobs can run simultaneously

• A monthly quota: a rolling 30-day cap on total export jobs submitted (the docs show a default of 1,000/month, adjustable via CSM request)

When either limit is hit, POST requests return HTTP 400 with codes like export_monthly_quota_reached. The retry schedule parameter on forecast exports can reduce quota exhaustion from transient failures.

Source: Clari API

Ingestion API:

100 requests per second per API token, with HTTP 429 returned on breach. Bulk ingestion files are capped at 10 MB. Incremental ingestion is capped at 100 records per request.

Copilot API:

10 requests per second, with a weekly quota of 100,000 requests. Exceeding the weekly quota returns HTTP 403.

The Ingestion API's 100 req/sec is generous for a data push surface. The Copilot API's 10 req/sec and 100K weekly cap is tight: at sustained pace, you exhaust the weekly quota in under three hours. If your integration pulls transcripts frequently or processes many calls, plan around that ceiling.

Clari API Pricing & Access Costs

Clari does not publish API pricing. The pricing page states "no extra platform fees for integrations," but this refers to native integrations (Salesforce, Slack, data warehouses) and does not clarify the API access model for custom development.

What first-party sources confirm:

• API access requires a paid Clari subscription and a CSM-enabled feature flag. Only existing customers who request activation can use it.

• The Ingestion API requires a partnerkey that appears to be issued to formal integration partners rather than all customers.

• No per-call, per-credit, or API add-on pricing is published.

• The monthly export quota defaults are adjustable via CSM request, suggesting that higher limits may involve contract renegotiation.

All signs point to API access being bundled into enterprise contracts on a quote-only basis. For a developer sizing the cost: the API itself may not cost extra, but you cannot access it without an enterprise Clari subscription, and you cannot know your quota limits until your CSM confirms them.

Source: Clari

Where the Clari API Falls Short

These are the practical limits a developer should plan around. Several are scope decisions that reflect what Clari's API is (a revenue data extraction surface) and what it is not.

The API is enterprise-gated with no self-serve path. You cannot sign up, generate a key, and make your first call. Access requires an active enterprise subscription, a support ticket, CSM involvement, and a feature flag. A developer evaluating this API has no way to test it before committing to a contract. The Copilot API has its own separate access requirements.

No webhooks, no event system. Every integration pattern is poll-based. Export jobs require submitting a request, then checking status until completion. There is no push notification for forecast changes, deal updates, or activity events. For real-time workflows, this is a significant constraint.

No contact enrichment, company intelligence, or intent data. The API moves revenue execution data (forecasts, opportunities, activities, audit events). It does not provide the B2B intelligence a developer often needs alongside that data: who the contacts are beyond what the CRM holds, what companies look like (industry data, technographics, org charts), or whether accounts show buying intent. If your pipeline needs to go from "this deal's close date slipped" to "here is the updated buying committee and their engagement signals," you need a second API.

Static API key auth with no scoping. There is no OAuth 2.0, no token rotation, no delegated access. Every key has the same permissions. For teams building multi-tenant integrations, enforcing least-privilege access, or meeting credential-rotation policies, this is limiting.

No official SDKs. Every integration is raw HTTP. You build and maintain the polling logic, the auth layer, the error handling, and the retry strategy yourself.

Copilot API rate limits are tight. At 10 req/sec and 100,000 requests per week, high-volume transcript pipelines will hit the ceiling quickly. The weekly quota is a hard gate that returns 403 when exhausted.

AI features are not API-accessible. Clari's platform includes AI deal scoring, predictive forecasting, Smart Deal Summaries, and Revenue AI Agents. None of these are exposed through the API. The API gives you the raw data, not the intelligence the platform applies to it.

ZoomInfo API: The B2B Intelligence Layer Clari Does Not Expose

Clari's API tells you where your deals stand: which forecasts were submitted, how opportunity fields changed over time, what activity happened on each account. ZoomInfo's API tells you who the people behind those deals are, what their companies look like, whether those accounts are researching your category, and where the gaps in the buying committee sit.

The two APIs operate at different layers. A developer building a complete revenue intelligence pipeline would use Clari's API to extract deal execution data and ZoomInfo's API to enrich it with the contact, company, and signal intelligence that revenue platforms do not generate on their own.

What the API Covers: Search, Enrichment, and AI Intelligence

ZoomInfo's Enterprise API is a REST suite served from https://api.zoominfo.com/gtm, organized into four surface 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 unlock the full payload: business emails, direct dials, employment history, corporate hierarchy, org charts, technographics, and hashtag signals, up to 25 records per call. The search-then-enrich pattern means you filter freely, then pay only for the records you commit to. The underlying dataset spans 500M contacts, 100M companies, 135M+ verified phone numbers, and 200M+ verified business email addresses.

Copilot API (AI Intelligence): 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). This surface requires an Enterprise API or Copilot package subscription.

Marketing and Platform APIs round out the suite with audience management (CRUD for advertising audiences) and bidirectional engagement data via the Engagements API, currently in Beta.

The pairing with a revenue operations API is direct: pull opportunity and activity data from Clari to identify which deals need attention, then use ZoomInfo's enrichment endpoints to fill in the contact details, company context, and intent signals that Clari's API does not carry.

Authentication, Rate Limits & Credits

Authentication uses OAuth 2.0 with PKCE via Okta, issuing 24-hour access tokens with rotating refresh tokens. Three flows are supported: Authorization Code with PKCE (for web applications), Client Credentials (for server-to-server), and Refresh Token. Teams register applications through the ZoomInfo Developer Portal, where they generate credentials, define scopes, and test endpoints. This is a fundamentally different authentication model from Clari's static API key: it supports delegated access, credential rotation, and scoped permissions out of the box.

Rate limits are published 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: enriching a record 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.

Webhooks, MCP & Developer Experience

Webhooks are available via the Agents API, tied to ZoomInfo's Agent Teams system. Event types cover bulk enrichment jobs completing, records changing, credit usage crossing thresholds, and new GTM signals (scoops, funding events, intent spikes) becoming available, with retry behavior and throttling configurable per event type.

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. The credit model carries over from the REST API.

ZoomInfo does not publish official SDKs either, so both platforms require direct HTTP integration. The interactive API reference supports live testing, and a Docs MCP server lets AI development tools generate integration code against the API spec. ZoomInfo added API access to all relevant plans, removing the prior enterprise-only gate, with consumption-based pricing quoted per account.

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

Final Verdict

Clari's API is a focused, well-documented surface for extracting revenue execution data from one of the most established forecasting platforms in enterprise sales. The OpenAPI 3.0 spec is thorough, the opportunity trend data is unique (historical field-level changes that CRM exports do not capture), and the Copilot API opens a programmatic path to conversation intelligence. For the specific job of getting forecast submissions, opportunity trajectories, and activity logs into a data warehouse, the API delivers what it was designed to deliver.

The constraints are real and worth naming: no self-serve access, no webhooks, no SDKs, no OAuth, no AI features exposed, and a scope that ends at revenue execution data. Those are not failures; they are boundaries that define what you can and cannot build on this API alone.

Choose the Clari API if your integration is revenue-operations-first: exporting forecast data to a warehouse, pulling opportunity trend history for custom analytics, ingesting partner data into Clari's entity model, or feeding call transcripts into a downstream analysis pipeline. The API's strengths lie in the data unique to Clari's platform, particularly the time-series intelligence on deal movements.

Choose the ZoomInfo API if your build needs the B2B intelligence layer that revenue operations data does not carry: who the contacts are, what their companies look like, whether those accounts are in-market, and where the buying committee gaps sit. The search-then-enrich pattern (search is free, enrich consumes credits), OAuth 2.0 with scoped access, tiered rate limits with explicit headers, and the MCP server for AI-agent workflows cover the data and access model that Clari's API was not designed to provide. Explore the ZoomInfo Enterprise API or start with the developer docs to see the endpoint surface directly.

A developer who needs both layers (deal execution data from Clari and contact/company intelligence from ZoomInfo) should note that the two APIs use different authentication models (static API key vs. OAuth 2.0), different async patterns (Clari polls for export completion, ZoomInfo offers Agent Teams webhooks), and different rate-limiting philosophies. Plan the integration layer to handle both.

FAQ

Is the Clari API free?

Not as a standalone product. API access is bundled into Clari's enterprise subscription and requires a CSM-enabled feature flag to activate. No per-call or per-credit API pricing is published. The pricing page states "no extra platform fees for integrations," but this refers to native integrations. API access requires an existing paid contract plus support-team activation before you can make your first call.

Does Clari have a GraphQL API?

No. Clari exposes a REST API documented as an OpenAPI 3.0 specification (version 5.0.0) with JSON request and response bodies. There is no GraphQL endpoint. The Copilot API is also REST-based. If you need a GraphQL interface for Clari data, you would need to build a wrapper layer on top of the REST endpoints.

What is the Clari API rate limit?

Clari uses three rate-limiting models across its API surfaces. The main Export API enforces org-level concurrent job limits and a monthly job quota (adjustable via CSM). The Ingestion API allows 100 requests per second per API token. The Copilot API is the most restrictive at 10 requests per second and 100,000 requests per week, with HTTP 403 returned when the weekly quota is exhausted.

Are there official Clari SDKs?

No. Clari does not publish official SDKs in any language. The community documentation recommends using a generic API client for testing and an ETL tool or custom script for automated workflows. A Python sample file for the Copilot API is linked from the docs, but it is example code, not a maintained SDK package. Developers integrate directly over HTTP.

Does the Clari API support webhooks?

No. Neither the main Clari API nor the Copilot API supports webhooks or event subscriptions. The export pipeline uses a polling model: you submit a job, receive a job ID, and poll a status endpoint until the job completes. There is no callback URL parameter and no push notification system. For event-driven integration patterns, you build polling logic on your side.

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

ZoomInfo's API provides the B2B intelligence layer that Clari's API does not cover. Where Clari's API extracts revenue execution data (forecasts, opportunities, activities, call transcripts), ZoomInfo's API enriches that data with the contact and company intelligence behind it: verified business emails, direct-dial phone numbers, employment history, org charts, technographics, buyer intent signals, and AI-powered account research and buying-committee recommendations across 500M contacts and 100M companies. The two APIs use different authentication models (API key vs. OAuth 2.0) and different async patterns, so plan the integration layer to handle both. ZoomInfo's MCP server extends the same intelligence to AI-agent workflows, adding an access path Clari's API does not currently offer.