Login

API Docs

API Documentation

Partner API

This document outlines the Lonewolf’s Inkless API for Partners to integrate.

Base url: https://api.inklesshub.com/

Authorization

Using JWT Bearer Token

1. Generating Access Token

The first step to getting the access token requires an invitation to Inkless. Once invited, navigate to the user icon in the upper right, click Settings.

from within settings, scrolling to the bottom will provide an option to generate a token. Click this, and copy your token.

Warning: This is an account specific token that is long living. If you generate a new token it will break any integrations you have created with the previous token.

2. Decoding the externalId

All API requests have a required header of externalId. To get this external ID, first navigate to [jwt.io/](https://jwt.io/) to begin the decoding process.

With the token generated in the previous step, paste into the dialog to the left, and take note of the actort field. This is your externalId.

3. Using the JWT Token

Now that you have both your token and the externalId, you will need to pass both in the header for all requests.

Obtaining and using the actort programatically

Alternatively, you can extract the actort value directly from the JWT token programatically.
To do this,

Header Name Value Description
Authorization Bearer token The JWT Token generated in step 1
externalId externalId obtained from step 2

Branding and White Labeling Setup

To customize the signer experience with your brand, follow these steps:

1. Access Branding Settings

Click the user icon in the upper-right corner of the Inkless dashboard, then select Settings from the dropdown menu.

2. Upload Your Brand Assets

Scroll down to the Branding and White Labeling section. Here, you can upload logos for three distinct areas:

  • Email Banner Logo – This logo will brand the top of the Signing Invitation Email that users receive to enter the signing experience.
  • Signer Viewport Logo – This logo will be placed at the top of the portal where the user interacts to sign their documents.
  • Signing Completion Page Logo – This logo will be the header for the success page that a user is taken to after they complete a signing.

All logo uploads should be in a landscape orientation and will be set against a white background. After each upload, you’ll be prompted to resize and crop the image to best fit the target display area.

3. Preview and Save

Once your logos are uploaded and adjusted, they will automatically apply across the Inkless signer interface, replacing the default Inkless branding. Your customers will experience a fully white-labeled flow from start to finish.

Note: These settings apply globally to your account and will reflect across all signings created via the API.

CCs

This section describes pulling the CCs associated with a provided signing ID and how to add multiple CCs at once for efficient processing.

Get CCs [/api/v1/signings/{signingId}/ccs]

This endpoint will get fetch CCs associated with the provided signingId.

Get CCs [GET /api/v1/signings/{signingId}/ccs] 

curl -X GET "/api/v1/signings/{signingId}/ccs" \
-H "Accept: application/json" \
-H "Authorization: Bearer <access_token>" \
-H "externalId: <your_external_id>"
Response 200 (application/json)
			{        
        "message": "Success"    
    }
Response 400 (application/json)
			{
        "code": 400,
        "message": "BadRequest",
        "details": {
            "signingId": [
                "The value <signing id> is not valid."
            ]
        }
    }

Add CCs in batch [/api/v1/ccs/batch]

You can use this endpoint to add one or many CCs to a signing. The parameters to include in the post request are listed below:

Parameter Description
id The Unique ID (GUID) of the CC you wish to add
signingId The specific signing ID you wish to add someone.
firstName The first name of the recipient
middleName The middle name of the recipient
lastName The last name of the recipient
email the email address of the recipient
displayOrder The order in which the recipient will be displayed (Default is 0)
externalId Optional string. Can be null
transactionId Optional, the unique GUID of the transaction. Can be null
saveToContacts Boolean

Note: These must be passed as an array of the CC object in request body, for example: 

[
    {
        "id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
        "signingId": "12345678-1234-1234-1234-123456789012",
        "firstName": "John",
        "middleName": "D",
        "lastName": "Doe",
        "email": "john.doe@example.com",
        "displayOrder": 1,
        "externalId": "EXT1234",
        "transactionId": "9b74f03d-71d4-4911-a0d4-60c720bacea1",
        "saveToContacts": true
    },
    ... {more CCs}
]

Add CCs in Batch [POST /api/v1/ccs/batch] 

curl -X POST "/api/v1/ccs/batch" \
-H "Accept: application/json" \
-H "Authorization: Bearer access_token" \
-H "externalId: Your_External_Id" \
-H "Content-Type: application/json" \
-d '[
    {
        "id": "405355ec-7f5d-423e-416a-4567ea0632d1",
        "signingId": "805355ec-7f7d-413e-986a-c767ea0632da",
        "firstName": "Pat",
        "middleName": "Dee",
        "lastName": "Cake",
        "email": "PatDCake@lwolf.com",
        "displayOrder": 0,
        "externalId": "SomeExternalTag",
        "transactionId": "a4158891-3c20-4208-b3c0-3929ed0bdcb1",
        "saveToContacts": false
    }
]'
Response 200 (application/json)
{
    "message": "Success"
}
Response 400 (application/json)
{
    "type": "string",
    "title": "string",
    "status": 0,
    "detail": "string",
    "instance": "string",
    "additionalProp1": "string",
    "additionalProp2": "string",
    "additionalProp3": "string"
}
Response 404 (application/json)
{
    "type": "string",
    "title": "string",
    "status": 0,
    "detail": "string",
    "instance": "string",
    "additionalProp1": "string",
    "additionalProp2": "string",
    "additionalProp3": "string"
}

Deleted Signings

This section describes how to delete a signing, see previously deleted signings, and restore a deleted signing.

Delete Signing [/api/v1/signings/{signingId}]

This endpoint will delete the specified signingId.

Delete Signing [DELETE /api/v1/signings/{signingId}] 

curl -X DELETE "/api/v1/signings/{signingId}" \
-H "Accept: application/json" \
-H "Authorization: Bearer access_token"
+ Response 200 (application/json)
{
    "code": 0,
    "message": "string",
    "details": [
        "string"
    ]
}
+ Response 400 (application/json)
{
    "code": 0,
    "message": "string",
    "details": [
        "string"
    ]
}

Get Deleted Signings [/api/v1/signings/deleted]

This endpoint will retrieve a list of previously deleted signings.

Get Deleted Signings [GET /api/v1/signings/deleted] 

curl -X GET "https://api.example.com/api/v1/signings/deleted" \
  -H "Authorization: Bearer <your_token>" \
  -H "externalId: <your_external_id>" \
  -H "Content-Type: application/json"
+ Response 200 (application/json)
{
  "message": "Success"
}
+ Response 404 (application/json)
{
  "code": 0,
  "message": "string",
  "details": [
    "string"
  ]
}
+ Response 400 (application/json)
{
  "type": "string",
  "title": "string",
  "status": 0,
  "detail": "string",
  "instance": "string",
  "additionalProp1": "string",
  "additionalProp2": "string",
  "additionalProp3": "string"
}

