Ellipse Gradient for Header

Formstack Integration Guide

Connect Formstack Forms, Documents, and Sign with enterprise systems through REST APIs, selected webhook events, OAuth 2.0, and orchestrated workflows.

Formstack integration options at a glance

Formstack’s primary integration model is product-specific REST APIs covering resources such as Forms, Submissions, Fields, Documents, Templates, and signature-related objects. Selected events, particularly form submission events, can generate webhook-style notifications, while scheduled polling is appropriate where event coverage is unavailable. OAuth 2.0 is the primary documented authentication method, although some products or account configurations may use additional credentials. File and attachment handling depends on the relevant product and endpoint. Martini can consume these APIs, receive callbacks through a Martini API, paginate and batch retrievals, transform JSON, route files, and orchestrate downstream systems with validation, retries, and durable processing state.

Integration pointSupported by Formstack?Common use casesHow Martini supports it
REST APIsYesFormstack REST APIs provide product-specific access to Forms, Submissions, Fields, Documents, Templates, users, and other resources. Coverage varies across Forms, Documents, and Sign.Martini can consume Formstack REST endpoints, handle pagination, transform JSON, apply business rules, and expose a controlled REST API for downstream clients.
Webhooks / outbound callbacksLimitedWebhook-style notifications are available for selected events, especially submission-related events, but coverage is not universal across products or objects.Martini can expose an API to receive callbacks, validate payloads, invoke workflows, and use scheduled polling when the required event is unavailable.
File / attachment APIsLimitedFormstack Forms can collect uploaded files, while Formstack Documents manages generated documents. Retrieval and upload behavior depends on the product, endpoint, and plan.Martini can separate structured data from binary content, transfer supported files or metadata, and write them to downstream APIs or storage endpoints.
AuthenticationYesOAuth 2.0 is the primary documented authentication pattern. Product-specific API credentials may also apply to some products or account configurations.Martini can store credentials as environment secrets and reference them from API-consuming workflows rather than embedding them in workflow definitions.
Scheduled synchronizationYesPolling is appropriate for resources or events that are not covered by Formstack webhook notifications, using documented endpoints and pagination.Martini can schedule workflows, persist a cursor or timestamp, process controlled batches, and maintain idempotent state.
Bulk / asynchronous APIsNot confirmedA general bulk or asynchronous API covering all Formstack resources was not confirmed. Controlled batching should use documented resource endpoints.Martini can orchestrate paginated, bounded batches and retry transient failures without claiming a Formstack bulk API.
GraphQL APIsNot confirmedA public Formstack GraphQL API was not confirmed in the supplied research.Martini can use the confirmed REST APIs instead and can integrate GraphQL systems elsewhere in the surrounding workflow when required.
SOAP APIsNot confirmedA current Formstack SOAP API was not confirmed in the supplied research.Martini can consume SOAP services from other systems in a broader workflow, but Formstack integration should use confirmed REST or callback mechanisms.

How Formstack exposes data and business events

Formstack REST APIs

Formstack’s primary integration mechanism is product-specific REST APIs for Forms, Submissions, Fields, Documents, Templates, and other supported resources. API availability, object coverage, and authentication can vary by product and account plan.

Martini implementation pattern

Martini implementation pattern: a workflow authenticates to the applicable Formstack API, retrieves or writes the required resource, transforms the response, applies business rules, and calls downstream systems or exposes a controlled result through a Martini API.

Implementation sequence

Authenticate using the applicable Formstack credential
Call the documented Formstack resource endpoint
Handle pagination and normalize the JSON response
Map fields to the target system model
Apply validation and business rules
Write the result and persist the source identifier

Formstack Webhooks

Formstack supports webhook-style notifications for selected events, particularly form submission events. Coverage is product- and event-specific and should not be assumed for every object.

Martini implementation pattern

Martini implementation pattern: expose a Martini API endpoint for the supported callback, validate the event and payload, acknowledge or process it according to the Formstack behavior, and invoke a workflow that retrieves the current resource when necessary.

Implementation sequence

Receive the Formstack callback
Validate the payload structure and event type
Authenticate or validate the callback according to the product documentation
Retrieve the current Submission when required
Map and process the event idempotently
Route failures for retry or controlled replay

Scheduled Formstack synchronization

Scheduled polling is a fallback or complementary mechanism for events and resources without suitable webhook coverage. Formstack collections may require pagination and controlled batching.

Martini implementation pattern

Martini implementation pattern: a scheduler starts a workflow that retrieves pages after a stored cursor or timestamp, processes each item with bounded concurrency, and updates the checkpoint only after successful downstream handling.

Implementation sequence

Start the scheduled synchronization workflow
Read the stored cursor or last-processed timestamp
Retrieve the next Formstack page
Process each item with idempotency checks
Retry transient failures with backoff
Persist the checkpoint after successful processing

