Before wiring a reverse ETL API into your stack, the question is whether its programmatic surface covers enough ground to replace the dashboard: can you create syncs, trigger runs, monitor outcomes, and manage destinations without logging in?
Census's Activations Management API, now operating under the Fivetran Activations brand after Fivetran's May 2025 acquisition, is a REST surface with Bearer token authentication, Sync Lifecycle Webhooks with HMAC-SHA256 signature validation, and endpoint coverage spanning syncs, connections, models, segments, and sources. The API reference is public, a Postman Collection provides interactive testing, and a Terraform Provider supports infrastructure-as-code management. For a platform that started with one Redshift-to-Salesforce connector in 2018, the programmatic surface has grown up.
But maturity and fitness for your build are different questions.
Census's API does one thing: manage reverse ETL pipelines programmatically. If you need to create syncs, trigger runs, monitor lifecycle events, and orchestrate data activation from a warehouse into 200+ business tools without touching the UI, the API handles that job. If you need B2B intelligence on the same programmatic surface (contact enrichment, company search, intent signals, org charts, technographics), that lives at a different layer of the data stack.
This is where ZoomInfo's API enters the picture.
ZoomInfo is a GTM platform whose Enterprise API is a REST 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 occupy different layers of the same data pipeline, not competing ones: ZoomInfo provides the intelligence that feeds the warehouse, Census activates it into the tools where teams act.
This review covers the Census API in full technical depth first (authentication, endpoints, webhooks, SDKs, rate limits, and pricing), then reviews ZoomInfo's API as the intelligence layer that sits upstream of activation.
Census API at a Glance
Attribute | Detail |
|---|---|
API type | REST over HTTPS, JSON responses |
Authentication | Bearer token (workspace access tokens and personal access tokens) |
Base URL | https://app.getcensus.com/api/v1/ (US); https://app-eu.getcensus.com/api/v1/ (EU) |
Current version | v1 |
Rate limits | Not publicly documented |
Pricing / access | Requires Standard plan ($4,200/year) or above; not available on the Free tier |
SDKs | No official SDKs; Postman Collection and Terraform Provider available |
Webhooks | Yes, Sync Lifecycle Webhooks with HMAC-SHA256 signature validation |
Documentation | developers.getcensus.com (redirects to Fivetran docs infrastructure) |
Census API: What Works Well & What to Plan Around
What works well | What to plan around |
|---|---|
Public API reference with Postman Collection for interactive testing | Rate limits are not published; you discover constraints in production |
Terraform Provider for infrastructure-as-code sync management | No official SDKs in any language; you build and maintain the HTTP layer |
Webhook signature validation with HMAC-SHA256 for secure delivery | API access requires the Standard plan ($4,200/year); not available on Free |
Separate workspace and organization API tiers for access control | Scope is pipeline management only: no data enrichment, search, or intelligence |
EU-specific base URL for regional data residency requirements | Webhook retry behavior and delivery guarantees are not documented |
Custom Destination API lets you build targets Census does not natively support | Census is mid-acquisition; documentation is migrating between domains |
Census API: Authentication & Getting Started
API access starts with a paid Census (now Fivetran Activations) subscription.
The pricing page lists REST API access as a Standard plan feature, meaning the Free tier's 3,500 Monthly Active Rows and 2 active syncs do not include programmatic control. The Standard plan starts at $4,200 per year.
Census splits its API into two tiers with separate credential types:
Workspace access tokens: required for Workspace API calls (syncs, connections, models, segments, webhooks). Generated from the workspace's Settings page. Scoped to a single Census workspace, granting access to all resources within it.
Personal access tokens: required for Organization API calls (workspaces, users, invitations). These cover cross-workspace administrative operations.
Both token types go in the Authorization header as Bearer tokens:
curl "https://app.getcensus.com/api/v1/syncs" \
-H "Authorization: Bearer YOUR_WORKSPACE_TOKEN" \
-H "Content-Type: application/json"
There is no OAuth flow, no token rotation, and no scoped permissions beyond the workspace/organization split. The tokens are static credentials, and the documentation warns against embedding workspace access tokens in public-facing client-side code. Teams with strict credential-rotation policies should note: there is no built-in mechanism for rotating tokens on a schedule or scoping a token to read-only access on specific resources.
For the Census Store Iceberg REST Catalog (a data lake feature within the broader Fivetran platform), authentication uses OAuth 2.0 client credentials with a separate client ID and secret. This is distinct from the main Management API's token system.
One practical consideration: Census serves both US and EU organizations with separate base URLs. US organizations use https://app.getcensus.com, EU organizations use https://app-eu.getcensus.com. If your integration serves customers in both regions, your API layer needs to route accordingly.
Census API: Core Endpoints & Capabilities
The Management API is organized into Workspace and Organization resource groups. All endpoints follow the /api/v1/{resource} pattern and return JSON. This is a management surface: it controls pipeline configuration and execution, not the data flowing through those pipelines.
Syncs
The sync resource is the core of the API, covering the full lifecycle of a reverse ETL pipeline.
Operations: List (GET /syncs), get, create, trigger, update, and delete. The trigger operation matters most: it lets you start a sync run programmatically, which enables event-driven activation. For example, you can trigger a sync right after a dbt model finishes refreshing instead of waiting for a scheduled interval.
Source: Census
What you would build with this: an orchestration layer that triggers Census syncs as the final step in a data pipeline, after your warehouse transformation completes, so downstream tools like Salesforce or HubSpot receive fresh data within minutes of a model update.
Connections
Operations: List and get for both source and destination connections. These endpoints let you inventory which warehouses and business tools are wired up in a workspace, useful for monitoring and compliance dashboards.
Models
Operations: List and get. Models represent the SQL queries and dataset definitions that Census uses as sync sources. These endpoints let you audit which datasets power which syncs.
Segments
Operations: List and create. Segments are the audience definitions built in Audience Hub. The API lets you create new segments programmatically, enabling automated audience management.
Sources
Operations: List tables and columns from connected sources. These endpoints let you discover what data is available in a connected warehouse without querying the warehouse directly.
Webhooks
Operations: List, create, get, and delete sync lifecycle webhooks. Webhooks are managed via the API (/api/v1/webhooks), enabling programmatic setup of event-driven monitoring.
Organization APIs
A separate set of endpoints covers cross-workspace administrative operations:
Workspaces: list all workspaces in an organization
Users: manage user membership
Invitations: send and manage workspace invitations
These are useful for agencies or teams managing multiple Census workspaces from a single administrative layer.
Secondary API Surfaces
Beyond the Management API, Census exposes additional programmatic interfaces:
Dataset API: a REST interface for querying warehouse-backed datasets directly, letting applications read Census-managed data without going through the warehouse.
Entity API: a low-latency REST layer for serving warehouse data into applications for real-time personalization. This is built for use cases where sub-second response times matter, such as serving personalized content on page load.
Custom Destination API: a specification that lets developers build HTTP-based destination endpoints Census can sync to, covering any target system not natively supported.
Pagination follows a documented pattern, though specific page size limits are not stated in the documentation.
Census API: Webhooks & Events
Census offers Sync Lifecycle Webhooks to notify external systems about sync state changes in real time.
Webhooks are configured in Workspace Settings under the Webhooks tab and can also be managed via the REST API (/api/v1/webhooks).
Source: Census
The supported events cover the full sync lifecycle:
Event | When it fires |
|---|---|
sync.triggered | Sync is queued to run |
sync.started | Active execution begins |
sync.completed | Run finishes (success or failure) |
sync.success | Sync completes successfully |
sync.failed | Sync fails |
sync.alert.raised | A configured sync alert fires |
sync.alert.resolved | A previously raised alert clears |
Every webhook delivery includes workspace_id, sync_id, sync_run_id, and event in the payload. Alert events (sync.alert.raised, sync.alert.resolved) also include alert_instance_id, alert_type, message, details, and a followup_url. The sync.completed event carries a status field ("ok" for success, "emergency" for failure).
Signature validation: Each request includes an X-Signature header containing an HMAC-SHA256 hash of the raw payload body, computed using the webhook's one-time secret and base64-encoded. Census recommends constant-time comparison when validating signatures to prevent timing attacks.
What you would build with this: a monitoring pipeline that triggers a PagerDuty alert on sync.failed, logs every sync.completed event to a data warehouse for SLA tracking, and posts sync.alert.raised events to a Slack channel so the data team catches anomalies before downstream systems notice stale data.
Two things to plan around:
Webhook events cover sync lifecycle operations only. There is no webhook for model changes, connection updates, or segment membership changes.
Retry behavior, delivery frequency, and delivery guarantees are not described in the public documentation. Design your receiver to be idempotent regardless.
Census also supports an HTTP Request destination (replacing a deprecated Webhook destination) that pushes actual sync data outbound to any HTTP endpoint. This is a different mechanism from Sync Lifecycle Webhooks: the HTTP Request destination sends the data being synced, while lifecycle webhooks notify you about sync status changes.
Census API: SDKs, Docs & Rate Limits
SDKs & Libraries
Census does not publish official SDKs in any programming language. The developer experience centers on three alternative tools:
Postman Collection: the Activations (formerly Census) Postman Collection covers all API endpoints and serves as the primary interactive testing environment. This is the fastest way to confirm request shapes and response structures.
Source: Census
Terraform Provider: documented as a first-class integration for managing Census resources as infrastructure-as-code. For teams that manage their data stack through Terraform, this is a more natural integration path than the REST API.
Custom Destinations SDK: a specification for building HTTP-based destination endpoints. This is not a client SDK but a server-side specification for extending Census's destination coverage.
No official SDKs means you own the HTTP layer: authentication handling, request serialization, error parsing, and retry logic. For a management API with a small endpoint surface, this is less burdensome than it would be for a high-frequency data API, but it still adds engineering overhead that a maintained client library would absorb.
Documentation & Developer Experience
Census's developer documentation has been migrating since the Fivetran acquisition. The primary locations are:
API Reference: developers.getcensus.com, which routes to Fivetran's documentation infrastructure. Organized into Workspace and Organization API sections with endpoint-level documentation.
Product Documentation: docs.getcensus.com (now redirecting to Fivetran docs), covering syncs, datasets, Audience Hub, sources, destinations, and developer resources.
Product Changelog: whatsnew.getcensus.com tracks feature releases and new API endpoints, including entries like the list tables and columns endpoints.
Postman Collection: the interactive testing surface at the Census API Postman workspace.
The documentation works but is in transition. The Fivetran acquisition has split it between legacy Census domains and the Fivetran documentation infrastructure. Some pages redirect while others still carry Census branding. For a developer evaluating the API, this means checking multiple locations for current information.
Support is handled through the Fivetran Support portal. No dedicated developer Slack, Discord, or community forum is documented.
Rate Limits & Constraints
Census does not publish specific rate-limit figures in any of its developer documentation. There are no documented requests-per-second ceilings, daily caps, or plan-tiered rate limits.
This is a real gap for a developer sizing an integration. Without published limits, you cannot predict when your orchestration layer will start receiving 429 responses, and you cannot design your retry and backoff logic against a known ceiling. The safe approach is to build conservatively (sequential calls with exponential backoff) and test against your actual account's behavior.
The absence of published rate limits is itself a finding: Census's API is a management surface (create syncs, trigger runs, read status) rather than a high-frequency data API, so call volume is typically low. But for teams running automated orchestration across dozens of syncs on tight schedules, the lack of published constraints introduces uncertainty.
Census API Pricing & Access Costs
Census API access is gated by plan tier, as documented on the pricing page:
Free plan (3,500 MAR for activations): REST API access is not listed as a Free plan feature. You get 1 billable destination, 2 active syncs, and 5 user seats, but no programmatic control.
Standard plan ($4,200/year): explicitly includes REST API access along with 200+ activation destinations. This is the entry point for API access.
Enterprise and Business Critical plans (custom pricing): all Standard features plus Audience Hub, continuous syncs, Census Embedded, and advanced security features like AWS PrivateLink.
The core usage metric for Census is Monthly Active Rows (MAR): unique primary keys added, updated, or deleted in a source and synced into a destination in a given calendar month. If a row changes multiple times within a month, it is only counted once. Example rates from the pricing page: a Snowflake-to-Salesforce activation at roughly 12,000 MAR costs about $202/month; a Snowflake-to-HubSpot activation at roughly 10,000 MAR costs about $198/month.
API access itself carries no per-call or per-request charges. You pay for the plan subscription and MAR consumption; the API is the programmatic interface to the same syncs you would otherwise configure in the dashboard. Annual contracts save up to 22%.
Two cost-related constraints:
Both Free and Standard plans are subject to an 8 million records per month limit. Overage pricing is not publicly disclosed.
Additional billable destinations beyond the plan's base allocation cost $2,400 per year each on the Standard plan.
Following the Fivetran acquisition, Census customers receive consolidated invoicing for Connections, Transformations, and Activations, enabling a single budget commitment across all three workloads.
Where the Census API Falls Short
These are practical limits a developer should plan around, not criticisms of the product. Several are scope decisions that reflect what Census is (a reverse ETL orchestration platform) and what it is not.
The API manages pipelines. It does not provide data. There are no endpoints for contact enrichment, company search, company data lookup, intent signals, or any B2B intelligence. If your build needs to enrich warehouse records before activating them, or discover new contacts and companies programmatically, you need a separate data API. This is the fundamental scope boundary.
Rate limits are not published. Census does not document any requests-per-second ceiling, daily cap, or plan-tiered rate limit. For a management API with typically low call volume, this may not surface as a problem. For automated orchestration across many syncs on tight schedules, the uncertainty is harder to plan around.
No official SDKs. Every integration is raw HTTP. The Postman Collection and Terraform Provider offset this partially, but a developer building a custom orchestration layer in Python or Node.js writes and maintains the client code.
Static Bearer token auth only. No OAuth, no token rotation, no scoped permissions within a workspace. A workspace access token grants access to everything in that workspace. For multi-tenant integrations or teams with strict credential-rotation policies, this is a constraint.
Webhook delivery guarantees are undocumented. Sync Lifecycle Webhooks cover the right events and include HMAC signature validation, but the documentation does not describe retry policy, delivery guarantees, or failure behavior. If your pipeline depends on guaranteed webhook delivery, design your receiver to be idempotent and build your own reliability layer.
Documentation is mid-migration. The Fivetran acquisition has split documentation across developers.getcensus.com, docs.getcensus.com, and fivetran.com/docs/activations. Some pages redirect, some carry legacy Census branding, and the canonical location for a given piece of information is not always obvious.
API access requires a paid plan. The Free tier does not include REST API access. The entry point is the Standard plan at $4,200/year, which may block developers who want to evaluate the API before committing, since the 14-day free trial's API access scope is not documented.
ZoomInfo API: The Intelligence Layer Upstream of Activation
Census's API manages the pipeline that moves data from a warehouse into business tools.
ZoomInfo's API provides the B2B intelligence that makes the data worth activating: who these contacts are, what companies they represent, what technologies they use, whether they are researching your category, and where they sit in the org chart.
That intelligence runs on ZoomInfo's GTM Context Graph, which processes 1.5B+ data points daily by fusing ZoomInfo's B2B data with your first-party data to reveal not just what happened, but why.
The two APIs sit at different layers of the same data stack. A developer building a complete data activation pipeline would use ZoomInfo's API to enrich warehouse records with verified contacts, company data, and intent signals, then use Census's API to sync those enriched records into Salesforce, HubSpot, Marketo, or any of Census's 200+ destinations.
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 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.
AI Intelligence API (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.
The pairing with a reverse ETL API is direct: use ZoomInfo's search endpoints to find contacts matching your ICP (free, no credits consumed), enrich the ones worth pursuing, land those enriched records in your warehouse, then use Census's API to sync them into downstream tools on a schedule or trigger. The enrichment stays fresh in the warehouse; Census keeps the destinations in sync.
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.
Applications are registered through the ZoomInfo Developer Portal, where teams generate credentials, define scopes, and test endpoints. This is a different authentication model from Census's static Bearer token: it supports delegated access, credential rotation, and scoped permissions.
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: a record enriched for the first time consumes one credit; re-enriching the same record within the year is free. Search and lookup operations are free and 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, so both platforms require direct HTTP integration. The interactive API reference supports live testing with OAuth2 Bearer token authentication, and a Docs MCP server enables AI development tools to generate integration code against the API spec. Documentation lives at docs.zoominfo.com.
ZoomInfo extended API access across all relevant plans in 2025, 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
Census's API is a focused management surface that gives you programmatic control over reverse ETL pipelines: creating syncs, triggering runs, monitoring lifecycle events via signed webhooks, and managing destinations across 200+ integrations. The Terraform Provider and Postman Collection make onboarding practical, and MAR-based pricing means you pay for data movement rather than API calls. Its limits are limits of scope (pipeline orchestration, not data intelligence) and documentation maturity (unpublished rate limits, mid-migration docs), not of execution quality.
Choose the Census API if your build needs programmatic control over data activation from a warehouse into business tools. If you already run Census in the dashboard and need to automate sync orchestration, trigger runs from CI/CD or dbt pipelines, and monitor sync health via webhooks, the API is the right surface.
Add the ZoomInfo API when the build needs to go upstream of activation into who these records represent, what companies they work for, and whether those accounts are worth pursuing. Enrich first, activate second: the pattern keeps your downstream tools populated with verified, current data rather than stale warehouse records. ZoomInfo's search-then-enrich model (search is free, enrich consumes credits) and its AI intelligence endpoints cover the data layer that reverse ETL by design does not address.
Ready to wire in the intelligence layer? Start with the ZoomInfo Enterprise API or explore the developer docs to see the endpoint surface for yourself.
FAQ
Is the Census API free?
No. REST API access is listed as a Standard plan feature and is not available on the Free tier. The Standard plan starts at $4,200 per year and includes access to 200+ activation destinations. Census offers a 14-day free trial with access to all destinations and features, though the trial's API access scope is not separately documented. The Free tier provides 3,500 MAR, 2 active syncs, and 1 billable destination, but only through the dashboard.
Does Census have a GraphQL API?
No. Census exposes a REST API (currently v1) that communicates over HTTPS and returns JSON responses. There is no GraphQL endpoint. The API follows standard REST conventions with endpoints organized by resource type (syncs, connections, models, segments, webhooks). If you need a GraphQL interface for reverse ETL management, you would need to build a wrapper layer on top of the REST API.
What is the Census API rate limit?
Census does not publish specific rate-limit figures. There are no documented requests-per-second ceilings, daily caps, or plan-tiered limits in the public developer documentation. As a management API (creating syncs, triggering runs, reading status), typical call volume is low compared to a data API, but the absence of published constraints means you should build conservatively with exponential backoff and test against your actual account's behavior.
Are there official Census SDKs?
No. Census does not publish official SDKs in any programming language. The primary developer tools are a Postman Collection covering all API endpoints (the main interactive testing surface), a Terraform Provider for infrastructure-as-code management, and a Custom Destinations SDK specification for building new integration targets. Developers building custom integrations make direct HTTP requests to the REST API.
Does the Census API support webhooks?
Yes. Census offers Sync Lifecycle Webhooks that fire on seven event types covering the full sync lifecycle: triggered, started, completed, success, failed, alert raised, and alert resolved. Webhooks include HMAC-SHA256 signature validation using a one-time secret. They are configured in Workspace Settings or managed via the REST API. Retry behavior and delivery guarantees are not documented, so receivers should be idempotent.
What does ZoomInfo's API add to a Census build?
ZoomInfo's API adds the B2B intelligence layer that Census's API does not cover. Census manages the pipeline that moves data from a warehouse into business tools; ZoomInfo provides the data that makes that pipeline valuable. Search across 500M contacts and 100M companies, enrich records with verified business emails, direct dials, org charts, technographics, and employment history, detect buyer intent signals, and generate AI-powered account research and buying-committee recommendations. The practical pattern: use ZoomInfo's API to enrich warehouse records upstream, then use Census's API to activate those enriched records into Salesforce, HubSpot, Marketo, and other downstream tools. The two APIs use different authentication models (Bearer token vs. OAuth 2.0) and different pricing structures (MAR-based vs. credit-based), so plan the integration layer to handle both.