Recover Deleted Signing [/api/v1/signings/{signingId}/recover-deleted]

This endpoint will restore a previously deleted signingId.

Recover Delete Signing [PUT /api/v1/signings/{signingId}/recover-deleted] 

curl -X PUT "/api/v1/signings/{signingId}/recover-deleted"
Response 200 (application/json)
{
  "message": "Success"
}
Response 401 (application/json)
{
  "code": 0,
  "message": "string",
  "details": [
    "string"
  ]
}
Response 404 (application/json)
{
  "code": 0,
  "message": "string",
  "details": [
    "string"
  ]
}
Response 400 (application/json)
{
  "type": "string",
  "title": "string",
  "status": 0,
  "detail": "string",
  "instance": "string",
  "additionalProp1": "string",
  "additionalProp2": "string",
  "additionalProp3": "string"
}

Layouts

Get Layouts [/api/v1/layouts/?language={LayoutLanguage}]

This endpoint will get all layouts associated with the account based on the specified LayoutLanguage. Denoted by the two letter representation.

Get Layouts [GET /api/v1/layouts/?language={LayoutLanguage}] 

curl -X GET "/api/v1/layouts/?language=EN" \
  -H "Content-Type: application/json" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)

{
  "message": "Success"
}
Response 400 (application/json)

{
  "code": 0,
  "message": "string",
  "details": [
    "string"
  ]
}

Create a New Layout [/api/v1/layouts]

This endpoint will create a new layout. Requires a name tag in the body of the request.

Create a New Layout [POST /api/v1/layouts] 

curl -X POST "/api/v1/layouts" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>" \
  -d '{
    "name": "New Layout"
  }'
Response 200 (application/json)
"<New Layout Guid Generated>"
Response 400 (application/json)
{
  "code": 0,
  "message": "string",
  "details": [
    "string"
  ]
}

Copy an Existing Layout [/api/v1/layouts/{LayoutId}/copy]

This endpoint will make a copy of the layout associated with the provided LayoutId.

Copy an Existing Layout [POST /api/v1/layouts/{LayoutId}/copy] 

curl -X POST "/api/v1/layouts/{LayoutId}/copy" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "message": "Success"
}
Response 400 (application/json)
{
  "code": 0,
  "message": "string",
  "details": [
    "string"
  ]
}

Delete a specific Layout [/api/v1/layouts/{LayoutId}]

This endpoint will delete the layout associated with the provided LayoutId.

Delete a Specific Layout [DELETE /api/v1/layouts/{LayoutId}] 

curl -X DELETE "/api/v1/layouts/{LayoutId}" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "message": "Success"
}
Response 400 (application/json)
{
  "code": 0,
  "message": "string",
  "details": [
    "string"
  ]
}

Signing Actions

Send Signing [/api/v1/signings/{signingId}/send-signing]

This endpoint will send the signing session to added participants. This endpoint starts the signing process for a signing session based on the provided signingId.

Send Signing [POST /api/v1/signings/{signingId}/send-signing] 

curl -X POST "/api/v1/signings/{signingId}/send-signing" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "message": "Success"
}
Response 400 (application/json)
{
  "type": "string",
  "title": "string",
  "status": 0,
  "detail": "string",
  "instance": "string",
  "additionalProp1": "string",
  "additionalProp2": "string",
  "additionalProp3": "string"
}
Response 401 (application/json)
{
  "type": "string",
  "title": "string",
  "status": 0,
  "detail": "string",
  "instance": "string",
  "additionalProp1": "string",
  "additionalProp2": "string",
  "additionalProp3": "string"
}

Reset Signing [/api/v1/signings/{signingId}/reset]

This endpoint will reset the signing associated with the signingId provided.

Reset Signing [POST /api/v1/signings/{signingId}/reset] 

curl -X POST "/api/v1/signings/{signingId}/reset" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "message": "Success"
}
Response 400 (application/json)
{
  "code": 0,
  "message": "string",
  "details": [
    "string"
  ]
}

Reject Signing [/api/v1/signings/{signingId}/reject]

This endpoint will reject the specified signing associated with the provided signingId.

Reject Signing [POST /api/v1/signings/{signingId}/reject] 

curl -X POST "/api/v1/signings/{signingId}/reject" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "message": "Success"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "BadRequest",
  "details": [
    "message details"
  ]
}

Force Signing Completion [/api/v1/signings/{signingId}/force-complete]

This endpoint will forcefully complete the signing associated with the provided signingId.

Note: The signing must have the isAbleForceComplete property set to true.

Force Signing Completion [POST /api/v1/signings/{signingId}/force-complete] 

curl -X POST "/api/v1/signings/{signingId}/force-complete" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "message": "Success"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "BadRequest",
  "details": [
    "details"
  ]
}

Copy Signing [/api/v1/signings/{signingId}/copy]

This endpoint will duplicate the existing signing associated with the provided signingId.

Copy Signing [POST /api/v1/signings/{signingId}/copy] 

curl -X POST "/api/v1/signings/{signingId}/copy" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "id": "<GUID of new Signing>",
  "name": "<duplicated name of signing>",
  "accountId": "<Account ID of user>",
  "statusId": 0,
  "isOrdered": false,
  "dateCreated": "<Date created>",
  "lastModified": "<Date last modified>",
  "expirationDate": "<expiration date>",
  "idPosition": 0,
  "reminderDay": null,
  "reminderHour": null,
  "transactionId": null,
  "technologyProvider": null,
  "callbackUrl": null,
  "layoutId": null,
  "applyLayout": false
}
Response 400 (application/json)
{
  "code": 400,
  "message": "BadRequest",
  "details": {
    "id": [
      "Specific error message about the issue"
    ]
  }
}

Resend Signing Invitation [/api/v1/signings/{signingId}/resend-invitation]

In the event someone loses their signing invitation, this endpoint can be used to resend the invitation to the participants associated with the provided signingId.

Resend Signing Invitation [POST /api/v1/signings/{signingId}/resend-invitation] 

curl -X POST "/api/v1/signings/{signingId}/resend-invitation" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "message": "Success"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "BadRequest",
  "details": [
    "Signing is not Sent."
  ]
}

Forward Final Documents [/api/v1/signings/{signingId}/send-final-documents]

This endpoint sends the final documents of the completed signing session associated with the provided signingId.

Forward Final Documents [POST /api/v1/signings/{signingId}/send-final-documents] 