Formstack file and document handling

Forms can collect uploaded files and Formstack Documents manages generated documents, but exact content, URL, metadata, and download behavior depends on the product and endpoint.

Martini implementation pattern

Martini implementation pattern: process structured submission or document data separately from binary content, retrieve or forward files only where the applicable API supports it, and apply retention and access rules before writing to a target repository.

Implementation sequence

Identify the file or generated-document reference
Confirm whether the endpoint returns content, a URL, or metadata
Retrieve supported content securely
Map document metadata and retention attributes
Write the file to the target API or storage endpoint
Persist the resulting reference and processing status

Common Formstack integration patterns

Pattern 1: Sync Formstack submissions to Salesforce

When to use this pattern

Use this pattern for lead capture, service requests, registrations, or onboarding forms that must create or update Salesforce data. Prefer a supported submission webhook and use polling when the required event is unavailable.

Integration direction
Formstack
Martini
Salesforce
Example Mapping
Formstack FieldCanonical FieldTarget Field
submission.idsourceSubmissionIdFormstack_Submission_ID__c
field.emailemailEmail
field.first_namefirstNameFirstName
field.last_namelastNameLastName
Martini implementation pattern

Martini receives or retrieves the Submission, validates required values, normalizes field names, looks up an existing Salesforce object using the stored source identifier or business key, and creates or updates the target. Transient failures are retried, while invalid submissions are routed to an exception path.

Martini capabilities used
  • workflows
  • API consumption
  • data mapping
  • business rules
  • error handling

Pattern 2: Archive submissions in a SQL database

When to use this pattern

Use this pattern when Formstack submissions must be retained for operational reporting, compliance processing, or centralized intake management.

Integration direction
Formstack
Martini
SQL database
Example Mapping
Formstack FieldCanonical FieldTarget Field
submission.idsourceSubmissionIdformstack_submission_id
form.idformIdform_id
submitted_atreceivedAtreceived_at
submission.fieldsnormalizedPayloadpayload_json
Martini implementation pattern

A webhook-triggered or scheduled Martini workflow validates the Submission, converts field values into a stable database model, and writes the payload and processing state. A unique key on the Formstack submission ID prevents duplicates, and failed items remain available for controlled replay.

Martini capabilities used
  • workflows
  • scheduled execution
  • data mapping
  • SQL database connectivity
  • idempotency
  • error handling

Pattern 3: Generate documents from NetSuite data

When to use this pattern

Use this pattern for quotes, invoices, agreements, onboarding packages, or customer letters generated from ERP data using a Formstack Documents Template.

Integration direction
NetSuite
Martini
Formstack Documents
Example Mapping
Formstack FieldCanonical FieldTarget Field
customer.idcustomerIdcustomer_id
transaction.numberdocumentNumbertransaction_number
transaction.totalamounttotal_amount
transaction.datedocumentDatedocument_date
Martini implementation pattern

Martini consumes the source transaction, validates every required merge field, maps the canonical model to the Formstack Documents Template input, and calls the document-generation API. The workflow stores the generated document reference and routes missing fields, generation delays, or retrieval failures for retry or review.

Martini capabilities used
  • API consumption
  • workflows
  • data mapping
  • validation
  • business rules
  • error handling

Pattern 4: Orchestrate Formstack Sign requests

When to use this pattern

Use this pattern when an internal application needs to prepare, submit, and reconcile electronic-signature requests through Formstack Sign, subject to the account’s available Sign API capabilities.

Integration direction
Internal application
Martini
Formstack Sign
Example Mapping
Formstack FieldCanonical FieldTarget Field
agreement.idagreementIdexternal_reference
recipient.emailrecipientEmailsigner_email
agreement.documentUrldocumentReferencedocument
signature.statussignatureStatusstatus
Martini implementation pattern

Martini maps agreement and recipient data into the applicable Sign request model, submits the request, and processes supported status notifications or scheduled checks. It updates the source application only once per signature-request identifier and preserves signed-document references for audit and retrieval.

Martini capabilities used
  • workflows
  • API consumption
  • data mapping
  • scheduled execution
  • idempotency
  • error handling

Applications commonly integrated with Formstack

Formstack can be integrated with named enterprise applications to route submissions, generate documents, archive files, coordinate signatures, and notify operational teams. Availability and exact API behavior should be confirmed for the Formstack product and account plan involved.

