Ignisign's Api (3.0.2)

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.

Create an account

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.

drawing

You just need to validate your email address and you are good to go.

drawing

When you create an account, we automatically create for you:

  • An Organization
  • An Application (with its 3 environments)
  • 4 Signature Profiles

More information about Organizations, Applications and Environments is available here
More information about Signature Profiles is available here

Developing is free !

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

  • Development
  • Staging
  • Production
  • More information about Environments is available here

    drawing

    • 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

    Your First Signature

    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.

    drawing      drawing

    You are now invited to choose a Signature Profile. Choose the one you want and click on "Next" button.

    drawing

    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.

    Main Signature Workflow

    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.

    Integrate Ignisign with your Backend

    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.

    Obtain an API key

    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.

    drawing

    Then click on "Generate API Key" button. drawing

    Define Webhooks Endpoints

    • You can define webhooks endpoints in the "Webhooks" section of the console or with an API call Create Webhook.
    • We recommend to use ngrok to test your webhooks endpoints locally during the development phase
      (we do not have any agreement with them, it's just a great tool and a time saver).
    • You can find more information about Events sent by webhooks in the Webhooks Event section of the documentation.

    You have now different ways to integrate IgniSign with your backend:

    Using our SDK

    For the moment, we only provide a NodeJS SDK. Surely, we will provide other SDKs in the future.

    • The NodeJS SDK is available on NPM.
    • The source code is available on Github
    • The documentation of the SDK is available here
    • An example of integration is available here

    Using our API

    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

    Embedding signature into your application

    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.

    • To ease the integration, we have developed a Javascript SDK that let you to easily embed the signature process into your application.
    • Other SDKs for Android and iOS integration will be available soon.

    Important: To integrate the signature process with an embedded integration into production, you need to validate the Delegation of Authentication process.

    Examples

    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, Applications, Environments

    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.

      • It's a billing unit, so you cannot separate the billing of two applications in the same organization.
        If it's your needs, you need to create two organizations.
      • Regarding Delegation of Authentication and Identification, the process of enrollment is managed at this level

    • Applications: Application are related to a software or a service.
      Each application has 3 environments: DEVELOPMENT, STAGING and PRODUCTION.

      • Signers cannot be shared between applications nor environments.
      • Signature Profiles cannot be shared between applications nor environments.
      • Api Keys are unique by applications and environments.

    Signature Profiles

    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:

    • The Document Type that can be signed.
    • The Integration Mode
    • The Legally Binding value of the signature.
    • The Signer Identification Mechanism that will be available.
    • The Signer Authentication Mechanism that will be available.
    • The Language used during the signature session and if it can be changed.
    • The Availability of Statements that could be linked to a document or to the whole signature session during the Signature Request creation.

    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.

    Documents that can be signed

    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:

    • The PDF: the PDF file format is the most common file format used to sign documents. It is the most used file format to sign documents.

    • Other files format: all other files format that can be signed. The ignisign solution does not allow to only sign PDF, all kind of files can be signed.
      If the document is a PDF compatible image format ( "image/png", "image/jpeg", "image/jpg", "image/gif", "image/bmp", "image/tiff") it will be inserted into the PDF file in the signature proof document.

    • A pure data document (JSON format): the ignisign solution allows to sign a pure data document. The document is a JSON file that contains the data to be signed. The signature is applied on the hash of the JSON file.

    • Full Priviacy Document: The ignisign solution allows to sign a private document. The document is a private document that is not stored on the ignisign platform. The signature is applied on the hash of the private document.More Info

      file formats

    Full Privacy

    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:

    • You create a Signature Request with a Full Privacy document and you provide only the Hash (SHA-256) of the document.
    • When you launch the signature session with the IgniSign JS SDK, the library ask to you to provide an URL where the document is located.
    • IgniSign retrieve the document on the frontend side and check the hash of the document with the hash provided in the signature request.
    • The document is not sent to IgniSign servers, and the document is never stored on IgniSign platform. The document is only kept in the browser memory, into the signer device.
    • If the hash of the document provided match the one provided during the signature request creation, The document is displayed to the signer and the signature session can start.

    Embeded or By-Side Integration

    There are 2 ways to integrate Signature Sessions with your application

    • Embedded:
      The signature session is launched directly into your application. More operationnal explanations about the integration of the signature process into your application are available in the Embedding signature into your application section.
    • By-Side:
      The signature session is fully managed by IgniSign.
      Emails are sent to the signers to invite them to sign documents.
      All interactions with the signers are managed by IgniSign.

    Attention. Integration of the Signature Sessions is not the same things that the integration of your backend throw API.

    • Integration of your backend is mostly used to create signature requests and to retrieve the status of the Signature Requests.
    • Integration of the Signature Sessions is used to integrate the signature process into your application.

    Legally Binding

    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.

    Electronic (simple) signatures

    • Have no identification process
    • Usually use common 1FA electronic authentication methods like email or PINs
    • Are assimilated to an electronic process indicating - but not proving - acceptance
    • Use a provider's internal audit trail as evidence
    • Have a low probative value and are not considered actual signatures

    Digital (Advanced, Qualified) signatures:

    • Have an identification process
    • Use a 2FA electronic authentication method using knowledge, possession and inherent factors
    • Use a digital certificate from a trust service provider (TSP), such as a certificate authority (CA), to authenticate a signer's identity
    • Demonstrates proof of signing by binding the digital certificate associated with each signature to the document using encryption
    • Both certificates' validity and authenticity, and therefore signatures, can be checked independently of the provider
    • Have a high probative value and are considered actual 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:

    • Electronic/Simple signatures
    • Digital/Advanced signatures
    • Digital/Qualified signatures

    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 and Claims

    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

    Signer Identification

    Often, people don't realy understand the difference between Identification and Authentication.
    In the Electronic Signature world, it's very important to distinguish them.

    • Identification is the act of binding a, identity to an actor.
    • Authentication is the act to enable access and features to an actor.

    Depending of the level of signature, the identification could be Declared or Verified.

    • If your signature is Electronic/Simple, the requester Declare the identity of the signer and send the request to the signer.
    • If your signature is Digital/Advanced or Digital/Qualified the identity of the signer must be Verified.

    We offer different mechanisms to verify the identity of the signer:

    Regarding the Digital/Advanced Signature:

    • 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.

    Regarding the Digital/Qualified Signature:

    • 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.

    Signer Authentication

    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

    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:

    Create a Signature Request

    You can create a signature request using the Ignisign Console or through the API.

    Signature Request Creation Api Life Cycle

    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

    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.

    During 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

    Signature proofs serve as evidence of the signing process's authenticity and integrity. The Signature proofs availables are:

    • The Signature Proof Document
      This is the document that will be used in the most of the case to prove the signature.
      There are 1 signature proof document per document signed.
      This document is a PDF document taht contains:
      • If the document that was signed is a PDF document, the document is the merge of the original document with a final page that summarize signatures.

        All the pages of the document are linked with a "cryprographic binder" that ensure the integrity of the document.
        If the document is a PDF compatible image format ( "image/png", "image/jpeg", "image/jpg", "image/gif", "image/bmp", "image/tiff") it will be inserted into the PDF file in the signature proof document.
      • If the document that was signed is not a PDF document, the document is a PDF document that only contains the final page that summarize signatures.

    • The Signature Proof Internet Page
      This is a page that is available on the internet and that can be used to prove the signature.
      This page containts all the information and links that related to the global signature proof process.
      A QR code on the Signature page provide the link to this page.

    • The Signature Picture
      this is a representation of the signature in image format. This image ins individual per signer and per document.

    • A Xades Signature File
      This is a Xades signature file. This file represent technically the signature.
      This signature is individual per document.

    • A Asic Signature File
      This is a Asic-E Container. This file contains mainly the original document signed and the Xades file.
      In case of litigation, this is the file to provide to authorities
      This signature is individual per document.

    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)
    PDF 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
    PDF 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
    PDF 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

    Delegation of Authentication and Identification

    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:

    • The platforms that are very strict on authentication and identification but are very complex to use and integrate.

    • The platforms that are very easy to use but provide a signature without a real legal value
      (Simple Electronic Signature according to the EU's Eidas regulation or "Electronic Signature" according to the US's eSign regulation).

    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.

    NodeJS SDK

    Node.js Implementation of Ignisign API SDK

    This documentation guides you through the Node.js implementation of the Ignisign API SDK, simplifying the integration of Ignisign API with your backend.

    Pre-requisites

    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.

    Installation

    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
    

    Integration Example

    Find an example of integration in this GitHub repository.

    Initiate the IgnisignSdk Class

    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",
    }
    

    Easy API Calls

    The IgnisignSdk class exposes all API endpoints as methods for easy access.

    Example Implementation

    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;
      }
    }
    

    Linking Your Webhook Endpoint to Ignisign SDK

    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.

    Registering Webhook Callbacks

    You can register callbacks for various webhook events, as described in the Webhook Events Documentation.

    Example Webhook Callback Registration:

    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
    );
    

    Simplified Registration of Common Webhook Callbacks

    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>;
    

    Example of Implementation

    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
    );
    

    Ignisign JS

    Integrating Ignisign Signature in Web Applications

    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.

    Installation

    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.

    Examples

    Find integration examples here.

    Usage

    Initializing IgnisignJs Class

    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",
    }
    

    Initializing a Signature Session

    To start a signature session, use the initSignatureSession method of your ignisignJs instance:

    Error Handling

    Implement handleSignatureSessionError to manage errors:

    const handleSignatureSessionError = async (
        errorCode, errorContext, signerId, signatureRequestId
      ) : Promise<void> => {
        // Error handling logic here
      }
    

    handleSignatureSessionError Params

    • errorCode: The error code
    • errorContext: A context that will help you to understand from where the error comes from
    • signerId : The id of the signer
    • signatureRequestId : The id of the signature request

    Finalizing Signatures

    For 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 signer
    • signatureRequestId: The id of the signature requ

    Managing Private File Information

    For 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 sign
    • externalDocumentId : An reference that refers to the document to sign into your application - You have to provide it when you provide the document to Ignisign
    • signerId : The id of the signer
    • signatureRequestId : The id of the signature request

    IgnisignPrivateFileDto fields

    • fileUrl : The url of the file to sign
    • mimeType : The mime type of the file to sign
    • fileName : The name of the file to sign
    • bearer : Optional - A bearer token to access the file - if provided, the bearer token will be placed into the Authorization header of the request

    Signature Session Initialization Parameters

    Define 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 iframe
    • signatureRequestId : The id of the signature request - this value is provided to your backend by webhook when the signature request is created
    • signerId : The id of the signer - this value is provided to your backend by webhook when the signature request is created
    • signatureSessionToken : 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 created
    • signerAuthSecret : The secret that allows you to authenticate the signer - This value is provided to your backend by webhook when the signer is created
    • closeOnFinish : 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 window
    • sessionCallbacks.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 method
    • sessionCallbacks.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 iframe
    • dimensions.width : default: "100%"
    • dimensions.height : default "500px"
    • displayOptions : OPTIONAL - Option taht determinate the content displayed into the signing interface
    • displayOptions.showTitle : default: false - Show the title of the signature request like in by-side mode
    • displayOptions.showDescription : default: false - Show the description of the signature request like in by-side mode
    • displayOptions.darkMode : default : "Browser" force the darkMode of the content.
    • displayOptions.forceShowDocumentInformations : default : false

    Refer to the Ignisign documentation for detailed parameter descriptions and additional guidance:

    Canceling a Signature Session

    To prematurely close a signature session, call cancelSignatureSession on your ignisignJs instance:

    ignisignJs.cancelSignatureSession();
    

    Api Auth

    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  
    

    Api Authentication

    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.

    Authorizations:
    public
    Request Body schema: application/json
    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.
    This secret can be obtained from the Ignisign's Console (https://console.ignisign.io)

    Responses

    Request samples

    Content type
    application/json
    {
    • "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
    • "appEnv": "DEVELOPMENT",
    • "secret": "sk_development_XXXX-XXXX-XXXX-XXXX-XXXX"
    }

    Response samples

    Content type
    application/json
    {
    • "jwtToken": "string"
    }

    Signer

    Get Signer Creation Constraints

    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.

    Authorizations:
    api_key
    path Parameters
    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.

    Responses

    Response samples

    Content type
    application/json
    [
    • {
      }
    ]

    Get missing signer inputs for signature profile

    This endpoint allow you to determinate the missing inputs needed to use a signer in a specific signature profile

    Authorizations:
    api_key
    path Parameters
    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.

    Responses

    Response samples

    Content type
    application/json
    [
    • "firstName"
    ]

    Create a Signer

    This endpoint creates a new signer.

    Authorizations:
    api_key
    path Parameters
    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.

    Request Body schema: application/json

    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.

    email
    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.

    Responses

    Request samples

    Content type
    application/json
    {
    • "signatureProfileId": "string",
    • "externalId": "string",
    • "firstName": "string",
    • "lastName": "string",
    • "email": "string",
    • "phoneNumber": "string",
    • "nationality": "string",
    • "birthDate": "2019-08-24",
    • "birthPlace": "string",
    • "birthCountry": "string"
    }

    Response samples

    Content type
    application/json
    {
    • "signerId": "string",
    • "entityType": "NATURAL",
    • "authSecret": "string"
    }

    Get a Signer with details

    This endpoint retrieves details for a specific signer.

    Authorizations:
    api_key
    path Parameters
    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.

    Responses

    Response samples

    Content type
    application/json
    {
    • "signerId": "string",
    • "externalId": "string",
    • "firstName": "string",
    • "lastName": "string",
    • "email": "string",
    • "status": "CREATED",
    • "claims": [
      ],
    • "latestSignatureRequests": [
      ]
    }

    Get Signer Summary

    This endpoint a summary of information for a specific signer.

    Authorizations:
    api_key
    path Parameters
    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.

    Responses

    Response samples

    Content type
    application/json
    {
    • "signerId": "string",
    • "externalId": "string",
    • "firstName": "string",
    • "lastName": "string",
    • "email": "string",
    • "status": "CREATED",
    • "alreadyProvidedInputs": [
      ]
    }

    Update a Signer

    This endpoint update a signer ( only field additions are possible ).

    Authorizations:
    api_key
    path Parameters
    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.

    Request Body schema: application/json

    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.

    email
    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.

    Responses

    Request samples

    Content type
    application/json
    {
    • "signerId": "string",
    • "signatureProfileId": "string",
    • "externalId": "string",
    • "firstName": "string",
    • "lastName": "string",
    • "email": "string",
    • "phoneNumber": "string",
    • "nationality": "string",
    • "birthDate": "2019-08-24",
    • "birthPlace": "string",
    • "birthCountry": "string"
    }

    Response samples

    Content type
    application/json
    {
    • "signerId": "string",
    • "entityType": "NATURAL",
    • "authSecret": "string"
    }

    Revoke a Signer

    This endpoint revokes a signer.

    Authorizations:
    api_key
    path Parameters
    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.

    Responses

    Response samples

    Content type
    application/json
    {
    • "signerId": "string"
    }

    Search Signers

    This endpoint searches for signers within an application based on a filter.

    Authorizations:
    api_key
    path Parameters
    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.

    query Parameters
    filter
    string

    Responses

    Response samples

    Content type
    application/json
    {
    • "signers": [
      ],
    • "total": 0
    }

    Search Signers - Pagination

    This endpoint retrieves signers within an application for a specific page.

    Authorizations:
    api_key
    path Parameters
    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.

    query Parameters
    page
    integer

    Responses

    Response samples

    Content type
    application/json
    {
    • "signers": [
      ],
    • "total": 0
    }

    Signature Request - Document

    Create a Document

    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.

    Authorizations:
    api_key
    path Parameters
    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.

    Request Body schema: application/json

    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.

    Responses

    Request samples

    Content type
    application/json
    {
    • "signatureRequestId": "string",
    • "label": "string",
    • "description": "string",
    • "externalId": "string"
    }

    Response samples

    Content type
    application/json
    {
    • "documentId": "string"
    }

    Create a Document Request

    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.

    Authorizations:
    api_key
    path Parameters
    documentId
    required
    string

    The unique identifier of the document.

    Request Body schema: application/json

    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.

    email
    string

    The email address of the user associated with the document request. required if the target value is 'USER'

    Responses

    Request samples

    Content type
    application/json
    {
    • "target": "APPLICATION",
    • "documentId": "string",
    • "externalId": "string",
    • "firstName": "string",
    • "lastName": "string",
    • "email": "string"
    }

    Response samples

    Content type
    application/json
    {
    • "_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"
    }

    Get a Document Context

    This endpoint retrieves the context of a specific document.

    Authorizations:
    api_key
    path Parameters
    documentId
    required
    string

    The unique identifier of the document.

    Responses

    Response samples

    Content type
    application/json
    {
    • "_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": [
      ],
    • "documentRequest": {
      },
    • "signatureSummaries": [
      ]
    }

    Get Document Information

    This endpoint retrieves specific documents information.

    Authorizations:
    api_key
    path Parameters
    documentId
    required
    string

    The unique identifier of the document.

    Responses

    Response samples

    Content type
    application/json
    {
    • "_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"
    }

    Update Document Information

    This endpoint allows to update information about a specific document.

    Authorizations:
    api_key
    path Parameters
    documentId
    required
    string

    The unique identifier of the document.

    Request Body schema: application/json

    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.

    Responses

    Request samples

    Content type
    application/json
    {
    • "label": "string",
    • "description": "string",
    • "externalId": "string"
    }

    Response samples

    Content type
    application/json
    {
    • "_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"
    }

    Remove a Document

    This endpoint removes a specific document.

    Authorizations:
    api_key
    path Parameters
    documentId
    required
    string

    The unique identifier of the document.

    Responses

    Response samples

    Content type
    application/json
    {
    • "documentId": "string"
    }

    Download The Original Document

    This endpoint downloads the original document before if was signed.

    Authorizations:
    api_key
    path Parameters
    documentId
    required
    string

    The unique identifier of the document.

    Responses

    Response samples

    Content type
    application/json
    {
    • "message": "string",
    • "timestamp": "2019-08-24T14:15:22Z",
    • "status": 0,
    • "code": "string",
    • "context": { }
    }

    Provide Document Content - File or PDF

    This endpoint provides file content for a document.
    This method is a part of the Signature Request Creation Api Life Cycle.

    Authorizations:
    api_key
    path Parameters
    documentId
    required
    string

    The unique identifier of the document.

    header Parameters
    Content-Type
    required
    string

    The content type of the file.

    Content-Disposition
    required
    string

    The content disposition of the file.

    Request Body schema: multipart/form-data

    The file content details for a document.

    file
    string <binary>

    Responses

    Response samples

    Content type
    application/json
    {
    • "_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"
    }

    Provide Document Content - Data Json

    This endpoint provides data json content for a document. This method is a part of the Signature Request Creation Api Life Cycle.

    Authorizations:
    api_key
    path Parameters
    documentId
    required
    string

    The unique identifier of the document.

    Request Body schema: application/json

    The document details.

    jsonContent
    required
    object

    The JSON object that will be signed.

    Responses

    Request samples

    Content type
    application/json
    {
    • "jsonContent": { }
    }

    Response samples

    Content type
    application/json
    {
    • "_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"
    }

    Provide Document Content - Private file

    This endpoint provides private content for a document.
    This method is a part of the Signature Request Creation Api Life Cycle.

    Authorizations:
    api_key
    path Parameters
    documentId
    required
    string

    The unique identifier of the document.

    Request Body schema: application/json

    The private content for the document.

    documentHash
    required
    string

    the SHA-256 hash of the document that will be signed.

    Responses

    Request samples

    Content type
    application/json
    {
    • "documentHash": "string"
    }

    Response samples

    Content type
    application/json
    {
    • "_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"
    }

    Remove the Document Content

    This endpoint removes the content of a specific document.

    Authorizations:
    api_key
    path Parameters
    documentId
    required
    string

    The unique identifier of the document.

    Responses

    Response samples

    Content type
    application/json
    {
    • "_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"
    }

    Signature Request

    Get a Signature Request Context

    This endpoint retrieves the context of a signature request identified by the signature request ID.

    Authorizations:
    api_key
    path Parameters
    signatureRequestId
    required
    string

    The unique identifier of the signature request to be closed.

    Responses

    Response samples

    Content type
    application/json
    {
    • "_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": [
      ],
    • "externalId": "string",
    • "diffusionMode": "WHEN_READY",
    • "diffusionDate": "2019-08-24T14:15:22Z",
    • "signerIds": [
      ],
    • "signedBy": [
      ],
    • "_createdAt": "2019-08-24T14:15:22Z",
    • "isFakeIdProofing": true,
    • "isFakeSms": true,
    • "creatorId": "string",
    • "templateDisplayerId": "string",
    • "templateDisplayerVersion": 0,
    • "signers": [
      ],
    • "documents": [
      ],
    • "statements": [
      ],
    • "signatureProfile": {
      },
    • "applicationMetadata": {
      },
    • "signatureProofsUrl": "string",
    • "signatureProofStatus": "NOT_INITIALIZED"
    }

    Get Signature Requests - Paginated

    This endpoint retrieves all signature requests for a given application and environment.

    Authorizations:
    api_key
    path Parameters
    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.

    query Parameters
    page
    integer

    The page number to return.

    Responses

    Response samples

    Content type
    application/json
    {
    • "signatureRequests": [
      ],
    • "paginationData": {
      }
    }

    Initialize a Signature Request

    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.

    Authorizations:
    api_key
    path Parameters
    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.

    Request Body schema: application/json

    The signature profile ID.

    signatureProfileId
    required
    string

    Responses

    Request samples

    Content type
    application/json
    {
    • "signatureProfileId": "string"
    }

    Response samples

    Content type
    application/json
    {
    • "signatureRequestId": "string"
    }

    Update a Signature Request

    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.

    Authorizations:
    api_key
    path Parameters
    signatureRequestId
    required
    string

    The unique identifier of the signature request to be closed.

    Request Body schema: application/json

    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.

    • WHEN_READY : The signature request will be sent to the signer as soon it is ready to be signed. This is the default value.
      I.E: If there are no document request, the signature request will be sent to the signer as soon as the signature request is PUBLISHED.
      If there are document request, the signature request will be sent to the signer as soon as all the document request are have been completed.
    • SCHEDULED : The signature request will be sent to the signer at a specific date. This date is specified in the diffusionDate field
    diffusionDate
    string <date-time>
    Array of objects (IgnisignSignatureRequest_Statement)
    signerIds
    Array of strings

    Responses

    Request samples

    Content type
    application/json
    {
    • "title": "string",
    • "description": "string",
    • "expirationDate": "2019-08-24T14:15:22Z",
    • "expirationDateIsActivated": true,
    • "language": "EN",
    • "documentIds": [
      ],
    • "externalId": "string",
    • "diffusionMode": "WHEN_READY",
    • "diffusionDate": "2019-08-24T14:15:22Z",
    • "statements": [
      ],
    • "signerIds": [
      ]
    }

    Response samples

    Content type
    application/json
    {
    • "_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": [
      ],
    • "externalId": "string",
    • "diffusionMode": "WHEN_READY",
    • "diffusionDate": "2019-08-24T14:15:22Z",
    • "signerIds": [
      ],
    • "signedBy": [
      ],
    • "_createdAt": "2019-08-24T14:15:22Z",
    • "isFakeIdProofing": true,
    • "isFakeSms": true,
    • "creatorId": "string",
    • "templateDisplayerId": "string",
    • "templateDisplayerVersion": 0,
    • "signers": [
      ],
    • "documents": [
      ],
    • "statements": [
      ],
    • "signatureProfile": {
      },
    • "applicationMetadata": {
      },
    • "signatureProofsUrl": "string",
    • "signatureProofStatus": "NOT_INITIALIZED"
    }

    Publish a Signature Request

    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.

    Authorizations:
    api_key
    path Parameters
    signatureRequestId
    required
    string

    The unique identifier of the signature request to be published.

    Responses

    Response samples

    Content type
    application/json
    {
    • "signatureRequestId": "string"
    }

    Close a Signature Request

    This endpoint closes a signature request identified by the signature request ID.

    Authorizations:
    api_key
    path Parameters
    signatureRequestId
    required
    string

    The unique identifier of the signature request to be closed.

    Responses

    Response samples

    Content type
    application/json
    {
    • "signatureRequestId": "string"
    }

    Signature Profile

    Get Signature Profiles

    This endpoint retrieves all signature profiles for a given application.

    Authorizations:
    api_key
    path Parameters
    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.

    Responses

    Response samples

    Content type
    application/json
    [
    • {
      }
    ]

    Update a Signature Profile Status

    This endpoint updates the status of a signature profile for a given application.

    Authorizations:
    api_key
    path Parameters
    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.

    Request Body schema: application/json

    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.

    Responses

    Request samples

    Content type
    application/json
    {
    • "status": "PUBLISHED"
    }

    Response samples

    Content type
    application/json
    {
    • "_id": "string",
    • "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
    • "appEnv": "DEVELOPMENT",
    • "orgId": "string",
    • "name": "string",
    • "status": "PUBLISHED",
    • "integrationMode": "BY_SIDE",
    • "signatureMethodRef": "SIMPLE_STD",
    • "idProofings": [
      ],
    • "authMethods": [
      ],
    • "documentTypes": [
      ],
    • "documentRequestActivated": true,
    • "defaultLanguage": "EN",
    • "languageCanBeChanged": true,
    • "authSessionEnabled": true,
    • "statementsEnabled": true,
    • "templateDisplayerId": "string",
    • "createdByDefault": true
    }

    Signature Proof

    Get a Document Signature

    This endpoint allows for downloading a signatures description of a document.

    Authorizations:
    api_key
    path Parameters
    documentId
    required
    string

    The unique identifier of the document.

    signatureId
    required
    string

    The unique identifier of the signature.

    Responses

    Response samples

    Content type
    application/json
    {
    • "_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"
    }

    Get Document Signatures

    This endpoint allows for downloading all signatures description of a document.

    Authorizations:
    api_key
    path Parameters
    documentId
    required
    string

    The unique identifier of the document.

    Responses

    Response samples

    Content type
    application/json
    [
    • {
      }
    ]

    Download a Signature Proof

    This endpoint allows for downloading the signature proof document.

    Authorizations:
    api_key
    path Parameters
    documentId
    required
    string

    The unique identifier of the document.

    Responses

    Response samples

    Content type
    application/json
    {
    • "message": "string",
    • "timestamp": "2019-08-24T14:15:22Z",
    • "status": 0,
    • "code": "string",
    • "context": { }
    }

    Download a Signature XAdES

    This endpoint allows for downloading the XAdES of a document's signature. more informations

    Authorizations:
    api_key
    path Parameters
    documentId
    required
    string

    The unique identifier of the document.

    signatureId
    required
    string

    The unique identifier of the signature.

    Responses

    Response samples

    Content type
    application/json
    {
    • "message": "string",
    • "timestamp": "2019-08-24T14:15:22Z",
    • "status": 0,
    • "code": "string",
    • "context": { }
    }

    Download a Signature ASICs

    This endpoint allows for downloading the ASIC file of a document. We provide ASIC Extended files (ASIC-E) more information

    Authorizations:
    api_key
    path Parameters
    documentId
    required
    string

    The unique identifier of the document.

    Responses

    Response samples

    Content type
    application/json
    {
    • "message": "string",
    • "timestamp": "2019-08-24T14:15:22Z",
    • "status": 0,
    • "code": "string",
    • "context": { }
    }

    Get Signature Images (Base64)

    This endpoint retrieves the image of a signature from a document.

    Authorizations:
    api_key
    path Parameters
    documentId
    required
    string

    The unique identifier of the document.

    Responses

    Response samples

    Content type
    application/json
    {
    • "documentId": "string",
    • "signatures": [
      ]
    }

    Manage Webhooks

    Get Webhook Endpoints

    This endpoint retrieves webhook endpoints configurated for an environment.

    Authorizations:
    api_key
    path Parameters
    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.

    Responses

    Response samples

    Content type
    application/json
    [
    • {
      }
    ]

    Add a new Webhook Endpoint

    This endpoint adds a new webhook endpoint to an application environment.

    Authorizations:
    api_key
    path Parameters
    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.

    Request Body schema: application/json

    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.

    Responses

    Request samples

    Content type
    application/json
    {
    • "url": "string",
    • "description": "string"
    }

    Response samples

    Content type
    application/json
    {
    • "_id": "string",
    • "url": "string",
    • "description": "string",
    • "_createdAt": "2019-08-24T14:15:22Z"
    }

    Update a Webhook Endpoint

    This endpoint updates an existing webhook endpoint.

    Authorizations:
    api_key
    path Parameters
    webhookId
    required
    string

    The unique identifier of the webhook.

    Request Body schema: application/json

    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.

    Responses

    Request samples

    Content type
    application/json
    {
    • "url": "string",
    • "description": "string"
    }

    Response samples

    Content type
    application/json
    {
    • "_id": "string",
    • "url": "string",
    • "description": "string",
    • "_createdAt": "2019-08-24T14:15:22Z"
    }

    Remove a Webhook Endpoint

    This endpoint removes an existing webhook endpoint.

    Authorizations:
    api_key
    path Parameters
    webhookId
    required
    string

    The unique identifier of the webhook.

    Responses

    Response samples

    Content type
    application/json
    {
    • "_id": "string",
    • "url": "string",
    • "description": "string",
    • "_createdAt": "2019-08-24T14:15:22Z"
    }

    Get Webhook Events

    This endpoint retrieves webhook events for a specific webhook.

    Authorizations:
    api_key
    path Parameters
    webhookId
    required
    string

    The unique identifier of the webhook.

    query Parameters
    filter
    string (IGNISIGN_WEBHOOK_EVENT_FILTER)
    Enum: "ALL" "SUCCESS" "FAILED"
    page
    integer

    Responses

    Response samples

    Content type
    application/json
    {
    • "events": [
      ],
    • "searchData": {
      }
    }

    Get a Webhook Event

    This endpoint retrieves a specific webhook event.

    Authorizations:
    api_key
    path Parameters
    webhookId
    required
    string

    The unique identifier of the webhook.

    eventId
    required
    string

    The unique identifier of the event.

    Responses

    Response samples

    Content type
    application/json
    {
    • "_id": "string",
    • "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
    • "appEnv": "DEVELOPMENT",
    • "webhookId": "string",
    • "topic": "ALL",
    • "action": "INITIALIZED",
    • "msgNature": "INFO",
    • "content": { },
    • "error": { },
    • "response": {
      },
    • "status": "SUCCESS",
    • "_createdAt": "2019-08-24T14:15:22Z"
    }

    Resend a Webhook Event

    This endpoint resends a specific webhook event.

    Authorizations:
    api_key
    path Parameters
    webhookId
    required
    string

    The unique identifier of the webhook.

    eventId
    required
    string

    The unique identifier of the event to be resent.

    Responses

    Response samples

    Content type
    application/json
    {
    • "message": "string",
    • "timestamp": "2019-08-24T14:15:22Z",
    • "status": 0,
    • "code": "string",
    • "context": { }
    }

    Check a Webhook Event Token

    this endpoint is used to check the webhook event token

    Authorizations:
    public

    Responses

    Response samples

    Content type
    application/json
    {
    • "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
    • "appEnv": "DEVELOPMENT",
    • "token": "string"
    }

    Webhook Events

    You can find below the list of webhooks events available in IgniSign.

    Webhook Main Callback Webhook

    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.

    Authorizations:
    public
    Request Body schema: application/json

    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)

    Responses

    Request samples

    Content type
    application/json
    {
    • "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
    • "appEnv": "DEVELOPMENT",
    • "verificationToken": "string",
    • "topic": "ALL",
    • "action": "INITIALIZED",
    • "msgNature": "INFO",
    • "content": {
      },
    • "error": {
      }
    }

    Signature Webhooks Webhook

    Webhooks for signature related events

    Authorizations:
    public
    Request Body schema: application/json
    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)

    Responses

    Request samples

    Content type
    application/json
    {
    • "topic": "SIGNATURE",
    • "content": {
      },
    • "action": "FINALIZED",
    • "msgNature": "INFO",
    • "error": {
      }
    }

    Signature Request Webhooks Webhook

    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."

    Authorizations:
    public
    Request Body schema: application/json
    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)

    Responses

    Request samples

    Content type
    application/json
    {
    • "topic": "SIGNATURE_REQUEST",
    • "content": {
      },
    • "action": "INITIALIZED",
    • "msgNature": "INFO",
    • "error": {
      }
    }

    Signature Profile Webhooks Webhook

    Webhooks for signature profile related events

    Authorizations:
    public
    Request Body schema: application/json
    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)

    Responses

    Request samples

    Content type
    application/json
    {
    • "topic": "SIGNATURE_PROFILE",
    • "content": {
      },
    • "action": "CREATED",
    • "msgNature": "INFO",
    • "error": {
      }
    }

    Signature Proof Webhooks Webhook

    Webhooks for signature proof related events

    Authorizations:
    public
    Request Body schema: application/json
    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)

    Responses

    Request samples

    Content type
    application/json
    {
    • "topic": "SIGNATURE_PROOF",
    • "content": {
      },
    • "action": "GENERATED",
    • "msgNature": "INFO",
    • "error": {
      }
    }

    Signature Session Webhooks Webhook

    Webhooks for signature session related events

    Authorizations:
    public
    Request Body schema: application/json
    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)

    Responses

    Request samples

    Content type
    application/json
    {
    • "topic": "SIGNATURE_SESSION",
    • "content": {
      },
    • "action": "INITIALIZED",
    • "msgNature": "INFO",
    • "error": {
      }
    }

    Signer Webhooks Webhook

    Webhooks for signer related events

    Authorizations:
    public
    Request Body schema: application/json
    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)

    Responses

    Request samples

    Content type
    application/json
    {
    • "topic": "SIGNER",
    • "content": {
      },
    • "action": "CREATED",
    • "msgNature": "INFO",
    • "error": {
      }
    }

    Signature Image Generated Webhooks Webhook

    Webhooks for signature's image generation related events

    Authorizations:
    public
    Request Body schema: application/json
    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)

    Responses

    Request samples

    Content type
    application/json
    {
    • "topic": "SIGNATURE_IMAGE",
    • "content": {
      },
    • "action": "GENERATED",
    • "msgNature": "INFO",
    • "error": {
      }
    }

    Document Request Webhooks Webhook

    Webhooks for documentRequest related events

    Authorizations:
    public
    Request Body schema: application/json
    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)

    Responses

    Request samples

    Content type
    application/json
    {
    • "topic": "DOCUMENT_REQUEST",
    • "content": {
      },
    • "action": "string",
    • "msgNature": "INFO",
    • "error": {
      }
    }

    Application Webhooks Webhook

    Webhooks for application related events

    Authorizations:
    public
    Request Body schema: application/json
    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)

    Responses

    Request samples

    Content type
    application/json
    {
    • "topic": "APPLICATION",
    • "content": {
      },
    • "action": "SETTINGS_UPDATED",
    • "msgNature": "INFO",
    • "error": {
      }
    }

    User Invitations

    Get Invited Users

    This endpoint retrieves all users who have been invited to an application.

    Authorizations:
    api_key
    path Parameters
    appId
    required
    string
    Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX

    The application identifier which is used to identify the application used.

    Responses

    Response samples

    Content type
    application/json
    [
    • {
      }
    ]

    Invite a User

    This endpoint allows to invites a user to an application.

    Authorizations:
    api_key
    path Parameters
    appId
    required
    string
    Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX

    The application identifier which is used to identify the application used.

    Request Body schema: application/json

    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.

    Responses

    Request samples

    Content type
    application/json
    {
    • "email": "string",
    • "roles": {
      }
    }

    Response samples

    Content type
    application/json
    {
    • "_id": "string",
    • "email": "string",
    • "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
    • "status": "PENDING",
    • "roles": {
      }
    }

    Edit a User Invitation

    This endpoint allows to edit the details of an invitation for an application.

    Authorizations:
    api_key
    path Parameters
    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

    Request Body schema: application/json

    The details to be updated for the invited user.

    required
    Array of objects (IgnisignApplication_Roles)

    Responses

    Request samples

    Content type
    application/json
    {
    • "roles": [
      ]
    }

    Response samples

    Content type
    application/json
    {
    • "_id": "string",
    • "email": "string",
    • "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
    • "status": "PENDING",
    • "roles": {
      }
    }

    Cancel a User Invitation

    This endpoint allow to cancel an invitation to a user for an application.

    Authorizations:
    api_key
    path Parameters
    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

    Responses

    Response samples

    Content type
    application/json
    {
    • "_id": "string",
    • "email": "string",
    • "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
    • "status": "PENDING",
    • "roles": {
      }
    }

    Resend a User Invitation

    This endpoint resends an invitation to a user for an application.

    Authorizations:
    api_key
    path Parameters
    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.

    Responses

    Response samples

    Content type
    application/json
    {
    • "_id": "string",
    • "email": "string",
    • "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
    • "status": "PENDING",
    • "roles": {
      }
    }

    Applications

    Get Application Context

    This endpoint retrieves the global context of an application.

    Authorizations:
    api_key
    path Parameters
    appId
    required
    string
    Example: appId_XXXX-XXXX-XXXX-XXXX-XXXX

    The application identifier which is used to identify the application used.

    Responses

    Response samples

    Content type
    application/json
    {
    • "appId": "appId_XXXX-XXXX-XXXX-XXXX-XXXX",
    • "appName": "string",
    • "status": "ACTIVE",
    • "orgId": "string",
    • "_createdAt": "2019-08-24T14:15:22Z",
    • "config": {
      },
    • "envSettings": {
      },
    • "settings": {
      },
    • "signatureProfiles": {
      }
    }

    HealthCheck

    Healthcheck

    Get a basic health status of the server. This can be used to check if the server is alive on monitoring systems.

    Authorizations:
    public

    Responses

    Response samples

    Content type
    application/json
    {
    • "isAlive": true
    }