curl -X POST "/api/v1/signings/{signingId}/send-final-documents" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>" \
  -d '{
    "Emails": "Example1@example.com,Example2@example.com"
  }'
Response 200 (application/json)
{
  "message": "Success"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "BadRequest",
  "details": [
    "Signing is not completed."
  ]
}

Signing Participants

Get Signing Participants [/api/v1/signings/{signingId}/participants]

This endpoint will retrieve the list of signing participants associated with the provided signingId.

The statusId value of a participant can be found below:

statusId Status Definition
1 Draft Signing has not been sent to this participant
2 Sent Signing has been sent to this participant
3 Completed Signing has been completed by this participant
4 Rejected Signing has been rejected by this participant

Get Signing Participants [GET /api/v1/signings/{signingId}/participants] 

curl -X GET "/api/v1/signings/{signingId}/participants" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "message": "Success"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "string",
  "details": [
    "string"
  ]
}

Add Signing Participants [/api/v1/participants/batch]

This endpoint will add participants to a signing. The parameters to include in the POST request are listed below:

Parameter Description
Id The unique ID of the participant to be added
SigningId The unique ID of the signing
FirstName The name of the signing participant
MiddleName The middle name of the signing participant
LastName The last name of the signing participant
Email The email address of the signing participant
ParticipantRole Role that participant is going to be assigned
CustomSignature Custom signature of the participant
CustomInitials Initials of the participant
SigningPin PIN for participant
Type 0 for remote signer. 1 for reviewer, They will have no signature blocks of any kind.
DisplayOrder Order in which the participant will be displayed
SignerGroup for which the participant is related
CustomInvitationSubject Custom subject for the email sent to the participant
CustomInvitationMessage custom message for the partipant
ExternalId Optional string. Can be null
TransactionId Optional transaction ID to associate with this participant
Language Two letter representation of the language for this participant
StaticSignatureEnabled Allows for a static, pregenerated signature
ScriptedSignatureEnabled Allows for custom drawn signature
ImageSignatureEnabled Allows users to upload image of signature

Note: These must be passed as an array of the Participant object in request body, for example: 

[
  {
    "Id": "<Unique GUID>",
    "SigningId": "53719b97-553d-f011-a5f1-6045bdeb690",
    ... additional properties of first participant
  },
  {
    "Id": "<Unique GUID>",
    "SigningId": "53719b97-553d-f011-a5f1-6045bdeb690",
    ... additional properties of next participant
  }
]

Add Signing Participants [POST /api/v1/participants/batch] 

curl -X POST "/api/v1/participants/batch" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -d '[
    {
      "Id": "405355ec-7f5d-423e-416a-4567ea0632d1",
      "SigningId": "805355ec-7f7d-413e-986a-c767ea0632da",
      "FirstName": "Pat",
      "MiddleName": "Dee",
      "LastName": "Backs",
      "Email": "PatDBacks@example.com",
      "ParticipantRole": "Buyer",
      "CustomSignature": "PDB_Signature",
      "CustomInitials": "PDB",
      "SigningPin": "123456",
      "Type": 0,
      "DisplayOrder": 1,
      "SignerGroup": 1,
      "CustomInvitationSubject": "Invitation To Sign",
      "CustomInvitationMessage": "Please review and sign the document",
      "ExternalId": "External9876",
      "TransactionId": "3fb95f64-5717-4562-b3fc-2c963f66bfa7",
      "Language": "en",
      "StaticSignatureEnabled": true,
      "ScriptedSignatureEnabled": true,
      "ImageSignatureEnabled": true,
      "TrestleRole": "Role1"
    }
]'
Response 200 (application/json)
{
  "message": "Success"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "BadRequest",
  "details": {
    "Property_With_Error1": ["error message details"],
    "Property_With_Error2": ["error message details"],
    "Property_With_Error3": ["error message details"]
  }
}

Update Signing Participant email address [/api/v1/participants/{ParticipantId}/email]

This endpoint will update the email address of an existing participant associated with the provided ParticipantId. It will then resend the signing invitation to the new email address.

Update Signing Participant email address [PUT /api/v1/participants/{ParticipantId}/email] 

curl -X PUT "/api/v1/participants/{ParticipantId}/email" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -d '{
    "email": "someEmail@lwolf.com"
  }'
Response 200 (application/json)
{
  "message": "Success"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "BadRequest",
  "details": {
    "participantId": [
      "details"
    ]
  }
}

Signings

This section will outline signing actions available.

Get All Signings Owned by a User [/api/v1/signings/]

This endpoint fetches all signings owned by a user.

Get All Signings Owned by a User [GET /api/v1/signings/] 

curl -X GET "/api/v1/signings/" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <access_token>"
Response 200 (application/json)
{
  "message": "Success"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "string",
  "details": [
    "string"
  ]
}

Fill and Send Signing [/api/v2/signings/fill-and-send-documents]

This endpoint initializes a signing session based on the provided layout, documents, and participants and then immediately sends it.

Note: Passing this information as form-data is reccomended, as it is an easier approach for files to be passed.

Embedded Workflow: In this instance if you wish to embed the signings and avoid sending out links via email, use Embedded=true. This will require UserId, UserName, AuthenticationMethod, and RedirectURL for each participant. Otherwise, these parameters are optional if Embedded=False or if Embedded is omitted from the request.

This workflow has two approaches:


Authentication: When using the embedded signings, Authentication is the responsibility of the integrator. You must implement and manage your own authentication mechanism and explicitly pass the corresponding value in the AuthenticationMethod parameter. The platform does not perform authentication on your behalf and does not infer this value automatically.

Below are some example values that can be passed for AuthenticationMethod. You are not required to support all methods. You must select and pass the method that accurately reflects how authentication is performed in your implementation.
  • Biometric
  • Email
  • HTTPBasicAuth
  • Kerberos
  • KnowledgeBasedAuth
  • PaperDocuments
  • Password
  • RSASecureID
  • SingleSignOn_MicrosoftActiveDirectory

Fill and Send Signing [POST /api/v2/signings/fill-and-send-documents]