Application Scenario Direction Martini Pattern
Salesforce Send form submissions to Leads, Contacts, Cases, or custom objects and generate documents from Salesforce data. Formstack → Martini → Salesforce Receive a supported submission webhook or poll Submissions, validate and map fields, apply deduplication using the Formstack submission ID, and create or update Salesforce objects through its API.
HubSpot Route marketing, registration, and intake data into Contacts, Companies, or Deals. Formstack → Martini → HubSpot Normalize Formstack field values, map them to HubSpot properties, apply consent and ownership rules, and retry transient API failures without duplicating contacts.
ServiceNow Convert service, request, or onboarding submissions into ServiceNow incidents, requests, or cases. Formstack → Martini → ServiceNow Receive or retrieve the Formstack Submission, validate required fields, map the payload to ServiceNow, and store the submission identifier with the resulting ticket reference.
NetSuite Generate customer, order, invoice, or vendor documents from NetSuite data and return processing status. NetSuite → Martini → Formstack Documents Consume a NetSuite event or API response, validate required merge fields, call the Formstack Documents API, and return or persist the generated document reference.
Google Drive Archive generated documents or uploaded submission files in controlled folders. Formstack → Martini → Google Drive Retrieve file metadata or content where supported, apply retention and folder rules, and transfer the file through the respective APIs while keeping sensitive values out of logs.
Box Store generated documents, signed agreements, or submission attachments in an enterprise content repository. Formstack → Martini → Box Coordinate Formstack file retrieval with Box upload APIs, map business metadata, and record the Box item identifier alongside the Formstack document or submission ID.
DocuSign Coordinate document-generation or intake processes with an existing electronic-signature estate where the business process requires both platforms. Formstack → Martini → DocuSign Define the system of record for signing, transform document and recipient data, route requests through the applicable APIs, and reconcile completion status without duplicating signature requests.
Slack Notify operational teams about high-priority submissions, document-generation failures, or signature completions. Formstack → Martini → Slack Filter events in a Martini workflow, remove sensitive form values, format a concise notification, and send only the required status and business context to Slack.

How to build a Formstack integration in Martini

Objective

Confirm the Formstack product, API version, account plan, and authentication method before building the integration.

Instructions in Martini

  • Register or obtain the applicable Formstack application credentials
  • Configure OAuth 2.0 or the product-specific credential method
  • Store secrets in Martini environment configuration
  • Test access to the required Formstack resources

Objective

Select webhook delivery for supported events and scheduled polling for resources or events without suitable webhook coverage.

Instructions in Martini

  • Identify the exact Formstack product and event
  • Expose a Martini API for supported callbacks
  • Add a scheduler for polling workflows
  • Define the cursor, timestamp, or checkpoint strategy

Objective

Receive or retrieve Forms, Submissions, Documents, or signature-related resources using documented endpoints.

Instructions in Martini

  • Validate callback payloads before processing
  • Retrieve the current resource when the event contains only a notification
  • Handle pagination explicitly
  • Separate structured values from file metadata or binary content

Objective

Use a Martini workflow to coordinate validation, enrichment, target calls, state management, and exception routing.

Instructions in Martini

  • Create the workflow path for the selected trigger
  • Apply conditional routing for product-specific cases
  • Persist source identifiers and processing state
  • Use controlled batching and concurrency

Objective

Transform Formstack field structures into the canonical and target models while handling changing form definitions.

Instructions in Martini

  • Map stable field identifiers where available
  • Validate required values and document merge fields
  • Normalize dates, choices, files, and identifiers
  • Handle unknown fields without unnecessary failures

Objective

Create or update downstream CRM, database, storage, messaging, or signing records without duplicating work.

Instructions in Martini

  • Look up existing targets using source IDs or business keys
  • Apply business rules before writes
  • Record target references and processing status
  • Keep sensitive values out of operational logs

Common Formstack data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
FormsDefine online form fields, configuration, and submission behavior.Salesforce, HubSpot, ServiceNow, SQL databasesMartini can retrieve form metadata, use stable field identifiers where available, and version mappings when form definitions change.
SubmissionsCarry responses submitted through a Formstack form, including field values and possible uploaded-file information.Salesforce, HubSpot, ServiceNow, SQL databasesMartini can receive supported submission notifications or poll paginated results, validate fields, map values, and persist the submission ID for idempotency.
FieldsRepresent form inputs such as text, choice, date, and file-upload fields.Canonical data models, databases, CRM objectsMartini can normalize field names and values, handle unknown fields conservatively, and apply required-field validation.
DocumentsRepresent generated or managed documents in Formstack Documents.NetSuite, Salesforce, Google Drive, BoxMartini can map source data to document requests, process generated-file references, and transfer supported content or metadata.
TemplatesDefine document layout and merge fields for document generation.Salesforce, NetSuite, internal document processesMartini can validate required merge fields before calling the document-generation API and route generation failures for review or retry.
Signature requestsRepresent documents routed through Formstack Sign for electronic signing, subject to account API availability.Internal systems, Salesforce, NetSuite, DocuSignMartini can submit applicable requests, process supported status notifications or polling results, and update the source system with signed-document references.

Authentication and security considerations

Product-specific authentication

