.png)
Conga Composer Integration Guide
Conga Composer integrates with Salesforce, Microsoft Dynamics 365, and enterprise document workflows through APIs, host-platform data access, and document delivery mechanisms.
Conga Composer integration options at a glance
Conga Composer integrations typically use documented Conga or host-platform REST APIs to retrieve source data, initiate Composer Requests, and process generation results. Salesforce REST APIs are important for Salesforce deployments, while Microsoft Dynamics 365 Web API can provide Dataverse data for Dynamics deployments. Composer may generate files synchronously or asynchronously, and deployment-specific callbacks or status mechanisms should be verified rather than assumed. Generated documents can be attached, stored, emailed, or forwarded through configured destinations. Martini can securely manage authentication, orchestrate calls, map merge parameters, poll request status, process files, and route outputs to downstream systems.
| Integration point | Supported by Conga Composer? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Limited | Documented Conga or host-platform REST APIs may start Composer Requests, provide solution or template metadata, retrieve source data, and return generation status or results. Applicable endpoints vary by edition. | Martini can consume REST APIs, manage authentication, map request and response data, orchestrate dependent calls, and expose a controlled API for internal document-generation requests. |
| Salesforce REST APIs | Yes | Salesforce deployments can retrieve Accounts, Contacts, Opportunities, Quotes, line items, custom objects, and related data used by Composer merges. | Martini can query Salesforce, follow pagination, transform source records into Composer parameters, and write generated-document metadata or attachments back through the API. |
| Microsoft Dynamics 365 Web API | Yes | Dynamics deployments can retrieve Dataverse tables such as Accounts, Quotes, and Opportunities and use them as Composer source data. | Martini can consume the Web API, map Dataverse fields and relationships, invoke the applicable Composer process, and process output references or statuses. |
| Webhooks / outbound callbacks | Limited | Some deployment-specific status or notification mechanisms may exist, but broad coverage for Composer generation, delivery, and template events was not confirmed. | Martini can receive a documented callback when the selected deployment supports one; otherwise, a workflow can poll a status endpoint or query the source platform. |
| Bulk / async / batch APIs | Limited | Large or complex document generation may be asynchronous, with a request or job identifier and later status retrieval. A generally available bulk Composer API was not confirmed. | Martini can store correlation identifiers, poll with bounded intervals, apply timeout and retry rules, and separate interactive requests from batch workflows. |
| File / attachment APIs | Limited | Composer generates documents that may be returned, attached to business records, stored in a repository, emailed, or passed to another product. Exact endpoints depend on the edition and destination. | Martini can process binary content, encoded documents, download references, and attachment metadata before forwarding files to supported APIs or destinations. |
| Authentication | Limited | Authentication may rely on Salesforce or Dynamics authorization, OAuth 2.0, API credentials, client IDs, secrets, or bearer tokens depending on the deployment. | Martini can store credentials in environment secrets and apply configured authentication to API calls without embedding secrets in workflows. |
| GraphQL APIs | Not confirmed | No current Conga Composer GraphQL interface was verified; REST and host-platform APIs remain the preferred integration paths. | Martini supports GraphQL consumption generally, but this mechanism should not be selected for Conga Composer without product-specific confirmation. |
| SOAP APIs | Not confirmed | No current Conga Composer SOAP interface was verified in the supplied research. | Martini supports SOAP consumption generally, but no Conga Composer SOAP integration should be assumed. |
How Conga Composer exposes data and business events
Conga Composer REST APIs
Conga Composer and its host platforms expose API-based integration capabilities, but the applicable endpoints, objects, authentication, and output handling depend on the product edition. Salesforce REST APIs and Microsoft Dynamics 365 Web API are important source-data paths.
Martini implementation pattern
Martini implementation pattern: Martini receives a document-generation request or starts from a source-system trigger, retrieves the required business data, maps it into the documented Composer request, invokes the applicable endpoint, and processes the returned file, status, or request identifier.
Implementation sequence
Conga Composer callbacks
Some Conga deployments may provide status or notification callbacks, but comprehensive webhook coverage for Composer generation, delivery, and template events was not confirmed. Availability must be verified for the selected edition.
Martini implementation pattern
Martini implementation pattern: where a documented callback exists, Martini exposes a controlled receiving API or workflow trigger, validates the notification, correlates it to the Composer Request, and retrieves the authoritative status or file rather than assuming the callback contains the complete result.
Implementation sequence
Asynchronous Composer generation
Large documents, complex queries, and batch-like processing may complete asynchronously. A generally available bulk Composer API was not confirmed, so the selected endpoint must be checked for job identifiers and status operations.
Martini implementation pattern
Martini implementation pattern: Martini stores a correlation ID and request identifier, then uses bounded polling or a documented callback to determine completion. It applies backoff, timeout, duplicate detection, and operational routing before forwarding the final file.
Implementation sequence
File and attachment delivery
Composer generates documents that may be returned as binary content, base64 data, a download URL, or an attachment reference. Outputs may be attached to business records, stored, emailed, or passed to another product depending on deployment.
Martini implementation pattern
Martini implementation pattern: Martini normalizes the available output representation, validates size and authorization requirements, applies naming and destination rules, and forwards the document to a repository, signing platform, or host-system record.
Implementation sequence
Common Conga Composer integration patterns
Pattern 1: Generate quotes and proposals from Salesforce
When to use this pattern
Use this pattern when an approved Salesforce Opportunity or Quote should produce a proposal, quote, or related customer document. It is suitable for interactive requests exposed through an internal API or for workflows started by a source-system event or schedule.
Integration direction
Example Mapping
| Conga Composer Field | Canonical Field | Target Field |
|---|---|---|
| Quote.Id | sourceTransactionId | Composer Request source record ID |
| Account.Name | customerName | Account merge field |
| Opportunity.Amount | commercialValue | Proposal amount |
| Quote.LineItems | lineItems | Line-item merge data |
Martini implementation pattern
Martini retrieves the Account, Contact, Opportunity, Quote, and line-item data, validates required fields, and constructs the Composer Request. After generation, it retrieves or downloads the document, applies a duplicate check using the source record and document type, and writes the output reference or attachment metadata back to Salesforce. Authentication failures, missing templates, merge errors, timeouts, and duplicate outputs are handled separately.
Martini capabilities used
- APIs
- workflows
- data mapping
- business rules
- file handling
- error handling
Pattern 2: Send generated contracts for signature
When to use this pattern
Use this pattern when an approved Salesforce or Dynamics transaction should generate a contract and route it to DocuSign or Adobe Acrobat Sign. The signing step depends on the selected product and its API rather than being inherently provided by Composer.
Integration direction
Example Mapping
| Conga Composer Field | Canonical Field | Target Field |
|---|---|---|
| Opportunity or Quote.Id | transactionId | Composer source ID |
| Contact.Email | signerEmail | Signature recipient email |
| Quote.Total | contractValue | Contract merge field |
| Generated document | contractFile | Envelope or agreement document |
Martini implementation pattern
A Martini workflow checks approval status, retrieves source data, invokes the configured Composer Solution, and waits for a completed document when generation is asynchronous. It then submits the file and signer details to the selected signing API, stores both correlation identifiers, and maps signature status back to the source CRM. Retries are bounded to avoid duplicate envelopes.
Martini capabilities used
- workflow orchestration
- API consumption
- data mapping
- validation
- business rules
- retry and error handling
Pattern 3: Synchronize generated-document metadata
When to use this pattern
Use this pattern when downstream systems need document names, source record IDs, timestamps, statuses, storage locations, or request identifiers without necessarily copying the document contents.
Integration direction
Example Mapping
| Conga Composer Field | Canonical Field | Target Field |
|---|---|---|
| Composer Request ID | generationRequestId | External request key |
| Source record ID | sourceTransactionId | CRM reference |
| Document status | documentStatus | Repository processing status |
| Output location | documentUri | Repository URL |
Martini implementation pattern
Martini periodically queries the documented source, status endpoint, or configured repository, follows pagination or continuation mechanisms, and maps document metadata to the destination model. It uses the request ID, document ID, or maintained integration key to prevent duplicate updates, and routes unavailable outputs or inconsistent statuses for review.
Martini capabilities used
- scheduled workflows
- API consumption
- pagination handling
- mapping
- idempotency rules
- monitoring
Pattern 4: Generate customer documents from Dynamics 365
When to use this pattern
Use this pattern for Dynamics 365 deployments where Account, Quote, or Opportunity changes should initiate a proposal, quote, or contract generation process and attach or deliver the result.
Integration direction
Example Mapping
| Conga Composer Field | Canonical Field | Target Field |
|---|---|---|
| Dataverse Account.Id | customerId | Composer source identifier |
| Dataverse Quote.Id | quoteId | Composer Request source record ID |
| Dataverse Quote.TotalAmount | quotedAmount | Quote merge field |
| Generated file reference | documentReference | Dynamics attachment or document location |
Martini implementation pattern
Martini consumes the Dynamics 365 Web API, validates the Dataverse relationships and required merge fields, invokes the applicable Composer process, and tracks request and output status. Once complete, it attaches or forwards the document and records the result. Timeout, authorization, unavailable template, and duplicate-request paths are handled explicitly.
Martini capabilities used
- API consumption
- workflow triggers
- data transformation
- validation
- file handling
- error handling
Applications commonly integrated with Conga Composer
Conga Composer is commonly used with CRM platforms and downstream signing, storage, and business applications. Martini can coordinate these systems while keeping deployment-specific credentials, mappings, document identifiers, and error handling in reusable workflows.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Salesforce supplies Accounts, Contacts, Opportunities, Quotes, custom objects, and related data for Composer merges, while generated documents may be attached to Salesforce records. | Salesforce → Martini → Conga Composer | Martini retrieves the required Salesforce data, validates source records, constructs the Composer request, processes the generated file or status, and writes document metadata or attachments back through documented APIs. |
| Microsoft Dynamics 365 | Dynamics 365 can provide Account, Quote, Opportunity, and Dataverse data for proposals, contracts, and customer documents in Composer deployments configured for Dynamics. | Microsoft Dynamics 365 → Martini → Conga Composer | A Martini workflow consumes the Dynamics 365 Web API, maps Dataverse data into the applicable Composer request, handles asynchronous status where required, and attaches or forwards the result. |
| DocuSign | Generated contracts, proposals, or order documents can be sent into electronic-signature workflows after Composer generation. | Conga Composer → Martini → DocuSign | Martini retrieves or receives the generated document, validates its business context, submits it to the DocuSign API, and maps envelope status back to Salesforce or Dynamics where supported. |
| Adobe Acrobat Sign | Composer-generated documents can be routed to Adobe Acrobat Sign for signature and subsequent status tracking. | Conga Composer → Martini → Adobe Acrobat Sign | Martini transforms the generated file and signer data into the Adobe Acrobat Sign request, stores correlation identifiers, and processes status updates through the available API mechanisms. |
| Box | Generated proposals, contracts, and customer documents can be stored in controlled Box folders with associated business metadata. | Conga Composer → Martini → Box | Martini downloads or accesses the Composer output, applies folder and naming rules, uploads the file to Box, and records the resulting document identifier against the source transaction. |
| Microsoft SharePoint | SharePoint document libraries can provide an organizational destination for generated proposals, contracts, and customer documents. | Conga Composer → Martini → Microsoft SharePoint | A Martini workflow sends the generated file to the appropriate SharePoint location, applies metadata, and optionally publishes the storage reference back to the source CRM. |
| NetSuite | Generated sales or contract documents may participate in broader order, billing, or ERP processes, although a native Conga relationship should be confirmed for each deployment. | Salesforce → Martini → Conga Composer → NetSuite | Martini coordinates source CRM data, Composer generation, and downstream NetSuite API calls, using transaction identifiers and idempotency checks to prevent duplicate document or ERP updates. |
How to build a Conga Composer integration in Martini
Objective
Confirm whether the integration calls Conga directly or invokes Composer through Salesforce or Microsoft Dynamics 365, then configure the appropriate endpoint, identity, permissions, and environment secrets.
Instructions in Martini
- Identify the Conga Composer edition and host platform.
- Confirm API endpoints, scopes, credentials, and output behavior.
- Store client secrets, tokens, and deployment identifiers as Martini environment secrets.
- Verify access to source records, Solutions, Templates, Queries, and output locations.
Objective
Select the initiation model that matches the business process, such as a Martini API request, source-platform event, documented callback, or scheduled synchronization.
Instructions in Martini
- Use an API trigger for interactive document-generation requests.
- Use a documented callback only when the deployment explicitly supports it.
- Use a scheduler for status polling or metadata synchronization.
- Define correlation and idempotency keys before enabling retries.
Objective
Obtain the Salesforce or Dynamics data required by the Composer Solution and verify that the integration identity can access all related records and fields.
Instructions in Martini
- Retrieve Accounts, Contacts, Opportunities, Quotes, line items, or Dataverse tables as required.
- Follow pagination or continuation mechanisms.
- Avoid unnecessary related-record retrieval.
- Preserve source identifiers and response metadata for traceability.
Objective
Build the Martini workflow that validates the request, invokes Composer, tracks synchronous or asynchronous execution, and coordinates downstream processing.
Instructions in Martini
- Validate required source IDs, document type, and business status.
- Construct the Composer Request from mapped source data.
- Store request and correlation identifiers.
- Poll a documented status operation or process a supported callback when generation is asynchronous.
Objective
Create stable mappings between source-platform fields, Conga merge parameters, generated-file metadata, and downstream application models.
Instructions in Martini
- Map source fields to the Composer request structure.
- Normalize names, addresses, dates, amounts, and signer details.
- Apply template-specific and document-type-specific transformations.
- Treat template, Solution, and Query identifiers as versioned configuration.
Objective
Control when documents may be generated, where they may be delivered, and whether a retry could create a duplicate document or signature envelope.
Instructions in Martini
- Check approval and transaction status before generation.
- Validate required merge fields and signer information.
- Use source transaction, document type, and version as an idempotency key.
- Route missing templates, permission failures, and merge errors to operational handling.
Common Conga Composer data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Composer Solutions | Configured actions that define templates, data sources, output settings, and delivery behavior. | Salesforce, Microsoft Dynamics 365, document repositories, signing platforms | Martini stores solution identifiers in environment configuration, validates that the solution is available, and supplies it when constructing a Composer Request. |
| Conga Templates | Word, Excel, PowerPoint, PDF, or other supported templates used to generate business documents. | Salesforce, Microsoft Dynamics 365, Box, SharePoint, DocuSign, Adobe Acrobat Sign | Martini treats template identifiers and versions as controlled integration configuration and routes template-related errors for operational review. |
| Conga Queries | Queries that retrieve and shape related data for a Composer merge. | Salesforce, Microsoft Dynamics 365, Composer Solutions | Martini supplies validated source identifiers and records query or merge failures with the request correlation ID. |
| Composer Requests | Requests or execution parameters that initiate document generation. | Conga Composer, Salesforce, Microsoft Dynamics 365, monitoring stores | Martini validates input, maps record IDs and merge parameters, stores request identifiers, and tracks synchronous or asynchronous status. |
| Salesforce Accounts | Organization or customer information merged into proposals, quotes, contracts, and correspondence. | Conga Composer, Salesforce, document repositories, signing platforms | Martini retrieves permitted fields through Salesforce APIs and maps them to the Composer request or an internal canonical document model. |
| Salesforce Contacts | Names, addresses, roles, and signer information included in generated documents. | Conga Composer, Salesforce, DocuSign, Adobe Acrobat Sign | Martini validates contact and signer data, applies business rules, and maps it to Composer or downstream signature requests. |
Authentication and security considerations
Deployment-specific authentication
Authentication depends on whether Martini calls Conga directly or invokes Composer through Salesforce or Microsoft Dynamics 365. Salesforce permissions, sharing rules, Dynamics identity configuration, OAuth 2.0, client credentials, or bearer tokens may apply.
Least-privilege access
Integration identities should have only the permissions required for source Accounts, Contacts, Opportunities, Quotes, custom objects, Composer Solutions, Templates, Queries, generated files, and destination records.
Secret management
Store client IDs, secrets, tokens, endpoint configuration, and deployment-specific identifiers in Martini environment secrets. Do not embed credentials in workflow mappings or request payloads.
Document protection
Generated documents and download references may contain sensitive commercial or personal information. Validate authorization, protect temporary files and URLs, and apply the destination system's access controls.
Operational considerations for Conga Composer integrations
Rate limits and pagination
Salesforce, Dynamics, Conga, signing, and storage APIs may impose different quotas. Follow pagination or continuation tokens, retrieve only required data, and apply backoff for throttling responses.
Asynchronous generation
Large or complex documents may require polling. Store request and correlation identifiers, use bounded intervals and timeouts, and distinguish incomplete, failed, and completed generation states.
Idempotency
Document generation and signature submission may not be idempotent. Use source record ID, document type, transaction version, and external request ID to detect duplicates before retrying.
Templates and schema changes
Treat Conga Templates, Solutions, and Queries as controlled integration assets. Changes to merge fields, relationship paths, API versions, or output behavior should be tested before deployment.
Testing and monitoring
Test permission failures, missing templates, merge errors, unsupported formats, expired download URLs, timeouts, and downstream failures. Retain request IDs, source IDs, statuses, and error responses for troubleshooting.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration across systems
Point-to-point scripts often combine source retrieval, document generation, file handling, signing, and repository delivery in one fragile process. Martini separates these concerns into maintainable workflows and reusable API interactions.
Controlled transformation
Martini provides explicit mapping, validation, enrichment, and business-rule steps between Salesforce or Dynamics data, Composer requests, generated files, and downstream applications.
Reliable operations
Workflows can model asynchronous generation, polling, retries, timeouts, idempotency, and operational routing instead of treating every document request as a single synchronous call.
API-led reuse
Martini can expose a controlled document-generation API for internal applications while centralizing authentication, environment configuration, logging, and error handling.
Frequently asked questions
Conga Composer can be integrated through documented Conga or host-platform REST APIs, Salesforce REST APIs for Salesforce deployments, and Microsoft Dynamics 365 Web API for Dynamics deployments. Integrations can retrieve source data, initiate Composer Requests, process synchronous or asynchronous results, and deliver generated documents to records, repositories, email, or downstream signing systems where supported.
Yes. Martini can integrate with Conga Composer by consuming documented Conga, Salesforce, or Microsoft Dynamics APIs, managing authentication, mapping source data into Composer requests, tracking generation status, and processing generated files. A Martini native Conga Composer connector is not documented in the supplied research.
No. A dedicated Conga Composer connector is not required. Martini can use Conga's confirmed native integration mechanisms, including applicable REST APIs, Salesforce or Dynamics platform APIs, documented callbacks where available, authentication methods, and file or attachment endpoints.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Conga Composer. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Conga, Salesforce, Microsoft, storage or signing providers, infrastructure, or other third parties.
REST APIs and the API of the host business platform should be treated as the preferred paths. Salesforce REST APIs are relevant for Salesforce deployments, and Microsoft Dynamics 365 Web API is relevant for Dynamics deployments. File or attachment mechanisms can process generated outputs. GraphQL and SOAP interfaces were not confirmed for current Conga Composer use.
Some deployment-specific status or notification callbacks may exist, but comprehensive webhook coverage for all Composer events was not confirmed. Martini can receive a documented callback when available; otherwise, it can poll a documented status operation or query the source platform.
Martini can use API-driven, event-driven where explicitly supported, or scheduled workflows. It retrieves source data, submits or monitors Composer Requests, processes generated files or metadata, and uses request IDs, document IDs, source identifiers, or integration keys to prevent duplicate updates.
Martini maps source records into Composer request structures and downstream models, applies validation and business rules, and records correlation identifiers. Workflows can distinguish authentication, permission, template, merge, timeout, storage, and downstream errors. Bounded retries, backoff, status checks, and idempotency keys help avoid duplicate documents or signature envelopes.
Related Martini documentation
Workflows
Build your Conga Composer integration with Martini
Use Martini to connect Conga Composer with Salesforce, Microsoft Dynamics 365, signing platforms, repositories, and other enterprise systems through secure APIs and maintainable workflows.