Example: Fill-and-send using syntax tagged documents:
curl -X POST "/api/v2/signings/fill-and-send-documents" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer access_token" \
  -F "name=Lonewolf Demo Fill and Send" \
  -F "isOrdered=false" \
  -F "expirationDate=2024-01-30T17:00:42.542Z" \
  -F "callbackUrl=https://typedwebhook.tools/webhook/2f9037fd-c8bf-4989-b560-d40f17696cac" \
  -F "Files=@File1.pdf" \
  -F "Files=@File2.pdf" \

  -F "participants[0].SigningId=example-signing-guid-1" \
  -F "participants[0].UserId=example-user-guid-1" \
  -F "participants[0].UserName=johndoe" \
  -F "participants[0].AuthenticationMethod=Password" \
  -F "participants[0].RedirectUrl=https://example.com/redirect/signer1" \
  -F "participants[0].FirstName=John" \
  -F "participants[0].MiddleName=M" \
  -F "participants[0].LastName=Doe" \
  -F "participants[0].Email=johndoe@example.com" \
  -F "participants[0].ParticipantRole=Signer 1" \
  -F "participants[0].CustomSignature=JohnD" \
  -F "participants[0].CustomInitials=JD" \
  -F "participants[0].SigningPin=1234" \
  -F "participants[0].Type=1" \
  -F "participants[0].DisplayOrder=0" \
  -F "participants[0].SignerGroup=1" \
  -F "participants[0].CustomInvitationSubject=Invitation to Sign" \
  -F "participants[0].CustomInvitationMessage=Please sign the attached document." \
  -F "participants[0].ExternalId=external-id" \
  -F "participants[0].TransactionId=example-transaction-guid" \
  -F "participants[0].Language=en-US" \
  -F "participants[0].StaticSignatureEnabled=true" \
  -F "participants[0].ScriptedSignatureEnabled=false" \
  -F "participants[0].ImageSignatureEnabled=true" \
  -F "participants[0].TrestleRole=Admin" \

  -F "participants[1].SigningId=example-signing-guid-2" \
  -F "participants[1].UserId=example-user-guid-2" \
  -F "participants[1].UserName=jondough" \
  -F "participants[1].AuthenticationMethod=Password" \
  -F "participants[1].RedirectUrl=https://example.com/redirect/signer2" \
  -F "participants[1].FirstName=Jon" \
  -F "participants[1].MiddleName=L" \
  -F "participants[1].LastName=Dough" \
  -F "participants[1].Email=jondough@example.com" \
  -F "participants[1].ParticipantRole=Signer 2" \
  -F "participants[1].CustomSignature=JonD" \
  -F "participants[1].CustomInitials=JD" \
  -F "participants[1].SigningPin=1234" \
  -F "participants[1].Type=1" \
  -F "participants[1].DisplayOrder=0" \
  -F "participants[1].SignerGroup=1" \
  -F "participants[1].CustomInvitationSubject=Invitation to Sign" \
  -F "participants[1].CustomInvitationMessage=Please sign the attached document." \
  -F "participants[1].ExternalId=external-id" \
  -F "participants[1].TransactionId=example-transaction-guid" \
  -F "participants[1].Language=en-US" \
  -F "participants[1].StaticSignatureEnabled=true" \
  -F "participants[1].ScriptedSignatureEnabled=false" \
  -F "participants[1].ImageSignatureEnabled=true" \
  -F "participants[1].TrestleRole=Admin"
Example: Fill and Send using Embedded = True and using a Layout:

    curl -X POST "/api/v2/signings/fill-and-send-documents" \
    -H "Accept: application/json" \
    -H "Authorization: Bearer access_token" \
    -F "name=Lonewolf Demo Fill and Send" \
    -F "isOrdered=false" \
    -F "Embedded=true" \
    -F "expirationDate=2024-01-30T17:00:42.542Z" \
    -F "callbackUrl=https://typedwebhook.tools/webhook/2f9037fd-c8bf-4989-b560-d40f17696cac" \
    -F "layoutId=example-guid-of-layout" \
    -F "applyLayout=true" \"


    -F "participants[0].SigningId=example-signing-guid-1" \
    -F "participants[0].UserId=example-user-guid-1" \
    -F "participants[0].UserName=johndoe" \
    -F "participants[0].AuthenticationMethod=Password" \
    -F "participants[0].RedirectUrl=https://example.com/redirect/signer1" \
    -F "participants[0].FirstName=John" \
    -F "participants[0].MiddleName=M" \
    -F "participants[0].LastName=Doe" \
    -F "participants[0].Email=johndoe@example.com" \
    -F "participants[0].ParticipantRole=Signer 1" \
    -F "participants[0].CustomSignature=JohnD" \
    -F "participants[0].CustomInitials=JD" \
    -F "participants[0].SigningPin=1234" \
    -F "participants[0].Type=1" \
    -F "participants[0].DisplayOrder=0" \
    -F "participants[0].SignerGroup=1" \
    -F "participants[0].CustomInvitationSubject=Invitation to Sign" \
    -F "participants[0].CustomInvitationMessage=Please sign the attached document." \
    -F "participants[0].ExternalId=external-id" \
    -F "participants[0].TransactionId=example-transaction-guid" \
    -F "participants[0].Language=en-US" \
    -F "participants[0].StaticSignatureEnabled=true" \
    -F "participants[0].ScriptedSignatureEnabled=false" \
    -F "participants[0].ImageSignatureEnabled=true" \
    -F "participants[0].TrestleRole=Admin" \

    -F "participants[1].SigningId=example-signing-guid-2" \
    -F "participants[1].UserId=example-user-guid-2" \
    -F "participants[1].UserName=jondough" \
    -F "participants[1].AuthenticationMethod=Password" \
    -F "participants[1].RedirectUrl=https://example.com/redirect/signer2" \
    -F "participants[1].FirstName=Jon" \
    -F "participants[1].MiddleName=L" \
    -F "participants[1].LastName=Dough" \
    -F "participants[1].Email=jondough@example.com" \
    -F "participants[1].ParticipantRole=Signer 2" \
    -F "participants[1].CustomSignature=JonD" \
    -F "participants[1].CustomInitials=JD" \
    -F "participants[1].SigningPin=1234" \
    -F "participants[1].Type=1" \
    -F "participants[1].DisplayOrder=0" \
    -F "participants[1].SignerGroup=1" \
    -F "participants[1].CustomInvitationSubject=Invitation to Sign" \
    -F "participants[1].CustomInvitationMessage=Please sign the attached document." \
    -F "participants[1].ExternalId=external-id" \
    -F "participants[1].TransactionId=example-transaction-guid" \
    -F "participants[1].Language=en-US" \
    -F "participants[1].StaticSignatureEnabled=true" \
    -F "participants[1].ScriptedSignatureEnabled=false" \
    -F "participants[1].ImageSignatureEnabled=true" \
    -F "participants[1].TrestleRole=Admin"
