.png)
Domo Integration Guide
Integrate Domo with enterprise systems through REST APIs for DataSet ingestion, querying, administration, analytics, and governed data exchange.
Domo integration options at a glance
Domo’s primary integration model is its REST API platform, which supports DataSet creation and management, data ingestion and publishing, query access, analytics operations, and platform administration. Dataset-oriented and batch capabilities support larger structured transfers, while query APIs allow Martini workflows to retrieve analytical data for downstream processing. Domo supports OAuth 2.0 and access-token authentication subject to tenant and dataset permissions. General-purpose webhooks for all Domo object changes were not confirmed, so scheduled queries and watermark-based synchronization are often safer. Martini can consume these APIs, transform payloads, orchestrate workflows, expose APIs for approved callbacks, and handle retries and checkpoints.
| Integration point | Supported by Domo? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Manage DataSets, ingest and publish data, query analytical data, administer Users and Groups, and work with Cards, Pages, DataFlows, and access controls. | Martini can consume documented Domo REST endpoints, construct authenticated requests, paginate responses, map payloads, and orchestrate downstream actions. |
| Bulk / async / batch APIs | Yes | Load larger structured payloads into DataSets, replace snapshots, append data, or publish batches when individual record operations are inappropriate. | Martini can prepare batches, select append or replace semantics, track import or batch identifiers where available, and validate completion and row counts. |
| Database / analytics access | Yes | Query DataSets to retrieve data for downstream synchronization, reconciliation, validation, and scheduled extracts. | Martini can invoke Domo query and data-access APIs, apply filters and business rules, and send results to applications, warehouses, or files. |
| Authentication | Yes | Authenticate API requests using OAuth 2.0 or Domo access-token and bearer-token patterns subject to tenant, user, client, and DataSet permissions. | Martini can store credentials in environment configuration or secrets and apply authenticated API configuration without embedding tokens in workflows. |
| Webhooks / outbound callbacks | Limited | Specific Domo features may provide alerting, automation, or callback behavior, but a universal notification interface for all DataSet and platform-object changes was not confirmed. | Martini can expose an API or receive a callback when the required Domo feature and event coverage are explicitly available; otherwise it can use scheduled polling and watermarks. |
| File / attachment APIs | Limited | Domo supports structured file or payload ingestion into DataSets, but a general-purpose attachment API for Cards, Pages, Users, or Groups was not confirmed. | Martini can transform CSV-like or structured source data into DataSet ingestion payloads; arbitrary attachment handling should not be assumed. |
| SDKs and client libraries | Yes | Domo provides developer resources and API tooling for its REST APIs, although the integration model remains API-oriented. | Martini does not require a Domo-specific SDK and can call documented endpoints directly, mapping responses and handling errors in workflows. |
| GraphQL APIs | Not confirmed | No generally supported Domo GraphQL API was confirmed in the reviewed developer material. | Martini should use Domo REST and data APIs rather than assume GraphQL availability. |
How Domo exposes data and business events
Domo REST APIs
Domo’s primary programmatic integration surface provides REST APIs for DataSet management, data ingestion and publishing, query access, analytics assets, Users, Groups, and other platform administration functions. The available operations depend on the tenant, API product, and permissions associated with the credential.
Martini implementation pattern
Martini implementation pattern: A Martini workflow builds authenticated REST requests, retrieves or publishes the required Domo object, handles pagination and response validation, transforms the result, and routes it to the next system or workflow step. Credentials remain in environment configuration or secrets, while checkpoints and identifiers support recovery.
Implementation sequence
Domo DataSet ingestion and batch APIs
Domo provides dataset-oriented APIs for importing, replacing, appending, and publishing structured data, including larger transfers that are not suitable for individual record operations. Integration designs must distinguish metadata management from the actual data load.
Martini implementation pattern
Martini implementation pattern: A scheduled or API-triggered workflow extracts source data, determines whether the load is a snapshot or delta, transforms it into the expected DataSet structure, submits a controlled batch, and validates processing results before marking the workflow complete.
Implementation sequence
Domo query and analytics APIs
Domo query capabilities allow integrations to retrieve data already stored in DataSets for downstream synchronization, reconciliation, business-rule evaluation, and scheduled extracts. Query results represent Domo’s loaded analytical state and may not reflect immediate source-system changes.
Martini implementation pattern
Martini implementation pattern: Martini schedules or receives an approved request, queries the relevant DataSet with filters and checkpoints, evaluates freshness and business rules, and sends selected results to an operational application, warehouse, or another governed destination.
Implementation sequence
Domo notifications and callbacks
A universal Domo webhook mechanism for all DataSet, DataFlow, Card, Page, User, and Group changes was not confirmed. Specific Domo features may provide alerting or automation behavior, but event coverage must be verified before using it as an integration trigger.
Martini implementation pattern
Martini implementation pattern: When a documented Domo feature provides an outbound callback, Martini can expose an API endpoint and validate the incoming request before starting a workflow. If no suitable event exists, a scheduled query with a timestamp, source identifier, or ingestion-batch watermark is the safer design.
Implementation sequence
Domo administration APIs
Domo REST APIs include administration scenarios involving Users, Groups, DataSets, access controls, and other platform assets, subject to the credential’s tenant and permission model. These operations should be separated from ordinary analytical data movement.
Martini implementation pattern
Martini implementation pattern: Martini receives an approved identity or governance request, validates scope and authorization, calls the relevant Domo administration endpoint, and records the result for reconciliation and audit. Administrative credentials should be isolated from ingestion and query credentials.
Implementation sequence
Common Domo integration patterns
Pattern 1: Publish operational data to a Domo DataSet
When to use this pattern
Use this pattern when Domo is the analytical destination for operational data from systems such as Salesforce, ServiceNow, NetSuite, or Workday. It is appropriate for reporting extracts, operational metrics, and governed data marts where the source remains the system of record.
Integration direction
Example Mapping
| Domo Field | Canonical Field | Target Field |
|---|---|---|
| Id | sourceKey | Source_Key |
| LastModifiedDate | sourceModifiedAt | Source_Modified_At |
| Name | displayName | Display_Name |
| OwnerId | ownerKey | Owner_Key |
Martini implementation pattern
A scheduled Martini workflow retrieves source pages after a persisted watermark, normalizes dates and identifiers, validates required fields, and selects replace or append semantics based on whether the source is a snapshot or delta. It publishes a controlled DataSet batch, checks row counts or processing status, and retries transient failures without duplicating appended data.
Martini capabilities used
- workflows
- scheduling
- API consumption
- data mapping
- business rules
- error handling
Pattern 2: Synchronize a Domo DataSet to an operational application
When to use this pattern
Use this pattern when a Domo DataSet contains approved analytical or governed outputs that must be sent to an operational system. The design must account for delayed refreshes and must not treat Domo’s analytical state as an immediate substitute for the source application’s transactional state.
Integration direction
Example Mapping
| Domo Field | Canonical Field | Target Field |
|---|---|---|
| DataSet business key | objectKey | External identifier |
| Status | approvalStatus | State |
| Owner | responsibleUser | Assigned to |
| Updated timestamp | sourceUpdatedAt | Updated source time |
Martini implementation pattern
Martini queries the DataSet on a schedule, verifies that the expected refresh or load is available, filters approved rows, and maps them to the target application. Stable business keys and an execution ledger prevent duplicate writes; validation failures are isolated while temporary API failures are retried.
Martini capabilities used
- scheduled workflows
- API consumption
- query orchestration
- data mapping
- validation
- idempotency controls
Pattern 3: Exchange governed data between Domo and a warehouse
When to use this pattern
Use this pattern for reconciliation, archival, governed data exchange, or cross-platform reporting between Domo and Snowflake or Amazon Redshift. It is useful when ownership is split between an analytical platform and a warehouse and both sides require measurable load quality.
Integration direction
Example Mapping
| Domo Field | Canonical Field | Target Field |
|---|---|---|
| DataSet name | datasetName | Table name |
| DataSet row key | businessKey | Business key |
| Load timestamp | loadStartedAt | Ingestion timestamp |
| Column definition | schemaDefinition | Table schema |
Martini implementation pattern
A Martini batch workflow queries or publishes data through documented interfaces, compares schemas and business keys, transforms types and timestamps, and writes the validated result to the warehouse. It compares row counts and load timestamps, records batch identifiers, and routes schema or permission failures for correction rather than repeatedly retrying them.
Martini capabilities used
- workflow orchestration
- REST API consumption
- database connectivity
- schema validation
- data transformation
- monitoring
Pattern 4: Reconcile Domo Users and Groups with an identity platform
When to use this pattern
Use this pattern for joiner, mover, leaver, group synchronization, access review, or DataSet provisioning processes where Domo administration must be coordinated with an identity or IT platform. Domo permissions remain authoritative for Domo access decisions.
Integration direction
Example Mapping
| Domo Field | Canonical Field | Target Field |
|---|---|---|
| User email | identityKey | User email |
| Group name | accessGroup | Domo group |
| User active state | enabled | User status |
| Requested permission | accessScope | DataSet permission |
Martini implementation pattern
Martini receives an approved request or runs a reconciliation workflow, validates authorization and scope, compares current Domo Users or Groups with the source, and applies only permitted changes. It records outcomes for audit, isolates permission failures, and avoids granting broader access than the request requires.
Martini capabilities used
- API orchestration
- business rules
- data mapping
- validation
- security controls
- error handling
Applications commonly integrated with Domo
Domo can be integrated with operational applications and analytical platforms through their documented APIs, database interfaces, and Domo DataSet ingestion or query capabilities. The following are practical enterprise integration counterparts; exact objects and access depend on each system’s permissions and implementation.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Publish Accounts, Contacts, Leads, Opportunities, and activity data to Domo for reporting and performance analysis. | Salesforce → Martini → Domo | A scheduled Martini workflow retrieves Salesforce data incrementally, maps it to a Domo DataSet schema, validates required fields, and uses append or replace semantics according to the reporting model. The workflow records watermarks and batch identifiers and retries transient failures. |
| ServiceNow | Consolidate Incidents, Requests, Changes, and configuration data in Domo for operational reporting and governance. | ServiceNow → Martini → Domo | Martini consumes ServiceNow REST responses, normalizes timestamps and reference values, and publishes structured DataSet loads. Validation, row-count checks, permission-error handling, and checkpointed pagination support reliable scheduled synchronization. |
| NetSuite | Load Customers, Sales Orders, Invoices, Items, and financial data into Domo for financial and operational analysis. | NetSuite → Martini → Domo | A scheduled workflow retrieves approved NetSuite objects, applies business rules for subsidiary and accounting scope, transforms the data into Domo-compatible batches, and validates import status before recording completion. |
| Workday | Provide worker, organization, and workforce metrics to Domo while preserving Workday as the system of record. | Workday → Martini → Domo | Martini retrieves permitted Workday data, maps worker and organization attributes to a governed DataSet model, filters sensitive fields, and publishes controlled snapshots with schema validation and audit logging. |
| Snowflake | Exchange governed analytical data between Domo and a cloud data warehouse for reconciliation, archival, and cross-platform reporting. | Domo → Martini → Snowflake | Martini queries Domo DataSets or coordinates warehouse-side extraction, compares schemas and business keys, transforms data between models, and writes validated batches while checking row counts and load timestamps. |
| Jira | Combine Issues, Projects, and work-management data with business performance data in Domo. | Jira → Martini → Domo | A scheduled Martini workflow retrieves Jira data through its APIs, standardizes project and issue fields, excludes or masks non-reportable values, and publishes incremental or snapshot DataSet loads with retry handling. |
| HubSpot | Bring Companies, Contacts, Deals, and marketing activity into Domo for revenue and campaign analysis. | HubSpot → Martini → Domo | Martini consumes HubSpot API pages, applies deduplication and field normalization, maps the result to DataSet columns, and publishes append or replacement batches with persisted extraction checkpoints. |
| Amazon Redshift | Centralize or exchange analytical datasets between Redshift and Domo according to data ownership and reporting requirements. | Amazon Redshift → Martini → Domo | Martini coordinates scheduled extracts or loads using the documented interfaces of both platforms, validates schema and row counts, and handles partial failures through batch identifiers and controlled retries. |
How to build a Domo integration in Martini
Objective
Establish Domo API access using the authentication method and permission scope appropriate for the integration, while keeping credentials outside workflow source.
Instructions in Martini
- Configure OAuth 2.0 or a Domo access token as required by the tenant
- Store credentials in Martini environment configuration or secrets
- Use separate credentials for ingestion, query, and administration where appropriate
- Confirm the credential can access the required DataSets or platform objects
Objective
Select a trigger that matches Domo’s confirmed capabilities and the freshness requirements of the integration.
Instructions in Martini
- Use a scheduler for periodic DataSet queries or publishing
- Use an API request when an external system initiates the process
- Use a Domo callback only after its specific feature and event coverage are confirmed
- Persist a timestamp, source identifier, or ingestion-batch watermark for polling
Objective
Obtain the relevant Domo resource or source payload while handling pagination, asynchronous processing, and analytical freshness.
Instructions in Martini
- Call the documented Domo REST or query endpoint
- Follow page-size and continuation rules until extraction is complete
- Check import or processing status where the API exposes it
- Avoid assuming that a successful upstream load is immediately queryable
Objective
Coordinate API calls, transformations, business decisions, and target-system writes as a maintainable Martini workflow.
Instructions in Martini
- Separate extraction, transformation, validation, and delivery stages
- Use reusable workflow logic for common Domo request and response handling
- Route permission, validation, throttling, and transient failures differently
- Record checkpoints and batch identifiers for restartability
Objective
Convert Domo DataSet, User, Group, or analytical results into the canonical model required by the destination.
Instructions in Martini
- Map stable business keys and timestamps explicitly
- Normalize dates, numeric values, nulls, and serialized JSON where present
- Validate required columns and expected schema versions
- Apply masking or filtering to sensitive administrative or workforce data
Objective
Ensure that only valid, authorized, and sufficiently fresh data is published or sent downstream.
Instructions in Martini
- Distinguish snapshot, delta, and append-only data
- Check analytical freshness before downstream synchronization
- Apply approval, scope, ownership, and least-privilege rules
- Use deterministic deduplication and idempotency keys
Common Domo data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| DataSets | Structured collections used for analysis, reporting, data exchange, snapshots, append-only history, or downstream synchronization. | Salesforce, ServiceNow, NetSuite, Snowflake, Amazon Redshift, reporting applications | Martini creates or manages DataSet metadata, transforms source data, selects append or replace behavior, publishes batches, queries data, and records checkpoints or import identifiers. |
| DataFlows | Transformation pipelines that process one or more input DataSets into output DataSets. | Data warehouses, reporting platforms, operational applications | Martini can coordinate related API operations, monitor known processing states where exposed, and avoid assuming that a successful upstream load means the transformed output is immediately fresh. |
| Cards | Visualizations or analytical views built from Domo data. | Reporting processes, governance workflows, analytical applications | Martini can use documented REST operations for supported Card-related administration or metadata scenarios, subject to tenant permissions and API coverage. |
| Pages | Dashboard and navigation containers that organize Cards and analytical content. | Governance platforms, reporting inventories, administrative workflows | Martini can coordinate supported Page metadata or administration operations through REST APIs and apply authorization and audit controls. |
| Users | Domo identities that are provisioned, managed, and associated with access permissions. | Identity platforms, HR systems, IT service platforms | Martini can synchronize permitted user attributes through administration APIs, apply least-privilege rules, and reconcile failures without treating Domo access as source-system authorization. |
| Groups | Collections of Users used to administer access and collaboration permissions. | Identity platforms, IT service platforms, access-review systems | Martini can compare group membership, apply approved changes through Domo APIs, and preserve audit records and reconciliation checkpoints. |
Authentication and security considerations
Authentication and authorization
Domo supports OAuth 2.0 and access-token patterns using bearer-token authorization. Access is constrained by the Domo user, client, tenant, DataSet permissions, and applicable policies.
- Store tokens and client credentials in Martini environment configuration or secrets.
- Use separate credentials for ingestion, query-only access, and platform administration where practical.
- Apply least privilege to DataSet, User, Group, and governance operations.
- Do not embed credentials in workflows, mappings, or source files.
Operational considerations for Domo integrations
Reliability and data quality
Domo integrations must account for pagination, rate limits, asynchronous processing, schema evolution, and the difference between analytical freshness and transactional state.
- Handle HTTP 429 responses, honor Retry-After when supplied, and use bounded exponential backoff.
- Persist watermarks, page checkpoints, import identifiers, and batch identifiers for restartability.
- Use stable business keys and deterministic replace or append strategies to control duplicates.
- Validate schemas, row counts, timestamps, and processing status before completing a load.
- Route authentication, permission, schema, and payload errors for correction rather than repeatedly retrying them.
- Test changes to DataSet columns, types, refresh timing, and downstream mappings before production deployment.
Why use Martini instead of scripts or point-to-point integrations?
Maintainable integration orchestration
Direct scripts can connect to Domo, but they often leave authentication, pagination, transformation, retries, monitoring, and downstream coordination scattered across custom code. Martini provides a workflow-based integration layer for consuming Domo APIs, exposing controlled APIs, applying business rules, and mapping data to multiple targets.
- Centralize REST API configuration, secrets, pagination, and error handling.
- Reuse mappings and workflow logic across DataSet ingestion, query, and administration processes.
- Support scheduled, API-driven, and conditional orchestration without creating separate point-to-point scripts.
- Make checkpoints, validation, retries, and operational logging part of the integration design.
- Keep Domo-specific behavior distinct from canonical models and downstream application rules.
Frequently asked questions
Domo can be integrated primarily through its REST APIs for DataSet creation and management, data ingestion and publishing, query access, analytics assets, and platform administration. Dataset-oriented batch operations support larger structured transfers, while scheduled query workflows can support synchronization when universal change webhooks are not available.
Yes. Martini can integrate with Domo by consuming its REST, DataSet ingestion, publishing, query, and administration APIs. Martini can authenticate requests, transform data, orchestrate scheduled or API-driven workflows, expose APIs for approved callbacks, and handle pagination, retries, and checkpoints.
No. A dedicated Domo connector is not required. Martini can use Domo’s confirmed native integration mechanisms, including REST APIs, OAuth 2.0 or access-token authentication, DataSet ingestion and query APIs, and specific callbacks where the relevant Domo feature explicitly supports them.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Domo. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Domo, cloud infrastructure, or other third-party systems based on subscription, usage, and deployment model.
REST APIs should be the default because they are Domo’s primary supported programmatic interface. Use DataSet ingestion or batch capabilities for larger structured loads, query APIs for analytical extraction, and administration APIs for governed User, Group, and platform operations. No generally supported Domo GraphQL or SOAP API was confirmed.
A universal webhook mechanism for all DataSet, DataFlow, Card, Page, User, and Group changes was not confirmed. A specific Domo feature may provide alerting, automation, or callback behavior, but coverage must be verified. Otherwise, scheduled Martini queries with timestamps, source identifiers, or ingestion-batch watermarks are safer.
Martini can schedule DataSet queries or source-system extracts, paginate through results, transform data, and publish or deliver controlled batches. The workflow should distinguish snapshots from deltas, account for analytical refresh timing, use stable business keys, and validate row counts, schemas, and load identifiers.
Martini workflows can separate authentication, permission, validation, throttling, and transient platform errors. They can honor Retry-After when supplied, use bounded exponential backoff, persist checkpoints, and apply deterministic append or replace strategies. Stable identifiers, batch tracking, and row-count validation help prevent duplicate or partial loads.
Related Martini documentation
API Workflows
Data Processing
Security Operations
Integrate Domo with Martini
Use Martini to build maintainable Domo integrations around REST APIs, DataSet ingestion, query workflows, administration, data transformation, and reliable enterprise orchestration.