Download OpenAPI specification:Download
Welcome to the IgniSign Electronic Signature Platform API documentation!
IgniSign is a comprehensive electronic signature platform that enables users to sign, send, and manage documents securely online. With IgniSign, users can streamline their document signing processes, reduce turnaround times, and increase productivity.
The IgniSign API allows developers to integrate electronic signature functionality directly into their applications, enabling their users to sign and manage documents without ever leaving their platform. With the IgniSign API, developers can easily automate document signing workflows, track signature progress in real-time, and securely store signed documents.
This documentation provides comprehensive information on how to use the IgniSign API to integrate electronic signature functionality into your application. It includes detailed information on API endpoints, authentication, error handling, and sample code snippets in multiple programming languages.
Whether you're developing a new application or looking to enhance an existing one, the IgniSign API provides a robust and flexible electronic signature solution that can help you achieve your business objectives.
To start using IgniSign, you need to create an account.
You can create an account by using the IgniSign Console available at https://console.ignisign.io/signup.
You just need to validate your email address and you are good to go.
When you create an account, we automatically create for you:
More information about Organizations, Applications and Environments is available here
More information about Signature Profiles is available here
We know, as developpers, that testing an API is a key step before adopting it.
So we decide to found a way to let you developing our API for free.
For each application you create, there are 3 environments
More information about Environments is available here
The Development environment is free and you can use it as long as you want.
To be able to do that we have choosen to avoid all external costs (SMS, ID Proofing, ...)
So, in the development environment, ID Proofing are simulated (fakely validated) and SMS NONCE are sent by email.
The Staging environment is also free regarding signatures cost.
But, as you need to test your application in real condition, we have choosen to use real ID Proofing & real SMS NONCE.
So, you will be charged for ID Proofing and SMS NONCE.
The Production environment is the real one. You will be charged for all signatures, ID Proofing and SMS NONCE.
More information about Pricing is available here
The easiest way create your first signature is to use the IgniSign's Console.
To access to the Signature Request creation page click on "Signature Request" in the menu and then click on "Create Signature Request" button.
You are now invited to choose a Signature Profile. Choose the one you want and click on "Next" button.
Enter a Title and a Description, provide information for a Signer, provide a document to sign and click on the "Publish" button.
More information about Signature Requests possibilities is available here
As all integration mode defined in default signature profile is "By Side", an email is sent to the signer to invite him to sign the document you provide.
When the signer click on the link in the email, he is redirected to the signature page and a Signature Session begin.
More information about Integration Modes is available here
More information about Signature Session is available here
When all the signers have signed the document, the Signature Request is Finalized.
An email is sent to the signers to provide the link where they can download the signed document.
Their are lots of possibilities in Ignisign.
The worflow below is the main workflow that you can use to make people signing documents.
%%{init: {'theme':'default'}}%%
stateDiagram-v2
state "Select a Signature Profile" as CreateSignatureProfile
state "Initiailize Signature Request" as CreateSignatureRequest_Init
state "Create/Add Signers" as CreateSigners
state "Add Documents" as AddDocuments
state "Update Signature Request Metadata" as UpdateSignatureRequestMetadata
state "Publish Signature Request" as FinalizeSignatureRequest
state "Create a Signature Request" as CreateSignatureRequest {
CreateSignatureRequest_Init --> CreateSigners
CreateSigners --> AddDocuments
AddDocuments --> UpdateSignatureRequestMetadata
UpdateSignatureRequestMetadata --> FinalizeSignatureRequest
}
state "Initialize Signature Session" as InitializeSignatureSession
state "Signers Identification" as SignersIdentification
state "Signers Authentication" as SignersAuthentication
state "Signer Validate the Signature" as SignerValidateSignature
state "Signers Sign Documents" as SignersSign {
InitializeSignatureSession --> SignersIdentification
SignersIdentification --> SignersAuthentication
SignersAuthentication --> SignerValidateSignature
}
state "Signature Proofs Availability" as SignatureProofsAvailability
[*] --> CreateSignatureProfile
CreateSignatureProfile --> CreateSignatureRequest
CreateSignatureRequest --> SignersSign
SignersSign --> SignatureProofsAvailability
SignatureProofsAvailability --> [*]
You can Find detailed information about each step in the following sections.
Surely, you can use the IgniSign Console as a standalone application.
But IgniSign has been designed to be integrated with backends.
This way, you can use IgniSign as a SaaS solution linked to your application.
First at all, you need to create obtain an API key.
You can do that by clicking on "API Keys" in the menu of the console.
Then click on "Generate API Key" button.
You have now different ways to integrate IgniSign with your backend:
For the moment, we only provide a NodeJS SDK. Surely, we will provide other SDKs in the future.
You can also direcly integrate our API by calling it directly.
You can find the API documentation at the end of the ignisign documentation here
The Open API specification is available here
IgniSign provides a mechanism to easily embed the signature process into your application.
As described in the Integration documentation section
you can choose to embed the signature process into your application or let IgniSign fully manage the signature process.
The signature process is a complex process that requires a lot of steps and a lot of interactions with the user.
There are lots of conditions to meet the legal requirements.
So, we cannot let you directly manage a signature session.
To enable you to embed the signature process into your application, we have developed a mechanism based on an iframe that let you to easyly embed the signature process into your application.
Important: To integrate the signature process with an embedded integration into production, you need to validate the Delegation of Authentication process.
To help you to integrate IgniSign with your application, we provide you some examples.
Examples are available into the repository ignisign-examples.
You can easily clone the repository and run the examples.
Organizations of ignisign accounts are structured as a tree. Each organization can have multiple applications and each application can have multiple environments. Each environment can have multiple signature profiles.
Users can have several organizations. You can invite others users to your organization or applications.
Organizations: Organization are related to a company or a group of people.
Applications: Application are related to a software or a service.
Each application has 3 environments: DEVELOPMENT
, STAGING
and PRODUCTION
.
At IgniSign, we want to provide a signature mechanism that matches the needs of companies.
These companies are very diverse, and their needs are also very diverse.
The real balance is to find the right experiences for the signers and the right legal value for the signature, all at a good price!
To achieve this, we have created the concept of Signature Profiles.
A Signature Profile is a set of parameters that defines the signature mechanism that will be used
when you create Signature Requests
Because parameters influence the possibilities of each others, Signature Profiles can only be created into IgniSign Console.
It defines the following elements:
All these parameters influence deeply the signature mechanism and the user experience.
During the creation of your signature profile, we show you some KPIs that will help you to choose the right parameters.
When your Archiving (set status to ARCHIVED
) the signature requests that have be initialized with this signature profile are still available and signable.
The ignisign solution does not allow to only sign PDF, all kind of files can be signed.
When you define a signature profile, you are able to define the file format that can be signed.
We differrentiate mainly 4 types of files:
Full Privacy documents are a solution to sign documents that you want to share only to the signers.
IgniSign does not store the document on its platform, and the document is not shared with IgniSign.
This mechanism is very useful when you want to sign a document that contains sensitive information.
You can only sign a Full Privacy document in Embedded integration mode.
How it works:
There are 2 ways to integrate Signature Sessions with your application
Attention. Integration of the Signature Sessions is not the same things that the integration of your backend throw API.
In the United States, the Electronic Signatures in Global and National Commerce (ESIGN) Act and the Uniform Electronic Transactions Act (UETA) are the main federal and state laws governing digital signatures, respectively.
In the European Union, the eIDAS regulation (Electronic Identification, Authentication and Trust Services) is the legal framework for electronic identification and trust services for electronic transactions in the internal market.
These laws and regulations establish that digital signatures and records are legal, enforceable, and valid as long as certain requirements are met.
Both ESIGN (US) and eIDAS (EU) make a clear distinction between Electronic/Simple and Digital/Advanced/Qualified signatures.
Under certain conditions, ie Qualified Signature in the EU, they're equivalent to a notarized signature.
At Ignisign, we offer 3 differents levels regarding the legally binding:
You can select this level when you define a Signature Profile
Depending on the level you select, the requirement about the Identification and Authentication are different.
Signers are the people who will sign the documents.
You do not share your signers, and related due diligence you have done with them with other IgniSign clients!
Signers are segregated by applications and environments.
So, if you have 2 applications, the same person will be two different signer.
The Same signer can sign Signature Request that are related to different Signature Profile
Signers have claims. Claims are the information that have to be "verified" to be able to sign the document.
Some Claims are related to the identification, others to the authentication.
Signature Profiles define the claims that are needed to sign the document.
When signers launch a Signature Session , Identification or Authentication Registration could be prompted to the signer to VERIFY
or DECLARE
some claims needed to properly sign the documents
To create a signer that match requirements of a Signature Profiles , you have to create a signer with the good inputs (to declare the related claims).
To know which inputs are needed, you can use the API call Get Signer Creation Constraints
This information is also available in the IgniSign Console, in the Signature Profiles section.
If you have a signer that is already created, but need to add some inputs, you can update it with the API call Update Signer.
This principle of claims could be a little bit complex to understand, but it's one of the key elements that allow IgniSign to be able to sign.
Globally you do not have to manage it, IgniSign do it for You
Often, people don't realy understand the difference between Identification and Authentication.
In the Electronic Signature world, it's very important to distinguish them.
Depending of the level of signature, the identification could be Declared
or Verified
.
Declare
the identity of the signer and send the request to the signer.Verified
.
We offer different mechanisms to verify the identity of the signer:
An Automatic Video Onboarding:
The signer is invited to make a video of himself and to show his Id document (passport, ID card, driving licence, etc.)
A Open Banking Identification:
The signer is invited to connect to his bank account and to share his identity.
No data about his account except his identity and the IBAN of his main account is stored by our services.
A Social Security Number Verification (US only):
The Signer is invited to share his SSN. We verify the SSN with the Social Security Administration (SSA) and the IRS.
An eID (electronic Identity) identification (EU only):
The signer is identified throw his eID.
We verify the eID with an eIDAS Node. High, Subtantial level are accepted (Notified or not Notified)
A Delegated Identification:
The signer is verifier by the organization that initiate the signature request.
An Online Qualified Onboarding:
The signer is invited to make a video of himself and to show his Id document (passport, ID card, driving licence, etc.)
The elements are verified by a human operator. This processus is compliant with the eIDAS regulation.
An eID (electronic Identity) identification (EU only):
The signer is identified throw his eID. We verify the eID with an eIDAS Node.
High Notified identity only are accepted.
A Delegated Identification.
The signer is verifier by the organization that initiate the signature request.
Authentication of the signers is used validate ...
Based on requirements defined into the Signature Profile, different configuration are available
Legally Binding Level | First Factor | Second Factor |
---|---|---|
Electronic/Simple | BySide: Email-Token Embedded: Signer-Secret |
N/A |
Digital/Advanced | BySide: Email-Token Embedded: Signer-Secret |
- SMS-Nonce - TOPT - PassKey - eID |
Digital/Qualified | BySide: Email-Token Embedded: Signer-Secret |
- SMS-Nonce - TOPT - PassKey - eID |
When you use an Electronic/Simple signature, only one factor is required. When you use a Digital/Advanced or Digital/Qualified signature, two factors are mandatory.
below, a description of the different authentication methods available:
Email-Token
The signer receive an email with a link to access to a Signature Session.
The link contains a token that is used to authenticate the signer.
Email-Nonce
The signer receive an email with a secret (6 numbers).
The Signer have to input them during the Signature Session.
This authentication method is used in the Electronic/Simple signature level in the case of an embedded signature because it's mandatory that Ignisign keep at least one authentication factor on its sole control.
Signer-Secret
When the signer is created, a secret is generated and sent to the application by Webhook
The application have to provide the secret when the Signature Session. is initialized.
More information about this method is available in the Delegation of Authentication section
SMS-Nonce
The signer receive a SMS with a secret (6 numbers).
The Signer have to input them during the Signature Session.
TOPT
The signer initialize the TOTP during a authentication registration session (almost always linked to an Identification Session)
This intialization is done by scanning a QRCode with a mobile authentication application (Google Authenticator, Authy, ...)
The Signer have to input the secret generated by the application during the Signature Session.
PassKey
The signer initialize a PassKey during a authentication registration session (almost always linked to an Identification Session).
The signer is invited to use its PassKey during the Signature Session.
PassKey is a technology linked to the W3C's WebAuthn standard..
This technology have been selected by Google, Apple And Microsoft to replace passwords (article)
This technology is mostly available on all modern browsers except Firefox for Now more info
eID
The signer use its eID to authenticate itself.
Signature Requests are the primary method to initiate the signing process on the IgniSign platform.
Users can easily create a signature request using the IgniSign Console Or through API.
The process involves selecting a Signature Profile, entering a title and description, providing signer information, and uploading documents to be signed.
The Signer can also ask for a document to someone else (Document Request principle),
or associate some statements to a document or globally to a signature request( the signer need to check these statements before be able to sign the document).
Once the request is created:
By Side
an email is sent to the signer inviting them to participate in the signature session. Embedded
the information to initiate the signature session with the Ignisign JS SDK are sent through a Webhook EventYou can create a signature request using the Ignisign Console or through the API.
You can find below a sequence diagram that describe the signature request creation process.
%%{init: {'theme':'default'}}%%
sequenceDiagram
participant App_Backend as App Backend
participant IgniSign_API as IgniSign API
App_Backend ->> IgniSign_API : Initialize a Signature Request
Note over App_Backend, IgniSign_API : Create signers if needed<br/> You can reuse existing signers
opt
App_Backend ->> IgniSign_API : Get Signer Creation Constraints
# Note over App_Backend, IgniSign_API : Optional <br/>but useful to know the constraints
end
loop For all new signers
App_Backend ->> IgniSign_API : Create a Signer
end
Note over App_Backend, IgniSign_API : Add documents
loop For all documents
App_Backend ->> IgniSign_API : Initialize a Document
App_Backend ->> IgniSign_API : Provide Document Content <br/>or Create a Document Request
# Note over App_Backend, IgniSign_API : Providing document could be <br>- File or PDF, Data Json or Private file<br/><br/>- or create a Document Request
end
Note over App_Backend, IgniSign_API : Finalize the signature request
App_Backend ->> IgniSign_API : Update a Signature Request
App_Backend ->> IgniSign_API : Publish a Signature Request
API calls used to create Signature Requests
Global Signature Request calls
Signers related api calls
Document related calls
Signature sessions are an integral part of the IgniSign electronic signature platform. When a user initiates a signature request, the recipient receives an email inviting them to sign the provided document. Upon clicking the link in the email, the recipient is redirected to the signature page, marking the beginning of a signature session. This session ensures that the signer has a seamless experience while signing the document. The session's integration mode can either be "By Side," where IgniSign manages the entire process, or "Embedded," where the signature process is integrated directly into the user's application. The choice of integration mode can be defined in the Signature Profile.
By Side
an email is sent to the signer inviting them to participate in the signature session. Embedded
the information to initiate the signature session with the Ignisign JS SDK are sent through a Webhook EventDuring the signature session, a Identification Session and An Authentication Registration Session can be Initialized if the signer does not match the requierement regarding the claims of the signature profile.
This mechanism is fully managed by Ignisign, You don't have anything to do on this part.
Once this first phase is finished, the signer is invited to review documents, check statements, and sign the document.
If an Authentication is required, the signer will be invited to authenticate himself before being able to sign the document.
Once finalized, a confirmation is provided to the signer, and the signature session is closed.
If the signature mechanism failed(unexpected error - should not happens), the signature session is closed and the signer is invited to retry the signature session. the signatures session is set as FAILED
and a webhook is triggered
Signature proofs serve as evidence of the signing process's authenticity and integrity. The Signature proofs availables are:
Hereunder a summary of the file available to stakeholders when the documents are signed. These documents depend on the signed document format:
Main Documents
Signed document format | Original file | Signature Proof (as a PDF) | Signature Proof (only signature summary) |
Zip file (Proof + File) |
---|---|---|---|---|
Yes | Yes | No | No | |
"PDFable" image | Yes | Yes | No | No |
Other Files | Yes | No | Yes | Yes |
Data with Template | Rendered Template | Yes | No | No |
Data without Template | Yes (Raw Data) | No | Yes | Yes |
Private File | No | No | Yes | No |
Secondary Documents
Signed document format | Signature Summary Picture | Signature Picture (Per Signer) |
Certificate linked to the signatures | Xades | Asic-E |
---|---|---|---|---|---|
Yes | Yes | Yes | Yes | Yes | |
"PDFable" image | Yes | Yes | Yes | Yes | Yes |
Other Files | Yes | Yes | Yes | Yes | Yes |
Data with Template | Yes | Yes | Yes | Yes | Yes |
Data without Template | Yes | Yes | Yes | Yes | Yes |
Private File | Yes | Yes | Yes | Yes | No |
Documents available in the "Signature Proof" Html page
Signed document format | Original file | Signature Proof | Zip file (Proof + File) | Advanced Proof | Certificate linked to the signatures |
---|---|---|---|---|---|
Yes | full PDF | No | Asic-E | Yes | |
"PDFable" image | Yes | full PDF | No | Asic-E | Yes |
Other Files | Yes | Signature Summary | Yes | Asic-E | Yes |
Data with Template | Rendered Template | full PDF | No | Asic-E | Yes |
Data without Template | Yes (Raw Data) | Signature Summary | Yes | Asic-E | Yes |
Private File | No (View Hash) | Signature Summary | No | Xades | Yes |
At IgniSign, we take signature mechanisms very seriously.
We have a strong infrastructure to ensure security and have analyzed for a long time the best way to implement signatures that match the needs of companies.
We especially take care of the Legally Binding aspect of the signatures we provide.
But we also take care of the User Experience for our customers and their customers.
In the Signature market, we primarily encounter two types of platforms:
Additionally to Signature Profiles,
a principle that helps you define the signature mechanism you want to use, we have also created a principle of Delegation of Authentication and Identification.
The principle stems from the fact that applications sometimes have strong mechanisms to authenticate users and employees.
When an organization wants to integrate a signature mechanism within its application, generally,most of the time, it has already authenticated its users by the time it launches the signature session.
Similarly, the application might have already identified its users in a robust manner and may want to use this identification to sign a document.
Many signature platforms don't permit the reuse of these elements, which can significantly diminish the user experience or the legal validity of the signature.
So, Delegation of Authentication and Identification is introduced to address these issues.
Most of the digital signature platforms restrict the reuse of these credentials, which can adversely impact both the user experience.
To tackle these challenges and protect the legal authenticity of the signature, the concept of Delegation of Authentication and Identification has been introduced.
By delegating a factor of authentication or a full identification, IgniSign builds on your processes and partners with your company to deliver a user-friendly and legally binding signature.
Those delegations are independent and depend on where your company is comfortable taking responsibility.
To activate the delegation mechanism in your organization's production, due diligence must be done, and a Legal representative of your organization must sign a contract with IgniSign.
All procedures to activate delegation mechanisms are available through the IgniSign Console,
under the Organization > Organization Settings > Delegation
section.
3 Delegations are available:
Delegation of Authentication:
Only available in embedded integration mode.
It allows IgniSign to delegate 1 of the 2 factors of authentication to the application.
The application must have already authenticated the user before launching the signature session.
IgniSign will only ask the user to provide the second factor of authentication during a signature session (Regarding legal requirements, it's mandatory that IgniSign keeps on its sole control at least one of the authentication factor).
This mechanism works based on a signerSecret that is generated when a signer is created in IgniSign.
This signerSecret is provided to the application as a result of signature creation, both by the webhook mechanism and in the response to the API Call.
This secret must be provided by the application to IgniSign when the signature session is launched.
More information regarding this integration is available in the IgniSign JS SDK, Signers, and Webhooks event documentation.
Delegation of Identification for Advanced Electronic Signature:
This delegation mechanism allows IgniSign to delegate the identification of the signer to the organization.
The organization becomes accountable for these identifications, and proof of identification might be requested in case of litigation.
Regarding the integration, no further identification mechanism will be asked of the signer during the signature session.
Delegation of Identification for Qualified Electronic Signature: (Available soon)
This delegation mechanism allows IgniSign to delegate the identification of the signer to the organization.
This is a more complex mechanism that requires adherence to a strict process provided by IgniSign.
The process of identification within your organization becomes auditable by IgniSign according to the EiDAS regulation.
A preliminary analysis of your organization will be done by IgniSign to ensure that your organization is capable of following the process.
This documentation guides you through the Node.js implementation of the Ignisign API SDK, simplifying the integration of Ignisign API with your backend.
Before you begin, ensure you have an API key and defined webhook endpoints. Detailed instructions for setting these up can be found in the Integrate Ignisign with your Backend section.
Install the library via npm:
npm install @ignisign/sdk
Additionally, consider installing the @ignisign/public
package, which includes all types utilized by the library. While it's a transitive dependency of @ignisign/sdk
and not mandatory, installing it directly can enhance your development experience, especially for IDE import mechanisms.
npm install @ignisign/public
Find an example of integration in this GitHub repository.
Begin by initiating the IgnisignSdk
class:
import { IgnisignSdk } from "@ignisign/sdk"
const ignisignSdkInstance = new IgnisignSdk({
appId: IGNISIGN_APP_ID,
appEnv: (<IGNISIGN_APPLICATION_ENV>IGNISIGN_APP_ENV),
appSecret: IGNISIGN_APP_SECRET,
displayWarning: true,
});
Find your appId
, appEnv
, and appSecret
in the "API Keys" section of the Ignisign Console.
The application environment
should be one of the following:
enum IGNISIGN_APPLICATION_ENV {
DEVELOPMENT = "DEVELOPMENT",
STAGING = "STAGING",
PRODUCTION = "PRODUCTION",
}
The IgnisignSdk
class exposes all API endpoints as methods for easy access.
async function createNewSigner(
signatureProfileId,
inputs: { [key in IGNISIGN_SIGNER_CREATION_INPUT_REF] ?: string } = {},
externalId: string = null): Promise<IgnisignSigner_CreationResponseDto> {
const dto: IgnisignSigner_CreationRequestDto = {
signatureProfileId,
...inputs,
...(externalId && {externalId})
};
try {
return await ignisignSdkInstance.createSigner(dto);
} catch (error) {
console.error(error.toString());
throw error;
}
}
Easily connect your webhook endpoint to the Ignisign SDK:
router.post('/v1/ignisign-webhook', async (req, res, next) => {
try {
const result = await IgnisignSdkManagerService.consumeWebhook(req.body);
jsonSuccess(res, result);
} catch (e) {
next(e);
}
});
The SDK manages webhook signature verification and calls the appropriate callback method based on the webhook type.
You can register callbacks for various webhook events, as described in the Webhook Events Documentation.
const exampleWebhookCallback = async (
webhookContext: IgnisignWebhookDto,
error: IgnisignError = null,
msgNature?: IGNISIGN_WEBHOOK_MESSAGE_NATURE,
action?: IGNISIGN_WEBHOOK_ACTION_SIGNATURE_REQUEST,
topic?: IGNISIGN_WEBHOOK_TOPICS
): Promise<boolean> => {
console.log("Received webhook", webhookContext, topic, action, msgNature);
return true;
};
await ignisignSdkInstance.registerWebhookCallback(
exampleWebhookCallback,
IGNISIGN_WEBHOOK_TOPICS.SIGNATURE,
IGNISIGN_WEBHOOK_ACTION_SIGNATURE.FINALIZED
);
To streamline the implementation of frequently used webhook callbacks, we've introduced a series of "shortcut" functions. These functions provide an more efficient way to handle common webhook scenarios. Below is a list of these functions:
registerWebhookCallback_Signature(
callback: IgnisignWebhook_Callback<IgnisignWebhookDto_Signature>,
action?: IGNISIGN_WEBHOOK_ACTION_SIGNATURE
): Promise<string>;
registerWebhookCallback_SignatureSession(
callback: IgnisignWebhook_Callback<IgnisignWebhookDto_SignatureSession>,
action?: IGNISIGN_WEBHOOK_ACTION_SIGNATURE_SESSION
): Promise<string>;
registerWebhookCallback_DocumentRequest(
callback: IgnisignWebhook_Callback<IgnisignWebhookDto_DocumentRequest>,
action?: IGNISIGN_WEBHOOK_ACTION_DOCUMENT_REQUEST
): Promise<string>;
registerWebhookCallback_SignatureRequest(
callback: IgnisignWebhook_Callback<IgnisignWebhookDto_SignatureRequest>,
action?: IGNISIGN_WEBHOOK_ACTION_SIGNATURE_REQUEST
): Promise<string>;
registerWebhookCallback_SignatureProfile(
callback: IgnisignWebhook_Callback<IgnisignWebhookDto_SignatureProfile>,
action?: IGNISIGN_WEBHOOK_ACTION_SIGNATURE_PROFILE
): Promise<string>;
registerWebhookCallback_Signer(
callback: IgnisignWebhook_Callback<IgnisignWebhookDto_Signer>,
action?: IGNISIGN_WEBHOOK_ACTION_SIGNER
): Promise<string>;
registerWebhookCallback_SignatureProof(
callback: IgnisignWebhook_Callback<IgnisignWebhookDto_SignatureProof>,
action?: IGNISIGN_WEBHOOK_ACTION_SIGNATURE_PROOF
): Promise<string>;
registerWebhookCallback_SignatureImageGenerated(
callback: IgnisignWebhook_Callback<IgnisignWebhookDto_SignatureImage>,
action?: IGNISIGN_WEBHOOK_ACTION_SIGNATURE_IMAGE
): Promise<string>;
registerWebhookCallback_Application(
callback: IgnisignWebhook_Callback<IgnisignWebhookDto_Application>,
action?: IGNISIGN_WEBHOOK_ACTION_APPLICATION
): Promise<string>;
Here is an example to illustrate how these shortcut functions can be implemented:
const webhookHandler_SignatureRequest = async (
content: IgnisignWebhookDto_SignatureRequest,
error: IgnisignError = null,
msgNature?: IGNISIGN_WEBHOOK_MESSAGE_NATURE,
action?: IGNISIGN_WEBHOOK_ACTION_SIGNATURE_REQUEST,
topic?: IGNISIGN_WEBHOOK_TOPICS
): Promise<any> => {
if (msgNature === IGNISIGN_WEBHOOK_MESSAGE_NATURE.ERROR) {
console.error("handleSignatureRequestWebhookSigners ERROR : ", error);
return;
}
console.log("handleSignatureRequestWebhookSigners : ", content);
};
await ignisignSdkInstance.registerWebhookCallback_SignatureRequest(
webhookHandler_SignatureRequest,
IGNISIGN_WEBHOOK_ACTION_SIGNATURE_REQUEST.LAUNCHED
);
This library facilitates the integration of the Ignisign electronic signature into web-based applications using the embedded
mode.
Alternatively, Ignisign can be integrated in a by side
mode, where users are redirected to the Ignisign platform to sign documents via an email link, with Ignisign managing the entire process.
For detailed information on these integration modes, visit Embedded or By-Side Integration.
If you are looking for the NodeJS Backend library, it is available here.
Install the library using npm:
npm install @ignisign/ignisign-js
An Ignisign account is required, which can be created for free at Ignisign Sign Up.
Find integration examples here.
To use IgnisignJs, first initialize the class. You will need an appId
and an application environment
:
import { IgnisignJs } from "@ignisign/ignisign-js"
const ignisignJs = new IgnisignJs(appId, appEnv);
Find your appId
and appEnv
in the "API Keys" section of the Ignisign Console. The application environment
is defined as:
enum IGNISIGN_APPLICATION_ENV {
DEVELOPMENT = "DEVELOPMENT",
STAGING = "STAGING",
PRODUCTION = "PRODUCTION",
}
To start a signature session, use the initSignatureSession
method of your ignisignJs
instance:
Implement handleSignatureSessionError
to manage errors:
const handleSignatureSessionError = async (
errorCode, errorContext, signerId, signatureRequestId
) : Promise<void> => {
// Error handling logic here
}
handleSignatureSessionError
Params
errorCode
: The error codeerrorContext
: A context that will help you to understand from where the error comes fromsignerId
: The id of the signersignatureRequestId
: The id of the signature requestFor handling the completion of signatures, use handleSignatureSessionFinalized
:
const handleSignatureSessionFinalized = async (
signatureIds, signerId, signatureRequestId
) : Promise<void> => {
// Finalization logic here
}
handleSignatureSessionFinalized
params
signatureIds
: The ids of the signatures signerId
: The id of the signersignatureRequestId
: The id of the signature requFor private file info provisioning, implement handlePrivateFileInfoProvisioning
:
const handlePrivateFileInfoProvisioning = async (
documentId, externalDocumentId, signerId, signatureRequestId
): Promise<IgnisignDocument_PrivateFileDto> => {
// Logic to retrieve private file information
}
handlePrivateFileInfoProvisioning
params
documentId
: The id of the document to signexternalDocumentId
: An reference that refers to the document to sign into your application - You have to provide it when you provide the document to IgnisignsignerId
: The id of the signersignatureRequestId
: The id of the signature requestIgnisignPrivateFileDto
fields
fileUrl
: The url of the file to signmimeType
: The mime type of the file to signfileName
: The name of the file to signbearer
: Optional - A bearer token to access the file - if provided, the bearer token will be placed into the Authorization header of the requestDefine the initialization parameters for the signature session:
const initParams: IgnisignJS_SignatureSession_Initialization_Params = {
htmlElementId : "my-div-signature-request-request-id",
signatureRequestId : "6490205421ac2fXXXXX" ,
signerId : "6490205421ac2fXXXXX",
signatureSessionToken : "6490205421ac2fXXXXXXXXXXXXXXXXXXXXXXXXXXX",
signerAuthSecret : "6490205421ac2fXXXXX" ,
closeOnFinish : true,
sessionCallbacks : {
handleSignatureRequestError,
handleSignatureRequestFinalized,
handlePrivateFileInfoProvisioning,
}
dimensions : {
width: "100%",
height: "500px",
},
displayOptions : {
showTitle : false,
showDescription : false,
darkMode : false,
forceShowDocumentInformations : false
}
}
await ignisignJs.initSignatureSession(initParams);
IgnisignJS_SignatureRequest_Initialization_Params fields informations
htmlElementId
: The id of the html element that will contain the signature request iframesignatureRequestId
: The id of the signature request - this value is provided to your backend by webhook when the signature request is createdsignerId
: The id of the signer - this value is provided to your backend by webhook when the signature request is createdsignatureSessionToken
: The unique token that allows you to access to the signature request for the signer - This value is provided to your backend by webhook when the signature request is createdsignerAuthSecret
: The secret that allows you to authenticate the signer - This value is provided to your backend by webhook when the signer is createdcloseOnFinish
: OPTIONAL - default true - If true, the signature request iframe will be closed automatically in case of finalization or error sessionCallbacks
: OPTIONAL The callbacks that will be called when the signature request iframe send a message to the parent windowsessionCallbacks.handlePrivateFileInfoProvisioning
:OPTIONAL - This method must be implemented if the signature profile linked to the signature request is configured to use a private files. If you want to close automatically the signature request iframe when the signature request is finalized, you can set the closeOnFinish parameter to true when you call the initSignatureRequest methodsessionCallbacks.handleSignatureRequestError
: RECOMMENDED - This method must be implemented if you want to handle the signature request errors.sessionCallbacks.handleSignatureRequestFinalized
: RECOMMENDED - This method must be implemented if you want to handle the signature request finalization.dimensions
: OPTIONAL - The options that will be used to configure the signature request iframedimensions.width
: default: "100%"dimensions.height
: default "500px"displayOptions
: OPTIONAL - Option taht determinate the content displayed into the signing interfacedisplayOptions.showTitle
: default: false - Show the title of the signature request like in by-side modedisplayOptions.showDescription
: default: false - Show the description of the signature request like in by-side modedisplayOptions.darkMode
: default : "Browser" force the darkMode of the content.displayOptions.forceShowDocumentInformations
: default : falseRefer to the Ignisign documentation for detailed parameter descriptions and additional guidance:
To prematurely close a signature session, call cancelSignatureSession
on your ignisignJs
instance:
ignisignJs.cancelSignatureSession();
To be able to use the API, you need to use a JWT that you have to put as a Bearer token in the Authorization header of your requests. The JWT is obtained by calling the Api Authentication endpoint.
sequenceDiagram
participant Client_App as Client App
participant IgniSign_API as IgniSign API
Client_App ->> IgniSign_API : Api Authentication
IgniSign_API -->> Client_App : JWT Token
Client_App ->> IgniSign_API : Api Call 1 with JWT Token
Client_App ->> IgniSign_API : Api Call 2 with JWT Token
Client_App ->> IgniSign_API : Api Call 3 with JWT Token
This endpoint authenticates an application over the Ignisign API.
The identification is related to an environment (appEnv) and an application (appId).
The secret is used to authenticate the application.
If validated, a JWT token is returned that can be used to authenticate the application using a Bearer token.
appId required | string (appId) The application identifier which is used to identify the application used. |
appEnv required | string (IGNISIGN_APPLICATION_ENV) Enum: "DEVELOPMENT" "STAGING" "PRODUCTION" The execution environment of the application where request are executed. |
secret required | string The secret related to the application and the environment. |
{- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "secret": "sk_development_XXXX-XXXX-XXXX-XXXX-XXXX"
}
{- "jwtToken": "string"
}
Ignisign offer a wide range of signature profiles.
Because requirements related to the signers vary between them, this endpoint allow you to determinate the inputs needed to create a signer.
This information is fix for a given signature profile, so It's not needed to check these values before each signer creation.
This information is also available in the Ignisign Console.
this method is a part of the Signature Request Creation Api Life Cycle.
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
appEnv required | string Enum: "DEVELOPMENT" "STAGING" "PRODUCTION" The execution environment of the application where request are executed. |
signatureProfileId required | string The unique identifier of the signature profile. |
[- {
- "inputsNeeded": [
- "firstName"
]
}
]
This endpoint allow you to determinate the missing inputs needed to use a signer in a specific signature profile
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
appEnv required | string Enum: "DEVELOPMENT" "STAGING" "PRODUCTION" The execution environment of the application where request are executed. |
signerId required | string The unique identifier of the signer to be revoked. |
signatureProfileId required | string The unique identifier of the signature profile. |
[- "firstName"
]
This endpoint creates a new signer.
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
appEnv required | string Enum: "DEVELOPMENT" "STAGING" "PRODUCTION" The execution environment of the application where request are executed. |
The details to create a signer (IgnisignSigner_CreationRequestDto).
signatureProfileId required | string The unique identifier of the signature profile that the signer must be compatible to. The signer could be compatible to multiple signature profiles if he match the claims required to be compatible with. more info: https://doc.ignisign.io/#tag/Signers-and-Claims |
externalId | string An external identifier that can be used to identify the signer. It's a reference that can be used to identify the signer in the external system. Ignisign does not use internally this field to identify the signer. |
firstName | string The first name of the signer. |
lastName | string The last name of the signer. |
string The email address of the signer. | |
phoneNumber | string <E.164> the phone number of the signer. |
nationality | string <iso 3166-1 alpha-2> The nationality of the signer. |
birthDate | string <date> the date of birth of the signer. |
birthPlace | string the place of birth of the signer. |
birthCountry | string <iso 3166-1 alpha-2> the country of birth of the signer. |
{- "signatureProfileId": "string",
- "externalId": "string",
- "firstName": "string",
- "lastName": "string",
- "email": "string",
- "phoneNumber": "string",
- "nationality": "string",
- "birthDate": "2019-08-24",
- "birthPlace": "string",
- "birthCountry": "string"
}
{- "signerId": "string",
- "entityType": "NATURAL",
- "authSecret": "string"
}
This endpoint retrieves details for a specific signer.
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
appEnv required | string Enum: "DEVELOPMENT" "STAGING" "PRODUCTION" The execution environment of the application where request are executed. |
signerId required | string The unique identifier of the signer. |
{- "signerId": "string",
- "externalId": "string",
- "firstName": "string",
- "lastName": "string",
- "email": "string",
- "status": "CREATED",
- "claims": [
- {
- "claimRef": "EID_POSSESSION_AES",
- "status": "DECLARED"
}
], - "latestSignatureRequests": [
- {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "signatureProfileId": "string",
- "title": "string",
- "description": "string",
- "expirationDate": "2019-08-24T14:15:22Z",
- "expirationDateIsActivated": true,
- "status": "DRAFT",
- "language": "EN",
- "documentIds": [
- "string"
], - "externalId": "string",
- "diffusionMode": "WHEN_READY",
- "diffusionDate": "2019-08-24T14:15:22Z",
- "signerIds": [
- "string"
], - "signedBy": [
- "string"
], - "_createdAt": "2019-08-24T14:15:22Z",
- "isFakeIdProofing": true,
- "isFakeSms": true,
- "creatorId": "string",
- "docFileName": "string",
- "docLabel": "string"
}
]
}
This endpoint a summary of information for a specific signer.
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
appEnv required | string Enum: "DEVELOPMENT" "STAGING" "PRODUCTION" The execution environment of the application where request are executed. |
signerId required | string The unique identifier of the signer to be revoked. |
{- "signerId": "string",
- "externalId": "string",
- "firstName": "string",
- "lastName": "string",
- "email": "string",
- "status": "CREATED",
- "alreadyProvidedInputs": [
- "firstName"
]
}
This endpoint update a signer ( only field additions are possible ).
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
appEnv required | string Enum: "DEVELOPMENT" "STAGING" "PRODUCTION" The execution environment of the application where request are executed. |
signerId required | string The unique identifier of the signer to be revoked. |
The details to update a signer (IgnisignSigner_UpdateRequestDto).
signerId required | string The unique identifier of the signer to be updated. |
signatureProfileId required | string The unique identifier of the signature profile that the signer must be compatible to. The signer could be compatible to multiple signature profiles if he match the claims required to be compatible with. more info: https://doc.ignisign.io/#tag/Signers-and-Claims |
externalId | string An external identifier that can be used to identify the signer. It's a reference that can be used to identify the signer in the external system. Ignisign does not use internally this field to identify the signer. |
firstName | string The first name of the signer. |
lastName | string The last name of the signer. |
string The email address of the signer. | |
phoneNumber | string <E.164> the phone number of the signer. |
nationality | string <iso 3166-1 alpha-2> The nationality of the signer. |
birthDate | string <date> the date of birth of the signer. |
birthPlace | string the place of birth of the signer. |
birthCountry | string <iso 3166-1 alpha-2> the country of birth of the signer. |
{- "signerId": "string",
- "signatureProfileId": "string",
- "externalId": "string",
- "firstName": "string",
- "lastName": "string",
- "email": "string",
- "phoneNumber": "string",
- "nationality": "string",
- "birthDate": "2019-08-24",
- "birthPlace": "string",
- "birthCountry": "string"
}
{- "signerId": "string",
- "entityType": "NATURAL",
- "authSecret": "string"
}
This endpoint revokes a signer.
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
appEnv required | string Enum: "DEVELOPMENT" "STAGING" "PRODUCTION" The execution environment of the application where request are executed. |
signerId required | string The unique identifier of the signer to be revoked. |
{- "signerId": "string"
}
This endpoint searches for signers within an application based on a filter.
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
appEnv required | string Enum: "DEVELOPMENT" "STAGING" "PRODUCTION" The execution environment of the application where request are executed. |
filter | string |
{- "signers": [
- {
- "signerId": "string",
- "externalId": "string",
- "firstName": "string",
- "lastName": "string",
- "email": "string",
- "status": "CREATED",
- "alreadyProvidedInputs": [
- "firstName"
]
}
], - "total": 0
}
This endpoint retrieves signers within an application for a specific page.
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
appEnv required | string Enum: "DEVELOPMENT" "STAGING" "PRODUCTION" The execution environment of the application where request are executed. |
page | integer |
{- "signers": [
- {
- "signerId": "string",
- "externalId": "string",
- "firstName": "string",
- "lastName": "string",
- "email": "string",
- "status": "CREATED",
- "alreadyProvidedInputs": [
- "firstName"
]
}
], - "total": 0
}
This endpoint allow to initialize a document.
A document is linked to a signature request.
Before providing the content of the document, each document need to be initialized.
This create a document object that will be used to link document.
This method is a part of the Signature Request Creation Api Life Cycle.
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
appEnv required | string Enum: "DEVELOPMENT" "STAGING" "PRODUCTION" The execution environment of the application where request are executed. |
The document initialization information.
signatureRequestId required | string The unique identifier of the signature request associated with the document initialization. |
label | string A user-friendly label to identify the document. |
description | string A detailed, human-readable description of the document. |
externalId | string An optional external identifier that can be used to reference the document from external systems. It's a free text. Ignisign's system do not interprete it. |
{- "signatureRequestId": "string",
- "label": "string",
- "description": "string",
- "externalId": "string"
}
{- "documentId": "string"
}
This endpoint creates a document request.
A document request is linked to a signature request.
This method is a part of the Signature Request Creation Api Life Cycle.
documentId required | string The unique identifier of the document. |
The document request details.
target required | string (IGNISIGN_DOCUMENT_REQUEST_TARGET) Enum: "APPLICATION" "USER" The target of the document request. |
documentId required | string The unique identifier of the document associated with this request. |
externalId | string An optional external identifier that can be used to reference the document request from external systems. |
firstName | string The first name of the user associated with the document request. |
lastName | string The last name of the user associated with the document request. |
string The email address of the user associated with the document request. required if the target value is 'USER' |
{- "target": "APPLICATION",
- "documentId": "string",
- "externalId": "string",
- "firstName": "string",
- "lastName": "string",
- "email": "string"
}
{- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "externalId": "string",
- "documentNature": "PDF",
- "fileName": "string",
- "fileSize": 0,
- "label": "string",
- "description": "string",
- "mimeType": "string",
- "documentHash": "string",
- "status": "CREATED",
- "documentRequestId": "string",
- "signatureRequestId": "string",
- "dataJsonContent": "string",
- "relatedDocumentId": "string",
- "relatedDocumentType": "PDF",
- "_createdAt": "2019-08-24T14:15:22Z"
}
This endpoint retrieves the context of a specific document.
documentId required | string The unique identifier of the document. |
{- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "externalId": "string",
- "documentNature": "PDF",
- "fileName": "string",
- "fileSize": 0,
- "label": "string",
- "description": "string",
- "mimeType": "string",
- "documentHash": "string",
- "status": "CREATED",
- "documentRequestId": "string",
- "signatureRequestId": "string",
- "_createdAt": "2019-08-24T14:15:22Z",
- "statements": [
- {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "signatureRequestId": "string",
- "documentId": "string",
- "target": "SIGNATURE_REQUEST",
- "labelMd": "string"
}
], - "documentRequest": {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "signatureRequestId": "string",
- "documentId": "string",
- "target": "APPLICATION",
- "status": "CREATED",
- "externalId": "string",
- "user": {
- "firstName": "string",
- "lastName": "string",
- "email": "string"
}
}, - "signatureSummaries": [
- {
- "signatureId": "string",
- "signerId": "string",
- "date": "2019-08-24T14:15:22Z"
}
]
}
This endpoint retrieves specific documents information.
documentId required | string The unique identifier of the document. |
{- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "externalId": "string",
- "documentNature": "PDF",
- "fileName": "string",
- "fileSize": 0,
- "label": "string",
- "description": "string",
- "mimeType": "string",
- "documentHash": "string",
- "status": "CREATED",
- "documentRequestId": "string",
- "signatureRequestId": "string",
- "dataJsonContent": "string",
- "relatedDocumentId": "string",
- "relatedDocumentType": "PDF",
- "_createdAt": "2019-08-24T14:15:22Z"
}
This endpoint allows to update information about a specific document.
documentId required | string The unique identifier of the document. |
The document details for update.
label | string A user-friendly label to identify the document. |
description | string A detailed, human-readable description of the document. |
externalId | string An optional external identifier that can be used to reference the document from external systems. It's a free text. Ignisign's system do not interprete it. |
{- "label": "string",
- "description": "string",
- "externalId": "string"
}
{- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "externalId": "string",
- "documentNature": "PDF",
- "fileName": "string",
- "fileSize": 0,
- "label": "string",
- "description": "string",
- "mimeType": "string",
- "documentHash": "string",
- "status": "CREATED",
- "documentRequestId": "string",
- "signatureRequestId": "string",
- "dataJsonContent": "string",
- "relatedDocumentId": "string",
- "relatedDocumentType": "PDF",
- "_createdAt": "2019-08-24T14:15:22Z"
}
This endpoint downloads the original document before if was signed.
documentId required | string The unique identifier of the document. |
{- "message": "string",
- "timestamp": "2019-08-24T14:15:22Z",
- "status": 0,
- "code": "string",
- "context": { }
}
This endpoint provides file content for a document.
This method is a part of the Signature Request Creation Api Life Cycle.
documentId required | string The unique identifier of the document. |
Content-Type required | string The content type of the file. |
Content-Disposition required | string The content disposition of the file. |
The file content details for a document.
file | string <binary> |
{- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "externalId": "string",
- "documentNature": "PDF",
- "fileName": "string",
- "fileSize": 0,
- "label": "string",
- "description": "string",
- "mimeType": "string",
- "documentHash": "string",
- "status": "CREATED",
- "documentRequestId": "string",
- "signatureRequestId": "string",
- "dataJsonContent": "string",
- "relatedDocumentId": "string",
- "relatedDocumentType": "PDF",
- "_createdAt": "2019-08-24T14:15:22Z"
}
This endpoint provides data json content for a document. This method is a part of the Signature Request Creation Api Life Cycle.
documentId required | string The unique identifier of the document. |
The document details.
jsonContent required | object The JSON object that will be signed. |
{- "jsonContent": { }
}
{- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "externalId": "string",
- "documentNature": "PDF",
- "fileName": "string",
- "fileSize": 0,
- "label": "string",
- "description": "string",
- "mimeType": "string",
- "documentHash": "string",
- "status": "CREATED",
- "documentRequestId": "string",
- "signatureRequestId": "string",
- "dataJsonContent": "string",
- "relatedDocumentId": "string",
- "relatedDocumentType": "PDF",
- "_createdAt": "2019-08-24T14:15:22Z"
}
This endpoint provides private content for a document.
This method is a part of the Signature Request Creation Api Life Cycle.
documentId required | string The unique identifier of the document. |
The private content for the document.
documentHash required | string the SHA-256 hash of the document that will be signed. |
{- "documentHash": "string"
}
{- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "externalId": "string",
- "documentNature": "PDF",
- "fileName": "string",
- "fileSize": 0,
- "label": "string",
- "description": "string",
- "mimeType": "string",
- "documentHash": "string",
- "status": "CREATED",
- "documentRequestId": "string",
- "signatureRequestId": "string",
- "dataJsonContent": "string",
- "relatedDocumentId": "string",
- "relatedDocumentType": "PDF",
- "_createdAt": "2019-08-24T14:15:22Z"
}
This endpoint removes the content of a specific document.
documentId required | string The unique identifier of the document. |
{- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "externalId": "string",
- "documentNature": "PDF",
- "fileName": "string",
- "fileSize": 0,
- "label": "string",
- "description": "string",
- "mimeType": "string",
- "documentHash": "string",
- "status": "CREATED",
- "documentRequestId": "string",
- "signatureRequestId": "string",
- "dataJsonContent": "string",
- "relatedDocumentId": "string",
- "relatedDocumentType": "PDF",
- "_createdAt": "2019-08-24T14:15:22Z"
}
This endpoint retrieves the context of a signature request identified by the signature request ID.
signatureRequestId required | string The unique identifier of the signature request to be closed. |
{- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "signatureProfileId": "string",
- "title": "string",
- "description": "string",
- "expirationDate": "2019-08-24T14:15:22Z",
- "expirationDateIsActivated": true,
- "status": "DRAFT",
- "language": "EN",
- "documentIds": [
- "string"
], - "externalId": "string",
- "diffusionMode": "WHEN_READY",
- "diffusionDate": "2019-08-24T14:15:22Z",
- "signerIds": [
- "string"
], - "signedBy": [
- "string"
], - "_createdAt": "2019-08-24T14:15:22Z",
- "isFakeIdProofing": true,
- "isFakeSms": true,
- "creatorId": "string",
- "templateDisplayerId": "string",
- "templateDisplayerVersion": 0,
- "signers": [
- {
- "signerId": "string",
- "externalId": "string",
- "firstName": "string",
- "lastName": "string",
- "email": "string",
- "status": "CREATED",
- "alreadyProvidedInputs": [
- "firstName"
]
}
], - "documents": [
- {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "externalId": "string",
- "documentNature": "PDF",
- "fileName": "string",
- "fileSize": 0,
- "label": "string",
- "description": "string",
- "mimeType": "string",
- "documentHash": "string",
- "status": "CREATED",
- "documentRequestId": "string",
- "signatureRequestId": "string",
- "_createdAt": "2019-08-24T14:15:22Z",
- "statements": [
- {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "signatureRequestId": "string",
- "documentId": "string",
- "target": "SIGNATURE_REQUEST",
- "labelMd": "string"
}
], - "documentRequest": {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "signatureRequestId": "string",
- "documentId": "string",
- "target": "APPLICATION",
- "status": "CREATED",
- "externalId": "string",
- "user": {
- "firstName": "string",
- "lastName": "string",
- "email": "string"
}
}, - "signatureSummaries": [
- {
- "signatureId": "string",
- "signerId": "string",
- "date": "2019-08-24T14:15:22Z"
}
]
}
], - "statements": [
- {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "signatureRequestId": "string",
- "documentId": "string",
- "target": "SIGNATURE_REQUEST",
- "labelMd": "string"
}
], - "signatureProfile": {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "orgId": "string",
- "name": "string",
- "status": "PUBLISHED",
- "integrationMode": "BY_SIDE",
- "signatureMethodRef": "SIMPLE_STD",
- "idProofings": [
- "VIDEO_ROBOT_AES"
], - "authMethods": [
- "SIMPLE"
], - "documentTypes": [
- "PDF"
], - "documentRequestActivated": true,
- "defaultLanguage": "EN",
- "languageCanBeChanged": true,
- "authSessionEnabled": true,
- "statementsEnabled": true,
- "templateDisplayerId": "string",
- "createdByDefault": true
}, - "applicationMetadata": {
- "appName": "string",
- "logoB64": "string",
- "colors": {
- "primary": {
- "50": "string",
- "100": "string",
- "200": "string",
- "300": "string",
- "400": "string",
- "500": "string",
- "600": "string",
- "700": "string",
- "800": "string",
- "900": "string",
- "A100": "string",
- "A200": "string",
- "A400": "string",
- "A700": "string"
}, - "secondary": {
- "50": "string",
- "100": "string",
- "200": "string",
- "300": "string",
- "400": "string",
- "500": "string",
- "600": "string",
- "700": "string",
- "800": "string",
- "900": "string",
- "A100": "string",
- "A200": "string",
- "A400": "string",
- "A700": "string"
}
}
}, - "signatureProofsUrl": "string",
- "signatureProofStatus": "NOT_INITIALIZED"
}
This endpoint retrieves all signature requests for a given application and environment.
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
appEnv required | string Enum: "DEVELOPMENT" "STAGING" "PRODUCTION" The execution environment of the application where request are executed. |
page | integer The page number to return. |
{- "signatureRequests": [
- {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "signatureProfileId": "string",
- "title": "string",
- "description": "string",
- "expirationDate": "2019-08-24T14:15:22Z",
- "expirationDateIsActivated": true,
- "status": "DRAFT",
- "language": "EN",
- "documentIds": [
- "string"
], - "externalId": "string",
- "diffusionMode": "WHEN_READY",
- "diffusionDate": "2019-08-24T14:15:22Z",
- "signerIds": [
- "string"
], - "signedBy": [
- "string"
], - "_createdAt": "2019-08-24T14:15:22Z",
- "isFakeIdProofing": true,
- "isFakeSms": true,
- "creatorId": "string",
- "docFileName": "string",
- "docLabel": "string"
}
], - "paginationData": {
- "total": 0,
- "page": 0,
- "nbEventsPerPage": 0
}
}
This endpoint initializes a new signature request for a given application and environment. This method is a part of the Signature Request Creation Api Life Cycle.
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
appEnv required | string Enum: "DEVELOPMENT" "STAGING" "PRODUCTION" The execution environment of the application where request are executed. |
The signature profile ID.
signatureProfileId required | string |
{- "signatureProfileId": "string"
}
{- "signatureRequestId": "string"
}
This endpoint updates a signature request identified by the signature request ID.
This methos is a partial update, that means that you can update only the fields you want to update.
The signature request must be in DRAFT
state to be able to be updated.
documentIds
and signerIds
are optional but must be globally provided to be able to PUBLISH
the signature request.
That means that you need to provide them at least one time
This method is a part of the Signature Request Creation Api Life Cycle.
signatureRequestId required | string The unique identifier of the signature request to be closed. |
The signature request details.
title | string |
description | string |
expirationDate | string <date-time> |
expirationDateIsActivated | boolean |
language | string (IGNISIGN_SIGNATURE_LANGUAGES) Enum: "EN" "FR" "DE" Represents the languages for signatures supported by a signature profile. |
documentIds | Array of strings |
externalId | string |
diffusionMode | string (IGNISIGN_SIGNATURE_REQUEST_DIFFUSION_MODE) Enum: "WHEN_READY" "SCHEDULED" Represents the diffusion mode of a signature request.
|
diffusionDate | string <date-time> |
Array of objects (IgnisignSignatureRequest_Statement) | |
signerIds | Array of strings |
{- "title": "string",
- "description": "string",
- "expirationDate": "2019-08-24T14:15:22Z",
- "expirationDateIsActivated": true,
- "language": "EN",
- "documentIds": [
- "string"
], - "externalId": "string",
- "diffusionMode": "WHEN_READY",
- "diffusionDate": "2019-08-24T14:15:22Z",
- "statements": [
- {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "signatureRequestId": "string",
- "documentId": "string",
- "target": "SIGNATURE_REQUEST",
- "labelMd": "string"
}
], - "signerIds": [
- "string"
]
}
{- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "signatureProfileId": "string",
- "title": "string",
- "description": "string",
- "expirationDate": "2019-08-24T14:15:22Z",
- "expirationDateIsActivated": true,
- "status": "DRAFT",
- "language": "EN",
- "documentIds": [
- "string"
], - "externalId": "string",
- "diffusionMode": "WHEN_READY",
- "diffusionDate": "2019-08-24T14:15:22Z",
- "signerIds": [
- "string"
], - "signedBy": [
- "string"
], - "_createdAt": "2019-08-24T14:15:22Z",
- "isFakeIdProofing": true,
- "isFakeSms": true,
- "creatorId": "string",
- "templateDisplayerId": "string",
- "templateDisplayerVersion": 0,
- "signers": [
- {
- "signerId": "string",
- "externalId": "string",
- "firstName": "string",
- "lastName": "string",
- "email": "string",
- "status": "CREATED",
- "alreadyProvidedInputs": [
- "firstName"
]
}
], - "documents": [
- {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "externalId": "string",
- "documentNature": "PDF",
- "fileName": "string",
- "fileSize": 0,
- "label": "string",
- "description": "string",
- "mimeType": "string",
- "documentHash": "string",
- "status": "CREATED",
- "documentRequestId": "string",
- "signatureRequestId": "string",
- "_createdAt": "2019-08-24T14:15:22Z",
- "statements": [
- {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "signatureRequestId": "string",
- "documentId": "string",
- "target": "SIGNATURE_REQUEST",
- "labelMd": "string"
}
], - "documentRequest": {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "signatureRequestId": "string",
- "documentId": "string",
- "target": "APPLICATION",
- "status": "CREATED",
- "externalId": "string",
- "user": {
- "firstName": "string",
- "lastName": "string",
- "email": "string"
}
}, - "signatureSummaries": [
- {
- "signatureId": "string",
- "signerId": "string",
- "date": "2019-08-24T14:15:22Z"
}
]
}
], - "statements": [
- {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "signatureRequestId": "string",
- "documentId": "string",
- "target": "SIGNATURE_REQUEST",
- "labelMd": "string"
}
], - "signatureProfile": {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "orgId": "string",
- "name": "string",
- "status": "PUBLISHED",
- "integrationMode": "BY_SIDE",
- "signatureMethodRef": "SIMPLE_STD",
- "idProofings": [
- "VIDEO_ROBOT_AES"
], - "authMethods": [
- "SIMPLE"
], - "documentTypes": [
- "PDF"
], - "documentRequestActivated": true,
- "defaultLanguage": "EN",
- "languageCanBeChanged": true,
- "authSessionEnabled": true,
- "statementsEnabled": true,
- "templateDisplayerId": "string",
- "createdByDefault": true
}, - "applicationMetadata": {
- "appName": "string",
- "logoB64": "string",
- "colors": {
- "primary": {
- "50": "string",
- "100": "string",
- "200": "string",
- "300": "string",
- "400": "string",
- "500": "string",
- "600": "string",
- "700": "string",
- "800": "string",
- "900": "string",
- "A100": "string",
- "A200": "string",
- "A400": "string",
- "A700": "string"
}, - "secondary": {
- "50": "string",
- "100": "string",
- "200": "string",
- "300": "string",
- "400": "string",
- "500": "string",
- "600": "string",
- "700": "string",
- "800": "string",
- "900": "string",
- "A100": "string",
- "A200": "string",
- "A400": "string",
- "A700": "string"
}
}
}, - "signatureProofsUrl": "string",
- "signatureProofStatus": "NOT_INITIALIZED"
}
This endpoint allow to publish a signature request identified by the signature request ID.
documentIds
and signerIds
must be provided at least one time with the signature request method to be able to publish the signature request.
This method is a part of the Signature Request Creation Api Life Cycle.
signatureRequestId required | string The unique identifier of the signature request to be published. |
{- "signatureRequestId": "string"
}
This endpoint closes a signature request identified by the signature request ID.
signatureRequestId required | string The unique identifier of the signature request to be closed. |
{- "signatureRequestId": "string"
}
This endpoint retrieves all signature profiles for a given application.
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
appEnv required | string Enum: "DEVELOPMENT" "STAGING" "PRODUCTION" The execution environment of the application where request are executed. |
[- {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "orgId": "string",
- "name": "string",
- "status": "PUBLISHED",
- "integrationMode": "BY_SIDE",
- "signatureMethodRef": "SIMPLE_STD",
- "idProofings": [
- "VIDEO_ROBOT_AES"
], - "authMethods": [
- "SIMPLE"
], - "documentTypes": [
- "PDF"
], - "documentRequestActivated": true,
- "defaultLanguage": "EN",
- "languageCanBeChanged": true,
- "authSessionEnabled": true,
- "statementsEnabled": true,
- "templateDisplayerId": "string",
- "createdByDefault": true
}
]
This endpoint updates the status of a signature profile for a given application.
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
appEnv required | string Enum: "DEVELOPMENT" "STAGING" "PRODUCTION" The execution environment of the application where request are executed. |
signatureProfileId required | string The unique identifier of the signature profile. |
The status of the signature profile.
status required | string (IGNISIGN_SIGNATURE_PROFILE_STATUS) Enum: "PUBLISHED" "ARCHIVED" Represents the current status of a signature profile in the Ignisign application. |
{- "status": "PUBLISHED"
}
{- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "orgId": "string",
- "name": "string",
- "status": "PUBLISHED",
- "integrationMode": "BY_SIDE",
- "signatureMethodRef": "SIMPLE_STD",
- "idProofings": [
- "VIDEO_ROBOT_AES"
], - "authMethods": [
- "SIMPLE"
], - "documentTypes": [
- "PDF"
], - "documentRequestActivated": true,
- "defaultLanguage": "EN",
- "languageCanBeChanged": true,
- "authSessionEnabled": true,
- "statementsEnabled": true,
- "templateDisplayerId": "string",
- "createdByDefault": true
}
This endpoint allows for downloading a signatures description of a document.
documentId required | string The unique identifier of the document. |
signatureId required | string The unique identifier of the signature. |
{- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "signerId": "string",
- "signerKeyId": "string",
- "sessionId": "string",
- "documentId": "string",
- "status": "INIT",
- "mode": "SERVER_SIDE_SIGNATURE",
- "ocspCheckValue": null,
- "contentHash": "string",
- "signature": "string",
- "signatureValue": "string",
- "signedProperties": "string",
- "signedPropertiesHash": "string",
- "signingIp": "string",
- "signingTime": "string",
- "certificate": "string"
}
This endpoint allows for downloading all signatures description of a document.
documentId required | string The unique identifier of the document. |
[- {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "signerId": "string",
- "signerKeyId": "string",
- "sessionId": "string",
- "documentId": "string",
- "status": "INIT",
- "mode": "SERVER_SIDE_SIGNATURE",
- "ocspCheckValue": null,
- "contentHash": "string",
- "signature": "string",
- "signatureValue": "string",
- "signedProperties": "string",
- "signedPropertiesHash": "string",
- "signingIp": "string",
- "signingTime": "string",
- "certificate": "string"
}
]
This endpoint allows for downloading the signature proof document.
documentId required | string The unique identifier of the document. |
{- "message": "string",
- "timestamp": "2019-08-24T14:15:22Z",
- "status": 0,
- "code": "string",
- "context": { }
}
This endpoint allows for downloading the XAdES of a document's signature. more informations
documentId required | string The unique identifier of the document. |
signatureId required | string The unique identifier of the signature. |
{- "message": "string",
- "timestamp": "2019-08-24T14:15:22Z",
- "status": 0,
- "code": "string",
- "context": { }
}
This endpoint allows for downloading the ASIC file of a document. We provide ASIC Extended files (ASIC-E) more information
documentId required | string The unique identifier of the document. |
{- "message": "string",
- "timestamp": "2019-08-24T14:15:22Z",
- "status": 0,
- "code": "string",
- "context": { }
}
This endpoint retrieves the image of a signature from a document.
documentId required | string The unique identifier of the document. |
{- "documentId": "string",
- "signatures": [
- {
- "signerId": "string",
- "imgB64": "string"
}
]
}
This endpoint retrieves webhook endpoints configurated for an environment.
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
appEnv required | string Enum: "DEVELOPMENT" "STAGING" "PRODUCTION" The execution environment of the application where request are executed. |
[- {
- "_id": "string",
- "url": "string",
- "description": "string",
- "_createdAt": "2019-08-24T14:15:22Z"
}
]
This endpoint adds a new webhook endpoint to an application environment.
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
appEnv required | string Enum: "DEVELOPMENT" "STAGING" "PRODUCTION" The execution environment of the application where request are executed. |
The details of the webhook endpoint to be added.
url required | string The URL where the webhook endpoint will send data to. This is a required property. |
description | string A human-readable description of the webhook endpoint. This can be used for documentation or additional context. |
{- "url": "string",
- "description": "string"
}
{- "_id": "string",
- "url": "string",
- "description": "string",
- "_createdAt": "2019-08-24T14:15:22Z"
}
This endpoint updates an existing webhook endpoint.
webhookId required | string The unique identifier of the webhook. |
The new details of the webhook endpoint to be updated.
url required | string The URL where the webhook endpoint will send data to. This is a required property. |
description | string A human-readable description of the webhook endpoint. This can be used for documentation or additional context. |
{- "url": "string",
- "description": "string"
}
{- "_id": "string",
- "url": "string",
- "description": "string",
- "_createdAt": "2019-08-24T14:15:22Z"
}
This endpoint removes an existing webhook endpoint.
webhookId required | string The unique identifier of the webhook. |
{- "_id": "string",
- "url": "string",
- "description": "string",
- "_createdAt": "2019-08-24T14:15:22Z"
}
This endpoint retrieves webhook events for a specific webhook.
webhookId required | string The unique identifier of the webhook. |
filter | string (IGNISIGN_WEBHOOK_EVENT_FILTER) Enum: "ALL" "SUCCESS" "FAILED" |
page | integer |
{- "events": [
- {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "webhookId": "string",
- "topic": "ALL",
- "action": "INITIALIZED",
- "msgNature": "INFO",
- "content": { },
- "error": { },
- "response": {
- "status": 0,
- "statusText": "string"
}, - "status": "SUCCESS",
- "_createdAt": "2019-08-24T14:15:22Z"
}
], - "searchData": {
- "total": 0,
- "page": 0,
- "nbEventsPerPage": 0
}
}
This endpoint retrieves a specific webhook event.
webhookId required | string The unique identifier of the webhook. |
eventId required | string The unique identifier of the event. |
{- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "webhookId": "string",
- "topic": "ALL",
- "action": "INITIALIZED",
- "msgNature": "INFO",
- "content": { },
- "error": { },
- "response": {
- "status": 0,
- "statusText": "string"
}, - "status": "SUCCESS",
- "_createdAt": "2019-08-24T14:15:22Z"
}
This endpoint resends a specific webhook event.
webhookId required | string The unique identifier of the webhook. |
eventId required | string The unique identifier of the event to be resent. |
{- "message": "string",
- "timestamp": "2019-08-24T14:15:22Z",
- "status": 0,
- "code": "string",
- "context": { }
}
This is the description of the call that is made to your application when a webhook event is triggered. All following events are typed event that are transmitted to you in the body of the request. SDKs treat automatically these calls and provide to you a callback registration mecanism of typed events.
Global object that contains the webhook event data.
appId required | string (appId) The application identifier which is used to identify the application used. |
appEnv required | string (IGNISIGN_APPLICATION_ENV) Enum: "DEVELOPMENT" "STAGING" "PRODUCTION" The execution environment of the application where request are executed. |
verificationToken required | string The token that could be used to verify the origin of the request see Webhook Verification |
topic required | string (IGNISIGN_WEBHOOK_TOPICS) Enum: "ALL" "APP" "SIGNATURE" "SIGNATURE_REQUEST" "SIGNER" "DOCUMENT_REQUEST" "SIGNATURE_PROFILE" "SIGNATURE_SESSION" "SIGNATURE_PROOF" "SIGNATURE_SIGNER_IMAGE" "ID_PROOFING" "SIGNER_AUTH" Represents the topic related to a webhook event in the Ignisign application. |
required | IGNISIGN_WEBHOOK_ACTION_SIGNATURE_REQUEST (string) or IGNISIGN_WEBHOOK_ACTION_SIGNATURE_SESSION (string) or IGNISIGN_WEBHOOK_ACTION_SIGNATURE (string) or IGNISIGN_WEBHOOK_ACTION_SIGNER (string) or IGNISIGN_WEBHOOK_ACTION_DOCUMENT_REQUEST (string) or IGNISIGN_WEBHOOK_ACTION_SIGNATURE_IMAGE (string) or IGNISIGN_WEBHOOK_ACTION_SIGNATURE_PROFILE (string) or IGNISIGN_WEBHOOK_ACTION_SIGNATURE_PROOF (string) or IGNISIGN_WEBHOOK_ACTION_APPLICATION (string) or IGNISIGN_WEBHOOK_ACTION_ALL (string) (IgnisignWebhook_Action) |
msgNature required | string (IGNISIGN_WEBHOOK_MESSAGE_NATURE) Enum: "INFO" "SUCCESS" "WARNING" "ERROR" Represents the nature or type of a message associated with a webhook event in the Ignisign application. |
required | IgnisignWebhookDto_SignatureSession (object) or IgnisignWebhookDto_DocumentRequest (object) or IgnisignWebhookDto_SignatureRequest (object) or IgnisignWebhookDto_SignatureProfile (object) or IgnisignWebhookDto_Signer (object) or IgnisignWebhookDto_Signature (object) or IgnisignWebhookDto_SignatureImage (object) or IgnisignWebhookDto_SignatureProof (object) or IgnisignWebhookDto_Application (object) (IgnisignWebhookDto) |
object (IgnisignError) |
{- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "verificationToken": "string",
- "topic": "ALL",
- "action": "INITIALIZED",
- "msgNature": "INFO",
- "content": {
- "signerId": "string",
- "signatureRequestId": "string",
- "signatureRequestExternalId": "string",
- "signerExternalId": "string"
}, - "error": {
- "errorCode": "BAD_REQUEST",
- "message": "string",
- "context": { }
}
}
Webhooks for signature related events
topic | string Value: "SIGNATURE" |
object (IgnisignWebhookDto_Signature) | |
action | string (IGNISIGN_WEBHOOK_ACTION_SIGNATURE) Enum: "FINALIZED" "FAILED" |
msgNature | string (IGNISIGN_WEBHOOK_MESSAGE_NATURE) Enum: "INFO" "SUCCESS" "WARNING" "ERROR" Represents the nature or type of a message associated with a webhook event in the Ignisign application. |
object (IgnisignError) |
{- "topic": "SIGNATURE",
- "content": {
- "appId": "string",
- "appEnv": "DEVELOPMENT",
- "documentNature": "PDF",
- "signerId": "string",
- "signerExternalId": "string",
- "documentId": "string",
- "documentExternalId": "string",
- "signatureRequestId": "string",
- "signatureRequestExternalId": "string",
- "signatureId": "string"
}, - "action": "FINALIZED",
- "msgNature": "INFO",
- "error": {
- "errorCode": "BAD_REQUEST",
- "message": "string",
- "context": { }
}
}
Webhooks for signature request related events. The actions 'CANCELLED' and 'EXPIRED' actions are only used for cases where no one has signed. iIf at least one person has signed and the signature request expires or is canceled, the 'COMPLETED' action is sent."
topic | string Value: "SIGNATURE_REQUEST" |
object (IgnisignWebhookDto_SignatureRequest) | |
action | string (IGNISIGN_WEBHOOK_ACTION_SIGNATURE_REQUEST) Enum: "INITIALIZED" "UPDATED" "READY" "WAITING_DOCUMENTS" "LAUNCHED" "CANCELLED" "EXPIRED" "COMPLETED" |
msgNature | string (IGNISIGN_WEBHOOK_MESSAGE_NATURE) Enum: "INFO" "SUCCESS" "WARNING" "ERROR" Represents the nature or type of a message associated with a webhook event in the Ignisign application. |
object (IgnisignError) |
{- "topic": "SIGNATURE_REQUEST",
- "content": {
- "signatureRequestId": "string",
- "signatureRequestExternalId": "string",
- "status": "DRAFT",
- "signers": [
- {
- "signerId": "string",
- "signerExternalId": "string",
- "token": "string"
}
]
}, - "action": "INITIALIZED",
- "msgNature": "INFO",
- "error": {
- "errorCode": "BAD_REQUEST",
- "message": "string",
- "context": { }
}
}
Webhooks for signature profile related events
topic | string Value: "SIGNATURE_PROFILE" |
object (IgnisignWebhookDto_SignatureProfile) | |
action | string (IGNISIGN_WEBHOOK_ACTION_SIGNATURE_PROFILE) Enum: "CREATED" "ARCHIVED" |
msgNature | string (IGNISIGN_WEBHOOK_MESSAGE_NATURE) Enum: "INFO" "SUCCESS" "WARNING" "ERROR" Represents the nature or type of a message associated with a webhook event in the Ignisign application. |
object (IgnisignError) |
{- "topic": "SIGNATURE_PROFILE",
- "content": {
- "signatureProfileId": "string"
}, - "action": "CREATED",
- "msgNature": "INFO",
- "error": {
- "errorCode": "BAD_REQUEST",
- "message": "string",
- "context": { }
}
}
Webhooks for signature proof related events
topic | string Value: "SIGNATURE_PROOF" |
object (IgnisignWebhookDto_SignatureProof) | |
action | string (IGNISIGN_WEBHOOK_ACTION_SIGNATURE_PROOF) Enum: "GENERATED" "ADV_GENERATED" |
msgNature | string (IGNISIGN_WEBHOOK_MESSAGE_NATURE) Enum: "INFO" "SUCCESS" "WARNING" "ERROR" Represents the nature or type of a message associated with a webhook event in the Ignisign application. |
object (IgnisignError) |
{- "topic": "SIGNATURE_PROOF",
- "content": {
- "appId": "string",
- "appEnv": "DEVELOPMENT",
- "documentId": "string",
- "documentExternalId": "string",
- "signatureRequestId": "string",
- "signatureRequestExternalId": "string"
}, - "action": "GENERATED",
- "msgNature": "INFO",
- "error": {
- "errorCode": "BAD_REQUEST",
- "message": "string",
- "context": { }
}
}
Webhooks for signature session related events
topic | string Value: "SIGNATURE_SESSION" |
object (IgnisignWebhookDto_SignatureSession) | |
action | string (IGNISIGN_WEBHOOK_ACTION_SIGNATURE_SESSION) Value: "INITIALIZED" |
msgNature | string (IGNISIGN_WEBHOOK_MESSAGE_NATURE) Enum: "INFO" "SUCCESS" "WARNING" "ERROR" Represents the nature or type of a message associated with a webhook event in the Ignisign application. |
object (IgnisignError) |
{- "topic": "SIGNATURE_SESSION",
- "content": {
- "signerId": "string",
- "signatureRequestId": "string",
- "signatureRequestExternalId": "string",
- "signerExternalId": "string"
}, - "action": "INITIALIZED",
- "msgNature": "INFO",
- "error": {
- "errorCode": "BAD_REQUEST",
- "message": "string",
- "context": { }
}
}
Webhooks for signer related events
topic | string Value: "SIGNER" |
object (IgnisignWebhookDto_Signer) | |
action | string (IGNISIGN_WEBHOOK_ACTION_SIGNER) Enum: "CREATED" "INPUTS_ADDED" |
msgNature | string (IGNISIGN_WEBHOOK_MESSAGE_NATURE) Enum: "INFO" "SUCCESS" "WARNING" "ERROR" Represents the nature or type of a message associated with a webhook event in the Ignisign application. |
object (IgnisignError) |
{- "topic": "SIGNER",
- "content": {
- "appId": "string",
- "appEnv": "DEVELOPMENT",
- "signerId": "string",
- "authSecret": "string",
- "signerExternalId": "string",
- "inputsAdded": [
- "firstName"
]
}, - "action": "CREATED",
- "msgNature": "INFO",
- "error": {
- "errorCode": "BAD_REQUEST",
- "message": "string",
- "context": { }
}
}
Webhooks for signature's image generation related events
topic | string Value: "SIGNATURE_IMAGE" |
object (IgnisignWebhookDto_SignatureImage) | |
action | string (IGNISIGN_WEBHOOK_ACTION_SIGNATURE_IMAGE) Value: "GENERATED" |
msgNature | string (IGNISIGN_WEBHOOK_MESSAGE_NATURE) Enum: "INFO" "SUCCESS" "WARNING" "ERROR" Represents the nature or type of a message associated with a webhook event in the Ignisign application. |
object (IgnisignError) |
{- "topic": "SIGNATURE_IMAGE",
- "content": {
- "appId": "string",
- "appEnv": "DEVELOPMENT",
- "documentId": "string",
- "documentExternalId": "string",
- "signatureRequestId": "string",
- "signatureRequestExternalId": "string",
- "signerId": "string",
- "signerExternalId": "string"
}, - "action": "GENERATED",
- "msgNature": "INFO",
- "error": {
- "errorCode": "BAD_REQUEST",
- "message": "string",
- "context": { }
}
}
Webhooks for documentRequest related events
topic | string Value: "DOCUMENT_REQUEST" |
object (IgnisignWebhookDto_DocumentRequest) | |
action | string |
msgNature | string (IGNISIGN_WEBHOOK_MESSAGE_NATURE) Enum: "INFO" "SUCCESS" "WARNING" "ERROR" Represents the nature or type of a message associated with a webhook event in the Ignisign application. |
object (IgnisignError) |
{- "topic": "DOCUMENT_REQUEST",
- "content": {
- "signatureRequestId": "string",
- "signatureRequestExternalId": "string",
- "documentId": "string",
- "documentExternalId": "string",
- "documentNature": "string",
- "mimeType": "string"
}, - "action": "string",
- "msgNature": "INFO",
- "error": {
- "errorCode": "BAD_REQUEST",
- "message": "string",
- "context": { }
}
}
Webhooks for application related events
topic | string Value: "APPLICATION" |
object (IgnisignWebhookDto_Application) | |
action | string (IGNISIGN_WEBHOOK_ACTION_APPLICATION) Enum: "SETTINGS_UPDATED" "MEMBERSHIP_UPDATED" "ARCHIVED" |
msgNature | string (IGNISIGN_WEBHOOK_MESSAGE_NATURE) Enum: "INFO" "SUCCESS" "WARNING" "ERROR" Represents the nature or type of a message associated with a webhook event in the Ignisign application. |
object (IgnisignError) |
{- "topic": "APPLICATION",
- "content": {
- "userId": "string"
}, - "action": "SETTINGS_UPDATED",
- "msgNature": "INFO",
- "error": {
- "errorCode": "BAD_REQUEST",
- "message": "string",
- "context": { }
}
}
This endpoint retrieves all users who have been invited to an application.
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
[- {
- "_id": "string",
- "email": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "status": "PENDING",
- "roles": {
- "DEVELOPMENT": [
- "ADMIN"
], - "STAGING": [
- "ADMIN"
], - "PRODUCTION": [
- "ADMIN"
]
}
}
]
This endpoint allows to invites a user to an application.
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
The user invitation details.
email required | string The email address of the invited user. |
required | object (IgnisignApplication_Roles) The roles assigned to the invited user for each environments. |
{- "email": "string",
- "roles": {
- "DEVELOPMENT": [
- "ADMIN"
], - "STAGING": [
- "ADMIN"
], - "PRODUCTION": [
- "ADMIN"
]
}
}
{- "_id": "string",
- "email": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "status": "PENDING",
- "roles": {
- "DEVELOPMENT": [
- "ADMIN"
], - "STAGING": [
- "ADMIN"
], - "PRODUCTION": [
- "ADMIN"
]
}
}
This endpoint allows to edit the details of an invitation for an application.
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
userInvitationId required | string The unique identifier of the user invitation.x |
The details to be updated for the invited user.
required | Array of objects (IgnisignApplication_Roles) |
{- "roles": [
- {
- "DEVELOPMENT": [
- "ADMIN"
], - "STAGING": [
- "ADMIN"
], - "PRODUCTION": [
- "ADMIN"
]
}
]
}
{- "_id": "string",
- "email": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "status": "PENDING",
- "roles": {
- "DEVELOPMENT": [
- "ADMIN"
], - "STAGING": [
- "ADMIN"
], - "PRODUCTION": [
- "ADMIN"
]
}
}
This endpoint allow to cancel an invitation to a user for an application.
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
userInvitationId required | string The unique identifier of the user invitation.x |
{- "_id": "string",
- "email": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "status": "PENDING",
- "roles": {
- "DEVELOPMENT": [
- "ADMIN"
], - "STAGING": [
- "ADMIN"
], - "PRODUCTION": [
- "ADMIN"
]
}
}
This endpoint resends an invitation to a user for an application.
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
userInvitationId required | string The unique identifier of the user invitation to be resent. |
{- "_id": "string",
- "email": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "status": "PENDING",
- "roles": {
- "DEVELOPMENT": [
- "ADMIN"
], - "STAGING": [
- "ADMIN"
], - "PRODUCTION": [
- "ADMIN"
]
}
}
This endpoint retrieves the global context of an application.
appId required | string Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX The application identifier which is used to identify the application used. |
{- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appName": "string",
- "status": "ACTIVE",
- "orgId": "string",
- "_createdAt": "2019-08-24T14:15:22Z",
- "config": {
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "orgId": "string"
}, - "envSettings": {
- "DEVELOPMENT": {
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "orgId": "string",
- "appEnv": "DEVELOPMENT",
- "webhooks": [
- {
- "_id": "string",
- "url": "string",
- "description": "string",
- "_createdAt": "2019-08-24T14:15:22Z"
}
], - "appRootUrl": "string",
- "authorizedRedirectionUrls": [
- "string"
], - "isApiKeyGenerated": true
}, - "STAGING": {
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "orgId": "string",
- "appEnv": "DEVELOPMENT",
- "webhooks": [
- {
- "_id": "string",
- "url": "string",
- "description": "string",
- "_createdAt": "2019-08-24T14:15:22Z"
}
], - "appRootUrl": "string",
- "authorizedRedirectionUrls": [
- "string"
], - "isApiKeyGenerated": true
}, - "PRODUCTION": {
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "orgId": "string",
- "appEnv": "DEVELOPMENT",
- "webhooks": [
- {
- "_id": "string",
- "url": "string",
- "description": "string",
- "_createdAt": "2019-08-24T14:15:22Z"
}
], - "appRootUrl": "string",
- "authorizedRedirectionUrls": [
- "string"
], - "isApiKeyGenerated": true
}
}, - "settings": {
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "orgId": "string",
- "customerSupportEmail": "string",
- "defaultLanguage": "EN",
- "logoB64": "string",
- "logoDarkB64": "string",
- "primaryColor": {
- "50": "string",
- "100": "string",
- "200": "string",
- "300": "string",
- "400": "string",
- "500": "string",
- "600": "string",
- "700": "string",
- "800": "string",
- "900": "string",
- "A100": "string",
- "A200": "string",
- "A400": "string",
- "A700": "string"
}, - "secondaryColor": {
- "50": "string",
- "100": "string",
- "200": "string",
- "300": "string",
- "400": "string",
- "500": "string",
- "600": "string",
- "700": "string",
- "800": "string",
- "900": "string",
- "A100": "string",
- "A200": "string",
- "A400": "string",
- "A700": "string"
}
}, - "signatureProfiles": {
- "DEVELOPMENT": [
- {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "orgId": "string",
- "name": "string",
- "status": "PUBLISHED",
- "integrationMode": "BY_SIDE",
- "signatureMethodRef": "SIMPLE_STD",
- "idProofings": [
- "VIDEO_ROBOT_AES"
], - "authMethods": [
- "SIMPLE"
], - "documentTypes": [
- "PDF"
], - "documentRequestActivated": true,
- "defaultLanguage": "EN",
- "languageCanBeChanged": true,
- "authSessionEnabled": true,
- "statementsEnabled": true,
- "templateDisplayerId": "string",
- "createdByDefault": true
}
], - "STAGING": [
- {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "orgId": "string",
- "name": "string",
- "status": "PUBLISHED",
- "integrationMode": "BY_SIDE",
- "signatureMethodRef": "SIMPLE_STD",
- "idProofings": [
- "VIDEO_ROBOT_AES"
], - "authMethods": [
- "SIMPLE"
], - "documentTypes": [
- "PDF"
], - "documentRequestActivated": true,
- "defaultLanguage": "EN",
- "languageCanBeChanged": true,
- "authSessionEnabled": true,
- "statementsEnabled": true,
- "templateDisplayerId": "string",
- "createdByDefault": true
}
], - "PRODUCTION": [
- {
- "_id": "string",
- "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
- "appEnv": "DEVELOPMENT",
- "orgId": "string",
- "name": "string",
- "status": "PUBLISHED",
- "integrationMode": "BY_SIDE",
- "signatureMethodRef": "SIMPLE_STD",
- "idProofings": [
- "VIDEO_ROBOT_AES"
], - "authMethods": [
- "SIMPLE"
], - "documentTypes": [
- "PDF"
], - "documentRequestActivated": true,
- "defaultLanguage": "EN",
- "languageCanBeChanged": true,
- "authSessionEnabled": true,
- "statementsEnabled": true,
- "templateDisplayerId": "string",
- "createdByDefault": true
}
]
}
}