Example: Fill-And-Send using Embedded=True and tagged documents:
curl -X POST "/api/v2/signings/fill-and-send-documents" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer access_token" \
  -F "name=Lonewolf Demo Fill and Send" \
  -F "isOrdered=false" \
  -F "Embedded=true" \
  -F "expirationDate=2024-01-30T17:00:42.542Z" \
  -F "callbackUrl=https://typedwebhook.tools/webhook/2f9037fd-c8bf-4989-b560-d40f17696cac" \
  -F "Files=@File1.pdf" \
  -F "Files=@File2.pdf" \

  -F "participants[0].SigningId=example-signing-guid-1" \
  -F "participants[0].UserId=example-user-guid-1" \
  -F "participants[0].UserName=johndoe" \
  -F "participants[0].AuthenticationMethod=Password" \
  -F "participants[0].RedirectUrl=https://example.com/redirect/signer1" \
  -F "participants[0].FirstName=John" \
  -F "participants[0].MiddleName=M" \
  -F "participants[0].LastName=Doe" \
  -F "participants[0].Email=johndoe@example.com" \
  -F "participants[0].ParticipantRole=Signer 1" \
  -F "participants[0].CustomSignature=JohnD" \
  -F "participants[0].CustomInitials=JD" \
  -F "participants[0].SigningPin=1234" \
  -F "participants[0].Type=1" \
  -F "participants[0].DisplayOrder=0" \
  -F "participants[0].SignerGroup=1" \
  -F "participants[0].CustomInvitationSubject=Invitation to Sign" \
  -F "participants[0].CustomInvitationMessage=Please sign the attached document." \
  -F "participants[0].ExternalId=external-id" \
  -F "participants[0].TransactionId=example-transaction-guid" \
  -F "participants[0].Language=en-US" \
  -F "participants[0].StaticSignatureEnabled=true" \
  -F "participants[0].ScriptedSignatureEnabled=false" \
  -F "participants[0].ImageSignatureEnabled=true" \
  -F "participants[0].TrestleRole=Admin" \

  -F "participants[1].SigningId=example-signing-guid-2" \
  -F "participants[1].UserId=example-user-guid-2" \
  -F "participants[1].UserName=jondough" \
  -F "participants[1].AuthenticationMethod=Password" \
  -F "participants[1].RedirectUrl=https://example.com/redirect/signer2" \
  -F "participants[1].FirstName=Jon" \
  -F "participants[1].MiddleName=L" \
  -F "participants[1].LastName=Dough" \
  -F "participants[1].Email=jondough@example.com" \
  -F "participants[1].ParticipantRole=Signer 2" \
  -F "participants[1].CustomSignature=JonD" \
  -F "participants[1].CustomInitials=JD" \
  -F "participants[1].SigningPin=1234" \
  -F "participants[1].Type=1" \
  -F "participants[1].DisplayOrder=0" \
  -F "participants[1].SignerGroup=1" \
  -F "participants[1].CustomInvitationSubject=Invitation to Sign" \
  -F "participants[1].CustomInvitationMessage=Please sign the attached document." \
  -F "participants[1].ExternalId=external-id" \
  -F "participants[1].TransactionId=example-transaction-guid" \
  -F "participants[1].Language=en-US" \
  -F "participants[1].StaticSignatureEnabled=true" \
  -F "participants[1].ScriptedSignatureEnabled=false" \
  -F "participants[1].ImageSignatureEnabled=true" \
  -F "participants[1].TrestleRole=Admin"
Response 200 (application/json) (If Embedded = False)
{
  "id": "<New GUID>",
  "name": "<Name of Signing>",
  "accountId": "<Account ID of user>",
  "statusId": 0,
  "isOrdered": false,
  "dateCreated": "2025-05-30T16:26:20.97",
  "lastModified": "2025-05-30T16:26:20.97",
  "expirationDate": "2025-06-30T02:59:00Z",
  "idPosition": 0,
  "reminderDay": null,
  "reminderHour": null,
  "transactionId": null,
  "technologyProvider": null,
  "callbackUrl": null,
  "layoutId": "<Layout ID generated>",
  "applyLayout": false
}
Response 200 (application/json) (If Embedded = True)
{
  "signing": {
    "id": "<GUID to signing>",
    "name": "<Name of Signing>",
    "accountId": "<Account ID>",
    "statusId": 0,
    "isOrdered": false,
    "dateCreated": "<Date Created>",
    "lastModified": "<Date Last modified>",
    "expirationDate": "<Expiration Date>",
    "idPosition": 0,
    "reminderDay": null,
    "reminderHour": null,
    "transactionId": null,
    "technologyProvider": null,
    "callbackUrl": null,
    "layoutId": "<LayoutID>",
    "applyLayout": false,
    "adsEnabled": false
  },
  "links": [
    {
      "participantId": "<First participant GUID>",
      "userId": "UserID1",
      "userName": "UserName1",
      "signerPortionLink": "<Secure Link to Signing for first participant>"
    },
    {
      "participantId": "<Second participant GUID>",
      "userId": "UserID2",
      "userName": "UserName2",
      "signerPortionLink": "<Secure Link to Signing for second participant>"
    }
  ]
}
Response 400 (application/json)
{
  "code": 400,
  "message": "Error Message Summary",
  "details": {
    "ErrorPropertyField": [
      "details"
    ]
  }
}

Get Specific Signing [/api/v1/signings/{signingId}/]

This endpoint fetches details for the signing associated with the provided signingId.

The statusId value of a signing can be found below:

statusId Status Definition
0 Draft This is the initial status of the signing as you are preparing the documents and signature blocks
1 Sent This is the status of the signing after it has been sent out for signatures
2 Signed This is an intermediary status. Users should never see this. This is when the signing has completed but has not been digitally signed yet
3 Completed This is the status after the signing has completed and all documents have been finalized and produced (This will have the digital and electronic signature on it)
4 Rejected This is the status when a signer rejects the signing. Once rejected the signing process stops
5 Reset This is when someone resets a signing to rework a correction etc. When a signing is reset anyone that has signed will need to sign again.
6 Expired This is when the signing this the expiration date set on the signing creation. By default all signings expire after 30 days

Get Specific Signing [GET /api/v1/signings/{signingId}/] 

curl -X GET "/api/v1/signings/{signingId}/" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "message": "Success"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "string",
  "details": [
    "string"
  ]
}

Update Callback URL for a Signing [/api/v1/signings/{signingID}/]

This endpoint updates the Callback URL for the signing associated with the provided signingId.

Update Callback URL for a Signing [PATCH /api/v1/signings/{signingID}/] 

curl -X PATCH "/api/v1/signings/{signingID}/" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>" \
  -d '{
    "CallbackUrl": "https://newcallbackurl.com"
  }'
