.png)
Typeform Integration Guide
Integrate Typeform forms and response submissions with enterprise systems through REST APIs, response webhooks, scheduled synchronization, and secure authentication.
Typeform integration options at a glance
Typeform provides REST APIs for forms, responses, webhooks, workspaces, themes, and images. Its Responses API supports paginated retrieval and filtering, making scheduled synchronization and reconciliation possible when a webhook is missed or historical data is required. Typeform also supports webhook notifications primarily for submitted responses associated with a form. Authentication is available through personal access tokens for controlled internal integrations and OAuth 2.0 for delegated or multi-account access. Martini can consume these APIs, expose an endpoint for Typeform callbacks, map response answers and hidden fields, apply validation and business rules, and orchestrate reliable delivery to downstream applications or databases.
| Integration point | Supported by Typeform? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Manage and retrieve Forms, Responses, Webhooks, Workspaces, Themes, and Images. The Responses API supports paginated response retrieval and filtering. | Martini can consume Typeform REST endpoints from workflows, transform JSON payloads, apply business rules, and call downstream APIs or databases. |
| Webhooks / outbound callbacks | Limited | Notify an external endpoint when responses are submitted for a configured form. Coverage should not be treated as universal Typeform event streaming. | Martini can expose an API endpoint or workflow trigger endpoint to receive callbacks, validate payloads, acknowledge promptly, and route processing asynchronously when appropriate. |
| Authentication | Yes | Personal access tokens support controlled internal integrations, while OAuth 2.0 supports delegated access across independently authorized Typeform accounts. | Martini can store credentials in secure environment configuration or secrets and use bearer-token authentication when consuming Typeform APIs. |
| Pagination and incremental response retrieval | Yes | Retrieve historical or newly added Responses using the documented filtering, pagination, and timestamp-related capabilities. | Martini can schedule workflows, persist response timestamps or identifiers as checkpoints, process pages, and reconcile missed webhook notifications. |
| File-upload response data | Limited | Responses may contain file-upload answer data or references. A separate general-purpose Typeform attachment API was not confirmed. | Martini can inspect and validate file references, but implementations must confirm availability, authorization, download behavior, and retention requirements for the specific form. |
| Bulk or asynchronous APIs | Not confirmed | Typeform documents response retrieval and pagination, but a separate bulk export or asynchronous batch API was not confirmed. | Martini can implement paginated, checkpointed workflows rather than assuming a bulk export mechanism. |
| GraphQL APIs | Not confirmed | No official Typeform GraphQL API was confirmed in the reviewed documentation. | Martini integrations should use the confirmed Typeform REST APIs and webhook callbacks instead. |
| SOAP APIs | No | No official Typeform SOAP API was confirmed. | Martini does not need SOAP for this integration; it can consume Typeform REST APIs and receive webhook callbacks. |
How Typeform exposes data and business events
Typeform REST APIs
Typeform provides REST APIs for Forms, Responses, Webhooks, Workspaces, Themes, and Images. The Responses API is the primary mechanism for retrieving submitted answers, metadata, hidden fields, variables, and form-specific values, with pagination and filtering used for historical or incremental synchronization.
Martini implementation pattern
Martini implementation pattern: a workflow authenticates to Typeform with a personal access token or OAuth 2.0 credential, invokes the required REST endpoint, processes paginated JSON responses, maps the vendor model to a canonical structure, and writes to downstream APIs or databases. Checkpoints and response identifiers support recovery and duplicate prevention.
Implementation sequence
Typeform Webhooks
Typeform supports webhook registrations associated with a form and can notify external endpoints primarily when responses are submitted. This is a selected-event callback mechanism rather than universal event coverage for every Typeform resource.
Martini implementation pattern
Martini implementation pattern: expose a controlled API endpoint, receive the Typeform callback, validate its structure and identifiers, acknowledge promptly, and hand the response to a workflow for transformation and downstream delivery. A scheduled Responses API reconciliation flow can recover missed or failed notifications.
Implementation sequence
Typeform Authentication
Typeform supports bearer-token requests using personal access tokens and delegated OAuth 2.0 authorization with scopes. Personal access tokens suit controlled internal integrations, while OAuth 2.0 is appropriate when multiple Typeform accounts authorize access independently.
Martini implementation pattern
Martini implementation pattern: keep tokens, client credentials, and environment-specific settings outside workflow payloads, configure the appropriate authorization mechanism, request only required scopes, and rotate or revoke credentials according to enterprise security policy.
Implementation sequence
Typeform Response Synchronization
The Responses API supports paginated retrieval and can be used with timestamp or other supported filtering parameters for incremental synchronization. Typeform does not provide a confirmed separate bulk or asynchronous export API in the reviewed documentation.
Martini implementation pattern
Martini implementation pattern: schedule a workflow, load the last successful response timestamp or identifier, retrieve pages with bounded concurrency, process each response using the response identifier as an idempotency key, and update the checkpoint only after successful handling.
Implementation sequence
Common Typeform integration patterns
Pattern 1: Sync Typeform responses to Salesforce
When to use this pattern
Use this pattern for lead capture, event registration, qualification surveys, customer feedback, or service intake that must create or update Salesforce objects. Webhooks provide prompt processing, while scheduled retrieval can reconcile missed notifications.
Integration direction
Example Mapping
| Typeform Field | Canonical Field | Target Field |
|---|---|---|
| response_id | externalSubmissionId | External Submission ID |
| hidden.source | campaignSource | Lead Source |
| answers.email | ||
| answers.name | fullName | Name |
Martini implementation pattern
Martini receives a response callback or retrieves the response through the Responses API, validates required answers and consent, normalizes question-specific values, and checks Salesforce for an existing Lead, Contact, or Case before writing. The workflow records the Typeform response identifier, retries transient Salesforce failures, and routes mapping or authorization failures for review.
Martini capabilities used
- workflows
- API consumption
- API exposure
- data mapping
- validation
- business rules
- error handling
Pattern 2: Load Typeform responses into a SQL database
When to use this pattern
Use this pattern for reporting, analytics preparation, operational history, or downstream processing that requires a durable response store. It is particularly suitable for historical backfills and scheduled reconciliation.
Integration direction
Example Mapping
| Typeform Field | Canonical Field | Target Field |
|---|---|---|
| response_id | sourceResponseId | source_response_id |
| submitted_at | submittedAt | submitted_at |
| form_id | sourceFormId | source_form_id |
| answers | normalizedAnswers | answer columns or JSON payload |
Martini implementation pattern
A scheduled Martini workflow loads a checkpoint, retrieves paginated Responses, normalizes answer values according to the form's stable field identifiers, and writes them through a SQL workflow step. A unique key based on response_id prevents duplicates, while transient API or database failures are retried without advancing the checkpoint incorrectly.
Martini capabilities used
- scheduled workflows
- API consumption
- pagination orchestration
- data mapping
- JSON handling
- SQL database access
- error handling
Pattern 3: Route important submissions to Slack or Zendesk
When to use this pattern
Use this pattern when selected form responses should trigger team notifications or structured service intake. Routing can depend on the form, hidden campaign fields, answer values, or urgency indicators.
Integration direction
Example Mapping
| Typeform Field | Canonical Field | Target Field |
|---|---|---|
| form_id | submissionForm | routing rule |
| answers.priority | priority | notification severity or ticket priority |
| answers.message | requestDescription | Slack message or Zendesk description |
| response_id | sourceReference | message or ticket metadata |
Martini implementation pattern
Martini receives the webhook, validates the payload, evaluates routing and priority rules, and formats either a Slack notification or a Zendesk ticket. It retains the original response identifier for traceability, suppresses duplicate deliveries, and records failed downstream calls for replay.
Martini capabilities used
- webhook consumption
- workflow triggers
- conditional routing
- data transformation
- business rules
- duplicate detection
- error handling
Pattern 4: Synchronize Typeform form metadata
When to use this pattern
Use this pattern when an organization needs an internal catalog of Forms, fields, themes, or ownership information for governance, documentation, or configuration management.
Integration direction
Example Mapping
| Typeform Field | Canonical Field | Target Field |
|---|---|---|
| id | formId | external_form_id |
| title | formName | name |
| fields.id | questionId | external_question_id |
| workspace_id | workspaceId | workspace_id |
Martini implementation pattern
Martini invokes the Forms API on a schedule, retrieves current form metadata, maps stable identifiers and labels into the internal catalog, and compares the result with the previous snapshot. Validation and change rules can flag removed or changed questions for review before dependent integrations are updated.
Martini capabilities used
- scheduled workflows
- API consumption
- data mapping
- change detection
- validation
- business rules
- monitoring
Applications commonly integrated with Typeform
Typeform submissions can be routed through Martini to applications used for sales, marketing, collaboration, service intake, data capture, and enterprise operations. The specific target model and authorization requirements should be designed for each use case.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Convert Typeform submissions into Leads, Contacts, Campaign Members, or Cases while preserving response identifiers and campaign context. | Typeform → Martini → Salesforce | Martini receives a Typeform response webhook or retrieves responses on a schedule, validates answers and hidden fields, checks for an existing Salesforce object, and creates or updates the appropriate object with retry and duplicate protection. |
| HubSpot | Add respondents to contacts, lists, campaigns, or marketing workflows when the submission contains appropriate consent and segmentation data. | Typeform → Martini → HubSpot | A Martini workflow maps Typeform answers and hidden fields to HubSpot properties, applies consent and routing rules, and invokes HubSpot APIs with response-based idempotency and error handling. |
| Google Sheets | Make selected form responses available to business users for operational review, lightweight reporting, or controlled collaboration. | Typeform → Martini → Google Sheets | Martini consumes Typeform response data, normalizes answer values into a tabular structure, and writes rows to Google Sheets while retaining the Typeform response identifier to prevent duplicate rows. |
| Slack | Notify teams when important registrations, feedback submissions, or intake responses meet defined business conditions. | Typeform → Martini → Slack | Martini receives the response callback, evaluates form and answer-based routing rules, formats a concise notification, and sends it to the appropriate Slack destination while logging delivery failures. |
| Mailchimp | Add consented respondents to audiences or initiate follow-up campaigns using form answers and marketing context. | Typeform → Martini → Mailchimp | A Martini workflow validates marketing consent, maps respondent attributes to Mailchimp audience fields, rejects incomplete or unauthorized submissions, and retries only transient downstream failures. |
| Airtable | Store structured submissions for operational workflows, team collaboration, and lightweight process management. | Typeform → Martini → Airtable | Martini transforms Typeform answers into Airtable fields, applies form-specific mappings, and creates or updates rows using the Typeform response identifier as the duplicate-prevention key. |
| Zendesk | Turn customer or service-intake responses into tickets or structured support requests. | Typeform → Martini → Zendesk | Martini classifies the submission using form identifiers and answer values, maps it to Zendesk ticket fields, attaches traceability metadata, and routes failures for controlled replay. |
| NetSuite | Send registration, customer-intake, or operational form data into customer and transaction-related processes. | Typeform → Martini → NetSuite | Martini retrieves or receives Typeform responses, validates the business payload, maps it to the NetSuite-specific target model, and coordinates retries and idempotent writes for the selected process. |
How to build a Typeform integration in Martini
Objective
Establish the Typeform API connection using the authentication model appropriate to the deployment and account structure.
Instructions in Martini
- Choose a personal access token for a controlled internal integration or OAuth 2.0 for delegated multi-account access.
- Store tokens, client credentials, and environment settings in Martini secrets or secure configuration.
- Limit OAuth scopes to the Typeform resources required by the workflow.
Objective
Select webhook-driven, scheduled, or API-driven execution based on latency, reconciliation, and operational requirements.
Instructions in Martini
- Use a Typeform response webhook for prompt processing of submitted responses.
- Use a scheduler with the Responses API for historical retrieval, reconciliation, or polling-only designs.
- Use a workflow or API endpoint when another system must initiate synchronization.
Objective
Obtain Typeform response or metadata payloads and preserve the identifiers needed for traceability and replay.
Instructions in Martini
- Validate callback structure and capture form_id and response_id values.
- For polling, retrieve pages using the documented pagination and filtering parameters.
- Persist a timestamp or response identifier checkpoint only after successful processing.
Objective
Coordinate validation, enrichment, routing, target calls, and checkpoint management in a maintainable Martini workflow.
Instructions in Martini
- Separate transport acknowledgment from longer-running downstream work when appropriate.
- Use conditional routing for form-specific or answer-based processing.
- Keep reconciliation and replay paths explicit rather than embedding recovery in ad hoc scripts.
Objective
Convert Typeform's form-specific answer model into canonical and target-system structures.
Instructions in Martini
- Map by stable question and field identifiers where possible instead of display labels alone.
- Handle hidden fields, variables, respondent metadata, and answer types explicitly.
- Normalize dates, identifiers, consent values, and optional fields before target delivery.
Objective
Enforce data quality, consent, routing, and duplicate-prevention requirements before writing to downstream systems.
Instructions in Martini
- Validate required answers and expected form identifiers.
- Use response_id as a durable idempotency key.
- Confirm marketing consent before adding respondents to marketing audiences.
Common Typeform data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Forms | Represent questionnaires, surveys, registration forms, and other Typeform data-collection experiences. | Salesforce, HubSpot, internal catalogs, governance systems, and documentation platforms | Martini can retrieve form definitions and metadata, map stable form and field identifiers, and synchronize changes through scheduled workflows. |
| Responses | Contain submitted answers, response metadata, hidden fields, variables, and form-specific answer values. | Salesforce, HubSpot, Google Sheets, Airtable, Zendesk, NetSuite, SQL databases, and data warehouses | Martini can receive response notifications or retrieve responses through paginated API calls, validate payloads, normalize answers, enforce idempotency, and route results. |
| Webhooks | Represent callback registrations associated with a form for notification of selected events, primarily submitted responses. | Martini API endpoints and other callback consumers | Martini can expose the receiving endpoint, validate callback data, return a prompt response, and start downstream processing with replay and reconciliation support. |
| Workspaces | Organize and manage Typeform resources within an account or organization. | Internal resource catalogs, governance systems, and administrative applications | Martini can consume workspace data through the REST API and map organizational ownership or grouping into internal models. |
| Themes | Store visual configuration applied to Typeform forms. | Internal form catalogs, governance systems, and content management processes | Martini can retrieve theme metadata when required for form inventory or configuration synchronization. |
| Images | Represent image assets used within Typeform forms. | Content catalogs, asset management processes, and internal form inventories | Martini can retrieve relevant image metadata through the REST API; file transfer behavior should be designed separately from metadata synchronization. |
Authentication and security considerations
Authentication options
Typeform supports personal access tokens for controlled internal integrations and OAuth 2.0 for delegated access across independently authorized accounts. API requests use bearer-token authentication.
Credential protection
- Store tokens, OAuth credentials, and environment-specific settings in Martini secrets or secure environment configuration.
- Request only the scopes required for Forms, Responses, Webhooks, or other resources used by the workflow.
- Rotate or revoke credentials according to enterprise security policy.
Data protection
Responses may contain personal or other sensitive information. Minimize copied data, apply downstream retention and access policies, and validate marketing consent before sending respondents to marketing platforms.
Operational considerations for Typeform integrations
Rate limits and pagination
Design response retrieval around documented pagination and bounded concurrency. Handle HTTP 429 responses with controlled retries, backoff, and retry limits.
Idempotency and replay
Use response_id as the durable idempotency key. Persist processing status and error details so webhook deliveries and scheduled reconciliation can be replayed safely.
Webhook reliability
Validate callback structure, acknowledge promptly, and avoid long-running synchronous work where asynchronous workflow execution is more suitable. Retain form and response identifiers for tracing.
Schema changes
Answer structures depend on form questions and field identifiers. Treat additions, removals, renames, and answer-type changes as integration changes that require mapping review and testing.
File uploads
File-upload answers may contain references rather than generally transferable attachments. Confirm access, authorization, availability, download behavior, and retention before implementing file processing.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration instead of scripts
Martini provides a maintainable workflow for receiving Typeform callbacks, invoking REST APIs, retrieving paginated responses, applying rules, and delivering data to multiple systems.
Reusable transformation
Mappings, validation, idempotency checks, checkpoints, and routing logic can be reused across forms and target applications instead of being duplicated in point-to-point scripts.
Operational control
Martini provides structured error handling, retry paths, logging, and workflow monitoring so teams can distinguish rate limits, authorization failures, schema issues, and downstream errors.
API-led integration
Martini can expose controlled API endpoints for Typeform callbacks and create reusable integration assets around Typeform's documented APIs without requiring a dedicated vendor connector.
Frequently asked questions
Typeform can be integrated through its REST APIs and response webhooks. REST APIs support Forms, Responses, Webhooks, Workspaces, Themes, and Images, while webhooks primarily notify external endpoints about submitted responses. Scheduled Responses API retrieval can support historical synchronization and reconciliation.
Yes. Martini can consume Typeform REST APIs, receive Typeform response webhook callbacks through an exposed API endpoint, schedule incremental or historical response retrieval, transform Typeform payloads, and deliver results to downstream applications or databases.
No. A dedicated Typeform connector is not required. Martini can integrate using Typeform's confirmed native REST APIs, response webhooks, personal access tokens or OAuth 2.0, and supported response retrieval mechanisms.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Typeform. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Typeform, cloud infrastructure, or other third-party systems depending on subscription, usage, and deployment model.
Use the REST APIs for retrieving responses, managing forms, and working with other Typeform resources. Use response webhooks when prompt notification of submitted responses is needed, and use scheduled Responses API retrieval for reconciliation, replay, or historical synchronization. Typeform GraphQL and SOAP APIs were not confirmed.
Typeform supports webhook notifications associated with a form, primarily for submitted responses. This should not be treated as universal event coverage for every Typeform resource. Martini can receive the callback, validate it, process it through a workflow, and reconcile delivery with scheduled API retrieval.
Martini can retrieve paginated Responses using a stored timestamp or response identifier checkpoint, or process webhook notifications as they arrive. It maps form-specific answers, hidden fields, variables, and metadata into canonical and target models, with stable question identifiers preferred over display labels.
Use the Typeform response identifier as an idempotency key, separate transient failures from mapping or authorization errors, and retry rate-limit or temporary network failures with bounded backoff. Failed payloads or identifiers should be retained for controlled replay without creating duplicate downstream objects.
Related Martini documentation
API Integration
Connect Typeform to your enterprise systems
Use Martini to build reliable Typeform integrations that combine response webhooks, REST API synchronization, secure authentication, transformation, business rules, and operational error handling.