.png)
Census Integration Guide
Integrate Census with enterprise systems through its Platform REST API, selected sync lifecycle webhooks, and asynchronous warehouse-to-destination synchronization.
Census integration options at a glance
Census provides a Platform REST API for inspecting sources, destinations, syncs, and sync runs, as well as initiating synchronization operations and checking execution status. Selected sync lifecycle events can be delivered through Census webhook-style notifications. Its primary operating model is asynchronous and batch-oriented: Census reads modeled data from supported warehouses and activates it in downstream destinations. The Platform API uses API-key authentication, while source and destination connections maintain their own credentials. Martini can consume the Census REST API, receive selected webhook events, orchestrate scheduled or event-driven workflows, apply business rules, and route results to databases, APIs, monitoring systems, or messaging endpoints.
| Integration point | Supported by Census? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Manage and inspect Census sources, destinations, syncs, and sync runs; initiate synchronization operations and retrieve execution status. | Martini can consume the Census Platform REST API from workflows, map responses, apply business rules, and expose controlled APIs around Census operations. |
| Webhooks | Limited | Receive selected sync lifecycle notifications such as sync start, completion, or failure. Coverage is not a universal event stream for every object or row-level change. | Martini can expose a webhook endpoint, validate the notification, use its identifier to retrieve authoritative Census status, and apply idempotency controls. |
| Bulk / async / batch processing | Limited | Census sync runs provide asynchronous, batch-oriented warehouse-to-destination data movement, but the Platform API is not a general-purpose bulk CRUD API for destination records. | Martini can start a sync, store its sync-run identifier, poll or await lifecycle notification, and separate request acceptance from business completion. |
| Database / analytics access | Yes | Census reads modeled tables, views, or datasets from supported data warehouses and activates them in downstream destinations. | Martini can orchestrate Census around warehouse processes and can connect separately to supported databases for reconciliation, audit, or operational state. |
| Authentication | Yes | The Census Platform API uses an API key sent in the Authorization header, typically as a Bearer token. Source and destination connections have separate credentials. | Martini can store Census API keys and related values in secrets or protected environment configuration and apply them to REST API requests. |
| Scheduled synchronization | Yes | Census supports an operational model in which warehouse data is synchronized asynchronously to configured destinations; Martini can schedule API-driven orchestration and monitoring. | Martini scheduler-triggered workflows can identify eligible syncs, start them, monitor status, and route failures without relying on short fixed polling intervals. |
| File / attachment APIs | No | No general-purpose Census file or attachment API was confirmed; Census is centered on warehouse-to-application synchronization. | Martini can integrate with separate file or attachment systems when required, but should not represent Census as the file-transfer endpoint. |
| GraphQL APIs | Not confirmed | No official Census GraphQL API was confirmed in the supplied research. | Martini should use the Census REST API for confirmed Census operations rather than assuming GraphQL support. |
How Census exposes data and business events
Census REST APIs
Census provides a Platform REST API for inspecting sources, destinations, sync configurations, and sync runs, and for operating synchronization workflows. The API is the primary integration mechanism for administrative and operational control.
Martini implementation pattern
Martini implementation pattern: a Martini workflow authenticates with a Census API key stored in a secret, calls the relevant endpoint, maps the response into an internal model, applies business rules, and records or forwards the result. For asynchronous operations, the workflow retains the returned sync-run identifier and treats the later run status as the business outcome.
Implementation sequence
Census Webhooks
Census supports webhook-style notifications for selected sync lifecycle events, including notifications associated with sync execution states. These notifications should not be treated as a universal row-level event stream.
Martini implementation pattern
Martini implementation pattern: expose a controlled webhook endpoint, validate the incoming request and event payload, use the referenced identifier to query Census, and process the authoritative sync-run state. Idempotency prevents duplicate notifications from causing repeated downstream actions.
Implementation sequence
Census Async Sync Runs
Census performs warehouse-to-destination data movement through asynchronous and batch-oriented sync runs. Starting an API operation does not necessarily mean that destination updates have completed.
Martini implementation pattern
Martini implementation pattern: initiate an eligible sync, persist its run identifier, and coordinate completion through a webhook or controlled polling workflow. Martini can classify transient failures for retry while routing configuration, validation, or mapping failures for correction rather than repeatedly retrying them.
Implementation sequence
Census Warehouse Sources
Census reads modeled tables, views, or datasets from supported data warehouses and activates them in configured destinations. The warehouse remains the analytical system of record for the source data.
Martini implementation pattern
Martini implementation pattern: coordinate warehouse readiness and Census execution, validate that the expected model and destination configuration are available, and record activation results after the Census run completes. Martini can also connect separately to an operational database for audit and reconciliation.
Implementation sequence
Common Census integration patterns
Pattern 1: Monitor Census sync completion
When to use this pattern
Use this pattern when Census activates warehouse-modeled data into an operational or marketing destination and another system needs a reliable completion, failure, or audit signal. It separates the notification from the authoritative sync-run state and avoids treating webhook delivery as proof that destination processing succeeded.
Integration direction
Example Mapping
| Census Field | Canonical Field | Target Field |
|---|---|---|
| sync_run.id | activationRunId | census_run_id |
| sync_run.status | activationStatus | status |
| sync_run.started_at | startedAt | started_at |
| sync_run.completed_at | completedAt | completed_at |
Martini implementation pattern
Martini receives a selected Census lifecycle notification, validates and deduplicates it, retrieves the current sync-run details through the REST API, and maps the result into an operational audit model. Business rules classify successful, transient, and persistent failures; retries are limited to eligible transient conditions, while configuration and mapping errors are routed for review.
Martini capabilities used
- webhooks
- workflows
- API consumption
- data mapping
- business rules
- error handling
Pattern 2: Schedule and control Census syncs
When to use this pattern
Use this pattern when an enterprise needs centralized control over when eligible Census syncs start, such as coordinating them with warehouse refreshes or downstream processing windows. The workflow should prevent duplicate starts and should monitor the asynchronous run after the request is accepted.
Integration direction
Example Mapping
| Census Field | Canonical Field | Target Field |
|---|---|---|
| sync.id | syncId | census_sync_id |
| sync.name | syncName | sync_name |
| sync_run.status | runStatus | status |
| destination.id | destinationId | destination_id |
Martini implementation pattern
A scheduled Martini workflow lists or retrieves configured Census Syncs, checks eligibility and existing active runs, starts the selected operation, and stores the returned run identifier. It then polls at controlled intervals or relies on a webhook, applies retry and timeout rules, and publishes the final outcome to an operational system.
Martini capabilities used
- scheduled workflows
- API consumption
- orchestration
- conditional routing
- data mapping
- error handling
Pattern 3: Reconcile warehouse activation
When to use this pattern
Use this pattern for high-impact Salesforce, marketing, advertising, or support activations where an accepted Census request is insufficient and the organization needs an auditable indication that the modeled data activation completed as expected.
Integration direction
Example Mapping
| Census Field | Canonical Field | Target Field |
|---|---|---|
| model.name | sourceModel | source_model |
| destination.name | activationTarget | destination_name |
| sync_run.status | activationStatus | status |
| sync_run.completed_at | activationTimestamp | completed_at |
Martini implementation pattern
Martini coordinates the readiness check, retrieves the relevant Census Sync and run details, and records status, timestamps, identifiers, and available result information. Business rules compare expected activation context with the reported run, flag incomplete outcomes, and send exceptions to an operations queue or notification process.
Martini capabilities used
- workflows
- API consumption
- database integration
- data mapping
- validation
- monitoring
Pattern 4: Handle Census failures with controlled retry
When to use this pattern
Use this pattern when Census failure notifications must trigger a consistent response rather than an unrestricted retry loop. It is appropriate for distinguishing transient platform or service failures from authentication, source-query, destination, mapping, or configuration errors.
Integration direction
Example Mapping
| Census Field | Canonical Field | Target Field |
|---|---|---|
| sync_run.id | runId | census_run_id |
| sync_run.status | failureState | status |
| error.message | failureReason | error_message |
| error.type | failureCategory | error_category |
Martini implementation pattern
Martini receives or discovers the failed run, retrieves complete failure details, classifies the condition, and applies a bounded retry policy only to eligible transient failures. It avoids retrying unchanged validation or mapping errors, records each attempt with an idempotency key, and routes persistent failures to an operations queue or incident process.
Martini capabilities used
- webhooks
- API consumption
- business rules
- conditional routing
- error handling
- retry control
Applications commonly integrated with Census
Census is commonly used to activate modeled warehouse data in operational, marketing, advertising, and support applications. Destination capabilities, supported objects, and authentication requirements should be confirmed against the current Census destination configuration.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Activate warehouse-modeled Accounts, Contacts, Leads, and other customer or sales data for sales teams, with Martini coordinating completion monitoring and reconciliation. | Warehouse → Census → Salesforce | Use a Census sync for warehouse-to-Salesforce activation, then have Martini receive a selected lifecycle notification, retrieve the authoritative sync run, validate status and counts, and write operational results to a database or monitoring system. |
| HubSpot | Synchronize modeled customer, company, contact, and lifecycle data for marketing and sales operations. | Warehouse → Census → HubSpot | Martini can orchestrate Census sync execution or monitor completion through the Platform API, apply destination-specific reconciliation rules, and route failures to an operations workflow. |
| Marketo | Push qualified audiences, account attributes, and lifecycle signals from warehouse models into marketing automation. | Warehouse → Census → Marketo | Use Census for activation and Martini for scheduled orchestration, sync-run status retrieval, validation, and downstream notification when the activation succeeds or fails. |
| Braze | Activate customer attributes and audience segments for messaging and engagement campaigns. | Warehouse → Census → Braze | Martini can trigger or monitor the relevant Census sync, retain the sync-run identifier, and perform post-run reconciliation before allowing dependent campaign or reporting processes to continue. |
| Google Ads | Send modeled audiences or conversion-related data to advertising workflows. | Warehouse → Census → Google Ads | Use an asynchronous Census sync for audience activation and a Martini workflow to validate completion, classify failures, and record activation timestamps for operational reporting. |
| Meta Ads | Activate warehouse-defined audiences for paid media targeting and measurement. | Warehouse → Census → Meta Ads | Martini can schedule eligible Census syncs, avoid overlapping runs, and consume lifecycle notifications or poll status before recording the result in an operational data store. |
| LinkedIn Ads | Synchronize account or audience data for B2B advertising activation. | Warehouse → Census → LinkedIn Ads | Implement a scheduled Martini workflow that starts or monitors the Census sync, applies validation rules, and routes persistent destination errors to an operations queue. |
| Zendesk | Provide support teams with customer attributes or account context sourced from the warehouse. | Warehouse → Census → Zendesk | Use Census to activate the modeled support context and Martini to verify sync-run results, persist audit information, and notify support operations when activation is incomplete. |
How to build a Census integration in Martini
Objective
Configure secure access to the Census Platform API and any separate systems used for audit, monitoring, or downstream processing.
Instructions in Martini
- Store the Census API key in Martini secrets or protected environment configuration.
- Use separate non-production and production credentials where available.
- Treat Census source and destination credentials as separate from the Platform API key.
- Avoid placing credentials in workflow payloads, logs, or source control.
Objective
Select an event-driven or scheduled entry point based on the required Census operation and webhook coverage.
Instructions in Martini
- Use a Martini webhook endpoint for selected Census lifecycle notifications.
- Use a scheduler-triggered workflow when polling or proactive orchestration is required.
- Do not assume Census provides row-level events for every data change.
- Define the conditions that make a Sync eligible to start.
Objective
Call the Census REST API to inspect resources, start operations, and retrieve authoritative sync-run details.
Instructions in Martini
- Retrieve the relevant Source, Destination, Sync, or Sync run.
- Follow the current pagination behavior for collection endpoints.
- Store the sync-run identifier returned by asynchronous operations.
- Use a follow-up GET request to confirm current status before irreversible actions.
Objective
Coordinate Census operations with warehouse readiness, downstream processing, and operational state.
Instructions in Martini
- Prevent a new run from starting while an incompatible run is still active.
- Separate request acceptance from completion of destination updates.
- Use controlled polling intervals or webhook-driven continuation.
- Apply timeouts and route incomplete executions for review.
Objective
Convert Census API responses and lifecycle payloads into the internal models required by operational systems.
Instructions in Martini
- Map event identifiers, sync identifiers, status, timestamps, and error details.
- Normalize Census status values into the organization's operational status model.
- Preserve raw identifiers needed for audit and idempotency.
- Use validation before writing results to downstream systems.
Objective
Apply reliability, reconciliation, and failure-classification rules before committing business outcomes.
Instructions in Martini
- Deduplicate repeated webhook notifications using a stable event or sync-run identifier.
- Classify transient, authentication, configuration, source, destination, and mapping failures.
- Retry only eligible transient failures with bounded backoff.
- Record expected and reported activation context for high-impact syncs.
Common Census data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Sources | Represent warehouse or source-system connections from which Census reads modeled data. | Data warehouses, operational monitoring databases | Martini can list and inspect Sources through the Platform API and use the results to validate configuration or drive operational workflows. |
| Destinations | Represent downstream applications or platforms to which Census synchronizes data. | Salesforce, HubSpot, Marketo, Braze, Google Ads, Meta Ads, LinkedIn Ads, Zendesk | Martini can retrieve destination metadata, apply destination-specific rules, and record configuration or execution outcomes. |
| Models | Represent warehouse tables, views, or modeled datasets used as Census sync inputs. | Data warehouses and destination applications | Martini can use model-related sync configuration and operational results without treating Census as a general-purpose database query endpoint. |
| Syncs | Define the relationship between a source model and a destination object, including mappings and sync behavior. | Census destinations and operational control systems | Martini can inspect eligible Syncs, initiate operations where permitted, prevent overlapping runs, and apply workflow business rules. |
| Sync runs | Represent individual executions of a Sync, including status, timing, and execution results. | Operational databases, monitoring systems, incident workflows | Martini stores the sync-run identifier, retrieves authoritative status, classifies failures, and performs reconciliation or notification. |
| Sync mappings | Describe field-level mappings between source columns and destination fields as part of a Sync configuration. | Destination applications and data-quality processes | Martini can use mapping information for validation and audit workflows, while Census performs the configured warehouse-to-destination field mapping. |
Authentication and security considerations
API-key authentication
The Census Platform API uses an API key sent in the Authorization header, typically as a Bearer token. Source and destination connections have separate credentials managed within Census.
Secret management
Store Census API keys and webhook verification values in Martini secrets or protected environment configuration. Use separate credentials for development, staging, and production where the Census account permits it.
Access control
- Restrict access to Census API keys because they can operate Census resources.
- Confirm that the Census workspace and account permissions allow the required Sync operations.
- Do not place credentials in workflow payloads, logs, or source control.
Operational considerations for Census integrations
Rate limits and pagination
Confirm current Census limits and account quotas before designing polling. Prefer webhook notifications where appropriate, use exponential backoff for transient 429 or service-unavailable responses, and process collection endpoints according to their current pagination format.
Asynchronous execution
Starting a Sync does not mean that destination updates are complete. Store the Sync-run identifier and track the run through a webhook or controlled polling workflow.
Idempotency and retries
Webhook retries can create duplicate notifications. Use a stable event or Sync-run identifier, retrieve current state before irreversible actions, and avoid starting a Sync while an incompatible run is active.
Schema and data quality
Warehouse models, destination fields, data types, and required attributes can change independently. Validate mappings, monitor row counts and statuses where available, and test configuration changes before production promotion.
Why use Martini instead of scripts or point-to-point integrations?
Reusable orchestration
Martini provides workflows and APIs for coordinating Census operations with warehouse readiness, monitoring, reconciliation, databases, messaging, and downstream applications.
Controlled reliability
Instead of embedding polling, retries, and exception handling in one-off scripts, Martini centralizes idempotency, bounded retry policies, validation, routing, and operational logging.
Maintainable integration logic
Martini separates Census API consumption, data mapping, business rules, and target-system actions so teams can evolve the integration as Sync configurations, warehouse models, or destination requirements change.
API-led extension
Martini can expose a controlled API façade around Census operations, allowing internal systems to request approved actions without receiving direct access to Census credentials or implementation details.
Frequently asked questions
Census integrates primarily through its Platform REST API and selected sync lifecycle webhook notifications. It reads modeled data from supported warehouses and synchronizes that data to configured destinations through asynchronous Sync runs. Enterprise workflows can use the API to inspect or start Syncs, track Sync runs, and coordinate monitoring, reconciliation, and downstream processing.
Yes. Martini can consume the Census Platform REST API using API-key authentication and can receive selected Census webhook notifications through a Martini API or workflow. Martini can orchestrate Syncs, retrieve authoritative Sync-run status, transform results, and route them to databases, APIs, monitoring systems, or messaging endpoints.
No dedicated Census connector is required. Martini can integrate with Census using Census's confirmed native integration mechanisms: the Platform REST API, API-key authentication, and selected webhook-style sync lifecycle notifications.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Census. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Census, destination applications, cloud infrastructure, or other third-party systems depending on subscription, usage, and deployment model.
Use the Census Platform REST API for resource inspection, Sync operations, and Sync-run status. Use webhook-style notifications for selected lifecycle events, combined with a follow-up API request for authoritative details. Census's asynchronous Sync-run model is appropriate for batch-oriented warehouse-to-destination activation, while scheduled Martini workflows can provide controlled polling or orchestration.
Census supports webhook-style notifications for selected Sync lifecycle events, such as completion or failure. Coverage is not a universal event stream for every Census object or row-level data change. Martini should validate and deduplicate the notification, then query Census for the current Sync-run state.
Census reads modeled warehouse tables, views, or datasets and applies the configured Sync mappings to destination objects. Martini can orchestrate when a Sync starts, validate source and destination context, transform API responses into internal models, and perform reconciliation or operational reporting after the asynchronous run completes. Destination-specific object and field support should be confirmed in Census configuration.
Use the Census event or Sync-run identifier as an idempotency key and retrieve the current run state before taking irreversible action. Martini can classify transient service or rate-limit failures for bounded retry with backoff, while authentication, mapping, validation, and configuration errors should be routed for correction rather than repeatedly retried. Persistent failures can be recorded and sent to an operations queue.
Related Martini documentation
Workflows
Plan your Census integration with Martini
Use Martini to connect Census API operations and sync lifecycle notifications to reliable enterprise workflows, operational systems, and downstream applications.