Response 200 (application/json)
{
  "message": "Success"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "BadRequest",
  "details": {
    "errorProperty": [
      "details about error"
    ]
  }
}

Create Signing [/api/v1/signings]

This endpoint allows for the creation of a new signing, including the ability to add a webhook callback URL. The minimum information needed to create a signing is the Name property. Accepts form-data.

Note: Note: If using an existing layout to create a signing, additional parameters for the participants are required. Take note of the roles assigned in the layout selected, as they will need to be mapped to the participant. For example, if the Layout selected has roles “Signer 1” and “Signer 2”, those roles will need to be passed with the respective participant.

Create Signing [POST /api/v1/signings] 


    curl -X POST "/api/v1/signings" \
    -H "Accept: application/json" \
    -H "Authorization: Bearer (Token Here)" \
    -H "externalId: (externalId here)" \
    -F "Name=Test Layout" \
    -F "StatusId=1" \
    -F "IsOrdered=false" \
    -F "DateCreated=2023-04-20T02:59:00Z" \
    -F "LastModified=2023-04-21T02:59:00Z" \
    -F "ExpirationDate=2023-04-26T02:59:00Z" \
    -F "IdPosition=1" \
    -F "ReminderDay=5" \
    -F "ReminderHour=2" \
    -F "TransactionId=example-guid-3" \
    -F "TechnologyProvider=TechProviderName" \
    -F "CallbackUrl=https://yourcallbackurl.com" \
    -F "layoutId=Guid of an existing layout" \
    -F "Files[0]=File1" \
    -F "Files[1]=File2" \
    -F "FilesWithStrikeoutsDisabled[0]=FileName1" \
    -F "FilesWithStrikeoutsDisabled[1]=FileName2" \
    -F "CustomSender.FirstName=John" \
    -F "CustomSender.LastName=Dough" \
    -F "CustomSender.Email=example@email.com" \
    -F "CustomSender.Phone=5555555555" \
    -F "Participants[0].ParticipantRole=Example Role 1" \
    -F "Participants[0].Email=com" \
    -F "Participants[0].FirstName=Steve" \
    -F "Participants[0].LastName=Seller" \
    -F "participants[0].CustomInvitationSubject=Invitation to Sign" \
    -F "participants[0].CustomInvitationMessage=Please sign the attached document." \
    -F "Participants[0].StaticSignatureEnabled=true" \
    -F "Participants[0].ScriptedSignatureEnabled=true" \
    -F "Participants[0].ImageSignatureEnabled=true" \
    -F "Participants[1].ParticipantRole=Example Role 2" \
    -F "Participants[1].Email=com" \
    -F "Participants[1].FirstName=Bob" \
    -F "Participants[1].LastName=buyer" \
    -F "participants[1].CustomInvitationSubject=Invitation to Sign" \
    -F "participants[1].CustomInvitationMessage=Please sign the attached document." \
    -F "Participants[1].StaticSignatureEnabled=true" \
    -F "Participants[1].ScriptedSignatureEnabled=true" \
    -F "Participants[1].ImageSignatureEnabled=true"
Response 200 (application/json)
    {
    "id": "Guid of new signing",
    "name": "Name of new signing",
    "accountId": "Account ID Guid",
    "statusId": 1,
    "isOrdered": false,
    "dateCreated": "2023-04-20T02:59:00Z",
    "lastModified": "2026-02-06T19:52:25.573",
    "expirationDate": "2023-04-26T02:59:00Z",
    "idPosition": 1,
    "reminderDay": 5,
    "reminderHour": 2,
    "transactionId": null,
    "technologyProvider": "TechProviderName",
    "callbackUrl": "https://yourcallbackurl.com",
    "layoutId": null(will be populated if LayoutId was used),
    "applyLayout": false,
    "adsEnabled": false
    }
Response 400 (application/json)
{
  "code": 400,
  "message": "string",
  "details": [
    "string"
  ]
}

Get Completed Signing by Signing ID [/api/v1/signings/documents/{signingId}/completed]

This endpoint will fetch the completed signing links for the signing associated with provided signingId.

Get Completed Signing by Signing ID [GET /api/v1/signings/documents/{signingId}/completed] 

curl -X GET "/api/v1/signings/documents/{signingId}/completed" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
[
  {
    "link": "link for completed document 1"
  },
  {
    "link": "link for completed document 2"
  }
]
Response 404 (application/json)
{
  "code": 404,
  "message": "NotFound",
  "details": [
    "Signing has not been finalized."
  ]
}

Get URL to Original Documents by Signing ID [/api/v1/signings/documents/{signingId}/original]

This endpoint will fetch the links to the original documents to the signing associated with provided signingId.

Get URL to Original Documents by Signing ID [GET /api/v1/signings/documents/{signingId}/original] 

curl -X GET "/api/v1/signings/documents/{signingId}/original" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
[
  {
    "link": "link for original document 1"
  },
  {
    "link": "link for original document 2"
  }
]
Response 404 (application/json)
{
  "code": 404,
  "message": "NotFound",
  "details": [
    "Signing Status must be Sent, Finalizing or Completed"
  ]
}

Get URL for Certificates by Signing ID [/api/v1/signings/documents/{signingId}/certificates]

This endpoint will fetch the Certificate links for the signing associated with provided signingId.

Get URL for Certificates by Signing ID [GET /api/v1/signings/documents/{signingId}/certificates] 

curl -X GET "/api/v1/signings/documents/{signingId}/certificates" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
[
  {
    "link": "link for certificate 1"
  },
  {
    "link": "link for certificate 2"
  }
]
Response 404 (application/json)
{
  "code": 404,
  "message": "NotFound",
  "details": [
    "Signing has not been finalized."
  ]
}

Signings Documents

This section outlines the available actions for documents.

Get Signing Document IDs [/api/v1/signings/{signingId}/documents/]

This endpoint fetches the document IDs associated with the provided signingId.

Get Signing Document IDs [GET /api/v1/signings/{signingId}/documents/] 

curl -X GET "/api/v1/signings/{signingId}/documents/" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
[
  {
    "id": "<Unique GUID for Document>",
    "name": "<Name of Document>",
    "encryptedId": "<EncryptedId of Document>"
  }
]
Response 400 (application/json)
{
  "code": 0,
  "message": "string",
  "details": [
    "string"
  ]
}

Apply Layout to a Document Within Specific Signing [/api/v1/signings/{signingId}/documents/{documentId}/]

This endpoint will apply a layout to a document with provided documentId within the signing associated with the provided signingId.

Apply Layout to a Document Within Specific Signing [PATCH /api/v1/signings/{signingId}/documents/{documentId}/] 

