Adobe Sign API Getting Started: Quickstart Guide (2026)

Getting started overview

Integrating with the Adobe Sign API enables developers to embed e-signature capabilities directly into their applications, automate document workflows, and manage signing processes. This guide outlines the fundamental steps required to get started: account creation, credential generation, and making a successful initial API call. The Adobe Sign API supports various use cases, from simple document signing to complex, multi-party approval workflows with compliance requirements such as HIPAA and GLBA. Developers can choose to interact with the API directly via RESTful HTTP requests or leverage one of the officially supported SDKs for Java, Python, Node.js, or C#.

The primary interaction model involves creating an agreement, defining recipients, and specifying document details, then sending it out for signature. Status updates are managed through webhooks or API polling. Access to the API is managed through OAuth 2.0 credentials, which are obtained through the Adobe Developer Console. This approach secures API access and ensures that only authorized applications can initiate signing processes or retrieve document information.

Create an account and get keys

Before making any API calls, you need an Adobe Developer account and an application registered within the Adobe Developer Console to obtain your API credentials. These credentials, typically a Client ID and Client Secret, authenticate your application with the Adobe Sign API.

Step-by-step account and key creation:

1. Sign Up for Adobe Developer Account: Navigate to the Adobe Developer website and sign up for an account. If you already have an Adobe ID, you can use that to log in.
2. Access the Adobe Developer Console: Once logged in, go to the Adobe Developer Console. This is your central hub for managing Adobe API integrations.
3. Create a New Project: In the console, click on "Create new project." A project acts as a container for your applications and services.
4. Add an API to Your Project: Within your new project, click "Add API." Search for "Adobe Sign" or "Document Cloud API" and select it. Follow the prompts to configure the API credentials.
5. Choose Authentication Method: For most initial integrations, select "OAuth Server-to-Server" for applications that operate without direct user interaction, or "OAuth (Web/Single Page/Native App)" if your application requires a user to log in and grant consent. The server-to-server method is often preferred for backend services.
6. Generate Credentials: After configuring the API, the console will provide you with a Client ID (API Key) and a Client Secret. It is crucial to save your Client Secret securely, as it is displayed only once.
7. Configure Redirect URI (if applicable): If you chose a user-based OAuth flow, you will need to specify one or more Redirect URIs. These are the URLs where Adobe Sign redirects the user after authentication, so your application can receive the authorization code.
8. Enable Required Scopes: During API configuration, you will select various "scopes" that define the permissions your application will have. For sending agreements, common scopes include agreement_send and agreement_write. For administrative tasks, scopes like user_write might be needed. Ensure you select only the scopes your application requires.

After completing these steps, you will have the necessary Client ID and Client Secret to begin authenticating your API requests.

Your first request

The first step in making an API request is obtaining an access token using your Client ID and Client Secret. This token is then included in the authorization header of subsequent API calls. The Adobe Sign API uses OAuth 2.0 for authentication.

1. Obtain an Access Token

To get an access token for a server-to-server integration, make a POST request to the token endpoint:

curl -X POST "https://api.echosign.com/oauth/v2/token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=client_credentials" \
  -d "client_id=YOUR_CLIENT_ID" \
  -d "client_secret=YOUR_CLIENT_SECRET"

Replace YOUR_CLIENT_ID and YOUR_CLIENT_SECRET with your actual credentials. The response will contain an access_token and an expires_in value, indicating how long the token is valid.

{
  "access_token": "YOUR_ACCESS_TOKEN",
  "token_type": "Bearer",
  "expires_in": 3600,
  "scope": "agreement_send agreement_write"
}

2. Upload a Transient Document

Before sending an agreement, you first need to upload the document to Adobe Sign as a "transient document." This temporarily stores the file on Adobe's servers, returning a transientDocumentId that you'll use to create an agreement.

curl -X POST "https://api.echosign.com/api/rest/v6/transientDocuments" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Content-Type: multipart/form-data" \
  -F "file=@/path/to/your/document.pdf" \
  -F "fileName=document.pdf" \
  -F "mimeType=application/pdf"

Replace YOUR_ACCESS_TOKEN and /path/to/your/document.pdf with your token and the actual path to your PDF document. The response will provide a transientDocumentId:

{
  "transientDocumentId": "3AAABLblqZhA-1Lp0fC-L3lIAD5V8S64-3xV2f0z"
}

3. Create and Send an Agreement