Formstack authentication varies across Forms, Documents, and Sign. OAuth 2.0 is the primary documented pattern, while additional product-specific credentials may apply.

Credential protection

  • Store client credentials, tokens, and other secrets in Martini environment secrets.
  • Do not embed credentials in workflow definitions or log sensitive form values.
  • Request only the permissions required by the relevant Formstack product and resources.

Webhook protection

Validate callback payloads and use the product’s documented verification mechanism where available. If validation is limited, protect the Martini endpoint with authentication, a secret path, source restrictions where practical, and strict payload checks.

Operational considerations for Formstack integrations

Rate limits and pagination

Use the documented rate limits for the relevant Formstack API. Limit concurrency, process collections in controlled batches, handle pagination explicitly, and retry transient 429 and 5xx responses with backoff.

Idempotency and replay

Persist stable Formstack identifiers such as Submission, Document, or signature-request IDs with processing state. This prevents duplicate writes when webhook delivery or polling repeats an item and enables controlled replay.

Schema and product boundaries

Confirm the Formstack product, API version, account plan, object coverage, and event support. Form owners may add, remove, or rename fields, so mappings should validate required values, tolerate unknown fields where possible, and be versioned when necessary.

Files and sensitive data

Define whether workflows transfer file content, download URLs, or metadata. Apply retention, encryption, access, and deletion rules, and prevent personal or sensitive form values from appearing in logs.

Why use Martini instead of scripts or point-to-point integrations?

Orchestration across systems

Martini coordinates Formstack APIs, callbacks, scheduled polling, databases, CRMs, storage systems, and messaging endpoints in maintainable workflows instead of scattering logic across scripts.

Reusable integration logic

Reusable workflows and APIs can centralize authentication, validation, mapping, business rules, idempotency, and exception handling across Forms, Documents, and Sign processes.

Operational reliability

Martini provides structured workflow execution, controlled batching, retry paths, durable processing state, and monitoring-oriented logging. This makes it easier to distinguish transient Formstack failures from invalid submissions and to replay work safely.

Controlled API access

Martini can expose a controlled REST API for internal consumers while keeping Formstack credentials, product boundaries, and downstream orchestration behind a managed integration layer.

Frequently asked questions

How can Formstack be integrated with enterprise systems?

Formstack can be integrated through its product-specific REST APIs, selected webhook-style notifications, scheduled polling, OAuth 2.0, and supported file or document endpoints. Forms, Submissions, Fields, Documents, Templates, and signature-related data can be mapped into CRMs, databases, storage platforms, and other enterprise applications.

Can Martini integrate with Formstack?

Yes. Martini can consume Formstack REST APIs, receive supported Formstack callbacks through a Martini API, run scheduled synchronization workflows, map Formstack data, and orchestrate downstream systems. The exact implementation depends on whether the solution uses Formstack Forms, Documents, or Sign.

Do I need a connector to integrate Formstack with Martini?

No. A dedicated Formstack connector is not required. Martini can use Formstack’s confirmed native integration mechanisms, including REST APIs, selected webhooks, applicable authentication methods, scheduled polling, and supported file or document endpoints.

Is there any extra Lonti cost to integrate Formstack with Martini?

Lonti does not charge an additional per-connector or per-vendor fee to integrate Formstack. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Formstack, cloud infrastructure, or other third-party systems depending on subscription, usage, and deployment model.

Which Formstack APIs and integration methods should be used?

REST APIs are the primary and recommended integration method, with product-specific coverage for Forms, Submissions, Fields, Documents, Templates, and other resources. Use selected webhooks for supported events, scheduled polling for uncovered events, and applicable file endpoints when the product and plan support them. A public GraphQL or current SOAP API was not confirmed.

Does Formstack support events or webhooks?

Formstack supports webhook-style notifications for selected events, particularly form submission events. Coverage is not universal across products or objects, so integrations should use scheduled API polling when the required event is unavailable.

How does synchronization and data mapping work?

Martini can receive or retrieve Formstack data, normalize field names and values, map it to a canonical model, and create or update downstream records. Synchronization should use pagination, a stored cursor or timestamp where applicable, and stable identifiers such as submission, document, or signature-request IDs for idempotency.

How are Formstack errors, retries, and duplicates handled?

Martini workflows can distinguish transient API failures from validation errors, retry suitable 429 and 5xx responses with backoff, and route invalid data to an exception or review path. Durable source identifiers and processing state prevent duplicate downstream writes and support controlled replay.

Related Martini documentation

APIs

Triggers

Workflows

Security

Operations

Connect Formstack with Martini

Use Martini to connect Formstack Forms, Documents, and Sign with enterprise applications through APIs, selected events, scheduled workflows, secure credentials, and governed data transformation.

EXPLORE MARTINI
BOOK A DEMO