curl -X PATCH "/api/v1/signings/{signingId}/documents/{documentId}/" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>" \
  -d '{
        "LayoutId": "<Unique Guid for Layout>"
      }'
Response 200 (application/json)
{
  "type": "string",
  "title": "string",
  "status": 0,
  "detail": "string",
  "instance": "string",
  "additionalProp1": "string",
  "additionalProp2": "string",
  "additionalProp3": "string"
}
Response 400 (application/json)
{
  "type": "string",
  "title": "string",
  "status": 0,
  "detail": "string",
  "instance": "string",
  "additionalProp1": "string",
  "additionalProp2": "string",
  "additionalProp3": "string"
}
Response 404 (application/json)
{
  "type": "string",
  "title": "string",
  "status": 0,
  "detail": "string",
  "instance": "string",
  "additionalProp1": "string",
  "additionalProp2": "string",
  "additionalProp3": "string"
}

Get Original Document using Encrypted ID [/api/v1/documents/{encryptedDocId}/o]

This endpoint will retrieve the original document using the provided encryptedDocId.

Get Original Document using Encrypted ID [GET /api/v1/documents/{encryptedDocId}/o] 

curl -X GET "/api/v1/documents/{encryptedDocId}/o" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "message": "Success"
}
Response 400 (application/json)
{
  "code": 0,
  "message": "string",
  "details": [
    "string"
  ]
}

Get Final Version of Document using Encrypted ID [/api/v1/documents/{encryptedDocId}/d]

This endpoint will retrieve the final version of a document using the provided encryptedId.

Get Final Version of Document using Encrypted ID [GET /api/v1/documents/{encryptedDocId}/d] 

curl -X GET "/api/v1/documents/{encryptedDocId}/d" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "message": "Success"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "BadRequest",
  "details": [
    "Document has not been finalized."
  ]
}

Get Latest Signed Document for Specific Signing [/api/v1/signings/{signingId}/documents/ls]

This endpoint will retrieve the latest signed document for the provided signingId.

Get Latest Signed Document for Specific Signing [GET /api/v1/signings/{signingId}/documents/ls] 

curl -X GET "/api/v1/signings/{signingId}/documents/ls" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "message": "Success"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "BadRequest",
  "details": [
    "Signing status is not sent or expired."
  ]
}

Get Signing Certificate for Specific Signing [/api/v1/signings/{signingId}/documents/sc]

This endpoint will retrieve the signing certificate for the provided signingId.

Get Signing Certificate for Specific Signing [GET /api/v1/signings/{signingId}/documents/sc] 

curl -X GET "/api/v1/signings/{signingId}/documents/sc" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "message": "Success"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "BadRequest",
  "details": [
    "Signing has not been finalized."
  ]
}

Get Certificate of Document using Encrypted ID [/api/v1/documents/{encryptedDocId}/dc]

This endpoint will retrieve the signing certificate for the provided encryptedDocId.

Get Certificate of Document using Encrypted ID [GET /api/v1/documents/{encryptedDocId}/dc] 

curl -X GET "/api/v1/documents/{encryptedDocId}/dc" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "message": "Success"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "BadRequest",
  "details": [
    "Signing has not been finalized."
  ]
}

Get fully executed combined signing package PDF [/api/v1/signings/{signingId}/documents/s]

This endpoint will retrieve the fully executed combined signing package PDF for signing associated with the provided signingId.

Get Fully Executed Combined Signing Package PDF [GET /api/v1/signings/{signingId}/documents/s] 

curl -X GET "/api/v1/signings/{signingId}/documents/s" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "message": "Success"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "BadRequest",
  "details": [
    "Signing has not been finalized."
  ]
}

Get URL of fully executed combined signing package PDF [/api/v1/signings/{signingId}/documents/s/url]

This endpoint will retrieve the URL to the fully executed combined signing package PDF for signing associated with the provided signingId.

Get URL of Fully Executed Combined Signing Package PDF [GET /api/v1/signings/{signingId}/documents/s/url] 

curl -X GET "/api/v1/signings/{signingId}/documents/s/url" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "url": "https://url_to_package"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "BadRequest",
  "details": [
    "Signing has not been finalized."
  ]
}

Get URL to Latest Signed Document associated with Signing ID [/api/v1/signings/{signingId}/documents/ls/url]

This endpoint will retrieve the URL to latest signed document associated with the specified signingId.

Get URL to Latest Signed Document associated with Signing ID [GET /api/v1/signings/{signingId}/documents/ls/url] 

curl -X GET "/api/v1/signings/{signingId}/documents/ls/url" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "url": "https://URL_To_Latest_Signed_Document"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "BadRequest",
  "details": [
    "Signing status is not sent or expired."
  ]
}

Get URL of Original Document [/api/v1/documents/{documentId}/o/url]

This endpoint will retrieve the URL to original document associated with the specified documentId.

Get URL of Original Document [GET /api/v1/documents/{documentId}/o/url] 

curl -X GET "/api/v1/documents/{documentId}/o/url" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "url": "https://URL_To_Original_Document"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "BadRequest",
  "details": [
    "details about the error"
  ]
}

Get URL of Final Version of Document [/api/v1/documents/{documentId}/d/url]

This endpoint will retrieve the URL to final version of the document associated with the specified documentId.

Get URL of Final Version of Document [GET /api/v1/documents/{documentId}/d/url] 

curl -X GET "/api/v1/documents/{documentId}/d/url" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "url": "https://URL_To_Final_Version_Of_Document"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "BadRequest",
  "details": [
    "details about the error"
  ]
}

Get URL of Document’s Certificate [/api/v1/documents/{documentId}/dc/url]

This endpoint will retrieve the URL to Document’s Certificate associated with the specified documentId.

Get URL of Document’s Certificate [GET /api/v1/documents/{documentId}/dc/url] 

curl -X GET "/api/v1/documents/{documentId}/dc/url" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "url": "https://URL_To_Final_Version_Of_Document"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "BadRequest",
  "details": [
    "details about the error"
  ]
}

Signings History

This section describes how to retrieve the audit trail for a given signing.

Get Signing History [/api/v1/signings/{signingId}/history]

This endpoint allows you to pull a list of all audit trail events related to this signing. The audit trail is also embedded into the final signed documents themselves.

Get Signing History [GET /api/v1/signings/{signingId}/history] 

curl -X GET "/api/v1/signings/{signingId}/history" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "code": 0,
  "message": "string",
  "details": [
    "string"
  ]
}
Response 400 (application/json)
{
  "code": 0,
  "message": "string",
  "details": [
    "string"
  ]
}

Single Sign On Methods API