With the transientDocumentId, you can now create and send an agreement for signature. This involves specifying the document, recipients, and the signing workflow.

curl -X POST "https://api.echosign.com/api/rest/v6/agreements" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "documentCreationInfo": {
      "fileInfos": [ {
        "transientDocumentId": "YOUR_TRANSIENT_DOCUMENT_ID"
      } ],
      "name": "My First Agreement",
      "recipientSetInfos": [ {
        "recipientSetRole": "SIGNER",
        "memberInfos": [ {
          "email": "[email protected]"
        } ]
      } ],
      "signatureType": "ESIGN",
      "state": "IN_PROCESS",
      "signatureFlow": "WORKFLOW",
      "ccs": [],
      "mergeFieldInfos": [],
      "postSignOptions": null,
      "locale": "en_US"
    }
  }'

Replace YOUR_ACCESS_TOKEN and YOUR_TRANSIENT_DOCUMENT_ID with your data, and set [email protected] to the actual email address of the signer. The response will contain the agreementId:

{
  "id": "3AAABLblqZhA-2Lp0fC-L3lIAD5V8S64-4xV2f0z",
  "embeddedCode": "YOUR_EMBEDDED_CODE"
}

This agreementId uniquely identifies the agreement and can be used to track its status or manage its lifecycle.

Common next steps

After successfully sending your first agreement, you can explore more advanced features and integrations:

• Document Management: Use API calls to retrieve signed documents, audit trails, and manage document libraries. The Adobe Sign API reference details endpoints for these operations.
• Webhooks for Status Updates: Implement webhooks to receive real-time notifications about agreement status changes (e.g., signed, declined, expired) instead of polling the API. This is more efficient for high-volume workflows.
• Embedded Signing: Integrate the signing process directly into your application's user interface using embedded signing URLs, providing a seamless user experience.
• Form Fields and Templates: Define form fields programmatically or use pre-configured templates in Adobe Sign to streamline document preparation and ensure consistent signing experiences.
• Error Handling and Logging: Implement robust error handling and logging mechanisms to diagnose issues and ensure the reliability of your integration.
• SDK Utilization: For a more abstracted and integrated development experience, consider using one of the official Adobe Sign SDKs (Java, Python, Node.js, C#). These SDKs handle much of the underlying HTTP request and JSON parsing logic.

Troubleshooting the first call

When making your first API calls, you might encounter various issues. Here are common problems and their solutions:

• Invalid Access Token (401 Unauthorized):
  • Issue: Your access token is expired, invalid, or missing from the Authorization header.
  • Solution: Regenerate a new access token using your Client ID and Client Secret. Ensure the token is correctly prefixed with Bearer in the Authorization header (e.g., Authorization: Bearer YOUR_ACCESS_TOKEN).
• Missing or Incorrect Scopes (403 Forbidden):
  • Issue: Your application does not have the necessary permissions (scopes) to perform the requested action.
  • Solution: Review the required scopes for the API endpoint you are calling in the Adobe Sign API reference. Go to the Adobe Developer Console, navigate to your project, select the Adobe Sign API, and ensure all necessary scopes are enabled.
• Invalid Request Body (400 Bad Request):
  • Issue: The JSON payload or form data in your request is malformed, missing required fields, or contains invalid values.
  • Solution: Carefully check the API documentation for the specific endpoint you are calling to ensure your request body matches the expected schema. Use a JSON validator to confirm syntax. Pay attention to required fields like name, recipientSetInfos, and fileInfos when creating an agreement.
• Incorrect Endpoint URL:
  • Issue: You are using an incorrect base URL or endpoint path.
  • Solution: Verify the API endpoint against the official Adobe Sign API documentation. Ensure you are using the correct domain (e.g., api.echosign.com) and version (e.g., /api/rest/v6/).
• File Upload Issues (Transient Document):
  • Issue: Problems uploading the document, such as incorrect Content-Type, file path, or mime type.
  • Solution: For file uploads, ensure you use Content-Type: multipart/form-data. Double-check that the file path in your curl -F "file=@/path/to/your/document.pdf" command is correct and accessible. Confirm the mimeType is accurate for the file type being uploaded (e.g., application/pdf).
• Network or Firewall Restrictions:
  • Issue: Your environment might be blocking outgoing requests to Adobe Sign API endpoints.
  • Solution: Check your local network, firewall, or proxy settings to ensure that connections to api.echosign.com and related Adobe domains are allowed.