This section describes how to SSO directly into the Signing Design phase to finalize it before sending.

Note: Check out the Fill and Send endpoint to automated signing creation and document retrieval.

SSO Into Signing [/api/v1/sso/signing/{signingId}?{redirectUrl}]

This endpoint generates an SSO URL that directly lands the user into the design phase of the signing.

SSO Into Signing [GET /api/v1/sso/signing/{signingId}?redirectUrl={redirectUrl}] 

curl -X GET "/api/v1/sso/signing/{signingId}?redirectUrl={redirectUrl}" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "sso": "URL_to_Directly_enter_Design_Step"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "BadRequest",
  "details": {
    "FieldThrowingError": [
      "Details about the field's error"
    ]
  }
}

SSO Into Layout [/api/v1/sso/Layouts/{LayoutId}?{redirectUrl}]

This endpoint generates an SSO URL that directly lands the user into the design phase of the Layout.

SSO Into Layout [GET /api/v1/sso/signing/{signingId}?redirectUrl={redirectUrl}] 

curl -X GET "/api/v1/sso/layouts/{LayoutId}?redirectUrl={redirectUrl}" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -H "externalId: <your_external_id>"
Response 200 (application/json)
{
  "sso": "URL_to_Directly_enter_Design_Step"
}
Response 400 (application/json)
{
  "code": 400,
  "message": "BadRequest",
  "details": {
    "FieldThrowingError": [
      "Details about the field's error"
    ]
  }
}

Common Workflows

Create Signing with an existing PDF

To create a signing and add participants with a previously created PDF, the appropriate tags are required to be added to the PDF. The table below outlines roles, actions, and the respective tags to use:

Role
Signer Actions Signature – Required Initials – Required Initials – Optional Signature Date Stamp Name Company Title
Signer 1 \s1\ \i1\ \oi1\ \d1\ \n1\ \co1\ \t1\
Signer 2 \s2\ \i2\ \oi2\ \d2\ \n2\ \co2\ \t2\
Signer 3 \s3\ \i3\ \oi3\ \d3\ \n3\ \co3\ \t3\
Signer 4 \s4\ \i4\ \oi4\ \d4\ \n4\ \co4\ \t4\

Once the PDF has been tagged appropriately, the Fill And Send endpoint can be used to quickly load the document, add participants, and send the signing.

Create a Signing from Static Layout

This workflow is best suited for a user that has a document that will be reused for multiple signings.

1. An existing layout will need to exist. To fetch existing layouts, use the Get Layouts endpoint. Take note of the id, as this will be used in the next step. If no layouts exist, a new layout can be created using Create New Layout. This endpoint will return the id when successfully created. Use this id to pass to the SSO into Layout. Once in the Layout Editor, add your documents, map your signing fields and any form fields, and save.

2. Now that you have the layout you wish to apply, create a new signing using the Create Signing endpoint. Pass the id from the previous step in the layoutId field to create a signing from the existing layout.

3. Alternatively, you can use the Fill-and-Send-Documents to pass the layoutId along with the participant information, and any form fields set in the layout. This will handle the creation of a new signing using the existing layout, and send to the participants.

Create a Signing with the Design Wizard

1. To create a signing and customize it with the Design Wizard, first you would need to create the initial signing, using the Create Signing endpoint.

2. Using the same GUID used to generate that signing, pass that GUID to the SSO Into Signing endpoint along with a redirect URL.

3. Use the URL generated with the previous endpoint to launch the Design Wizard, where users can upload files, add participants, and add additional signature blocks.

Creating a Signing with Multiple Signers

Sometimes a signing will require multiple signers, in different roles. For example, a signing could require the signatures of two buyers, and two sellers. This can be achieved by ensuring that the document is prepared with the correct PDF tags, for example:

Using an existing PDF with tags

Using an existing PDF will require it to be tagged with the appropriate tags where the signatures are required. When adding participants, defining ParticipantRole when adding participants will require each participant to match the role mapped on the PDF. Refer to the table under the Create Signing with an existing PDF for the valid tags and their roles.

Using the Design Wizard

Once the signing is created, use the SSO Into Signing endpoint to enter the design wizard. From the design wizard, click “Add Participants”. When filling out the participant information, be sure to give each party a unique role.

After participants are added, next step is to add the document(s). Once the document(s) have been added, navigate to the Tools. Use the Signing Tools to add Signing Blocks, any Signer Fields needed. Use the drop down menu at the top to change your signers, and add the necessary Signing Blocks, or Signer Fields as needed.

Once satisfied with the markup, click “Next” and make any adjustments to the expiration, reminders, or customize the invite if needed. Clicking Send will finalize and send the Signing to participants.

Creating a Signing and adding a CC

On occasion, an additional party may need to be notified when a signing is completed. A “CC” can be added to ensure that all parties are informed when a signing is completed. A CC can be added when a signing is in “Draft” or “Sent” status. To do this, simply pass the SigningId, First and Last Name, as well as Email address in the Add CCs in Batch endpoint for each CC needed.

Create Signing and Embed Link with an existing PDF

To create a signing with an existing PDF and return a link to the signing invitation requires some additional mandatory parameters in the body, and the parameter Embedded must be set to true. These are the additional parameters for each participant that should be defined:

  • UserId
  • UserName
  • AuthenticationMethod
  • RedirectUrl
The first three are saved in case of audit in the PDF “History Bookmark”. The last value is an URL to redirect the participant after finishing their signing process. When this feature is enabled, signing invitations emails containing links are not sent. Instead, the endpoint returns the signing portion link for each participant. Example of a response:
Response 200 (application/json):
{
    "signing": {
        "id": "",
        "name": "",
        "accountId": "",
        "statusId": 0,
        "isOrdered": false,
        "dateCreated": "2026-01-07T17:15:20.183",
        "lastModified": "2026-01-07T17:15:20.183",
        "expirationDate": "2026-02-07T04:59:00Z",
        "idPosition": 0,
        "reminderDay": null,
        "reminderHour": null,
        "transactionId": null,
        "technologyProvider": null,
        "callbackUrl": null,
        "applyLayout": false,
        "adsEnabled": false
    },
    "links": [
        {
            "participantId": "",
            "userId": "123456",
            "userName": "Username value",
            "signerPortionLink": ""
        }
    ]
}

Customize the Signing Creator Details

If you want a signing to appear to be sent from a custom persona, you can define these variables when generating a signing with the Create Signing endpoint:

  • CustomSender.FirstName
  • CustomSender.LastName
  • CustomSender.Email
  • CustomSender.Phone
These details will display to signing participants on the signing’s email notifications and again on the signing completed landing page.