API Integration Quick Win

Quickly implement Ignisign API integration in your applications

Preparation Steps

1. Create an Account

Before integrating Ignisign, you need to create an account.

2. Obtain an API Key

To authenticate your API calls, you'll need an API key:

1. Log in to the Ignisign Console
2. Navigate to your application in the Applications section
3. Click on "API Keys" in the left sidebar
4. Select your environment (Development/Staging/Production)
5. Click "Create API Key"
6. Make note of the API key that starts with skv2_ - you'll need this for all API calls

API Integration

Authentication

All API calls to Ignisign require authentication. Add your API key to the request headers:

const headers = {
'Authorization': 'Bearer skv2_your_api_key_here',
'Content-Type': 'application/json'
};

headers = {
  'Authorization': 'Bearer skv2_your_api_key_here',
  'Content-Type': 'application/json'
}

curl -X POST \
https://api.ignisign.io/v4/signature-requests/one-call-sign \
-H 'Authorization: Bearer skv2_your_api_key_here' \
-H 'Content-Type: application/json' \
-d '{"title":"Contract signature",...}'

Create a Signature Request in One Call

The most straightforward way to implement a signature workflow is to use the "Create Signature Request in One Call" endpoint:

curl -X POST \
https://api.ignisign.io/v4/signature-requests/one-call-sign \
-H 'Authorization: Bearer skv2_your_api_key_here' \
-H 'Content-Type: application/json' \
-d '{
  "title": "Contract signature",
  "signatureMethod": "SIMPLE_STD",
  "signers": [
    {
      "email": "[email protected]",
      "firstName": "John",
      "lastName": "Doe"
    }
  ],
  "documents": [
    {
      "originalName": "contract.pdf",
      "mimeType": "application/pdf",
      "base64": "JVBERi0xLjcKJb...[Base64 encoded content]"
    }
  ]
}'

const { IgnisignClient } = require('ignisign-node');

const client = new IgnisignClient({
applicationId: 'your-application-id',
apiKey: 'skv2_your_api_key_here'
});

const createSignatureRequest = async () => {
// Create a signature request in one call
const signatureRequest = await client.createSignatureRequestInOneCall({
  title: "Contract signature",
  signatureMethod: "SIMPLE_STD",
  signers: [
    {
      email: "[email protected]",
      firstName: "John",
      lastName: "Doe"
    }
  ],
  documents: [
    {
      originalName: "contract.pdf",
      mimeType: "application/pdf",
      base64: "JVBERi0xLjcKJb...[Base64 encoded content]"
    }
  ]
});

return signatureRequest;
};

import requests
import json

def create_signature_request():
  url = "https://api.ignisign.io/v4/signature-requests/one-call-sign"
  
  headers = {
      "Authorization": "Bearer skv2_your_api_key_here",
      "Content-Type": "application/json"
  }
  
  payload = {
      "title": "Contract signature",
      "signatureMethod": "SIMPLE_STD",
      "signers": [
          {
              "email": "[email protected]",
              "firstName": "John",
              "lastName": "Doe"
          }
      ],
      "documents": [
          {
              "originalName": "contract.pdf",
              "mimeType": "application/pdf",
              "base64": "JVBERi0xLjcKJb...[Base64 encoded content]"
              # Or provide a URL where Ignisign can download the document
              # "url": "https://yourdomain.com/documents/contract.pdf"
          }
      ]
  }
  
  response = requests.post(url, headers=headers, json=payload)
  return response.json()

tip

For a full description of the API endpoint parameters and response format, see the Create Signature Request in One Call API documentation.

Signature Workflow

The diagram below shows the basic workflow when creating a signature request:

What Happens Next

After creating a signature request:

1. Signers receive an email with a link to sign the document
2. Signers click the link and complete the signature process
3. After all signers have signed, everyone receives an email with the signed document

Advanced: Implementing Webhook Integration (Optional)

For real-time updates about signature events, you can implement webhook integration:

1. Register a Webhook Endpoint

1. In the Ignisign Console, go to your application settings
2. Navigate to the "Webhooks" section
3. Add a new webhook with your endpoint URL (e.g., `https://yourdomain.com/api/webhooks/ignisign`)
4. Select the events you want to receive (especially "SIGNATURE_PROOF.GENERATED")

2. Implement the Webhook Handler

Create an endpoint in your application to receive webhook events:

// Express.js example
app.post('/api/webhooks/ignisign', (req, res) => {
const webhookData = req.body;

// Verify that the webhook is from Ignisign
// Process different webhook events
if (webhookData.topic === 'SIGNATURE_PROOF' && 
    webhookData.action === 'GENERATED' && 
    webhookData.msgNature === 'SUCCESS') {
  
  // Extract information from the webhook content
  const { 
    signatureRequestId, 
    signatureRequestExternalId,
    signatureProofUrl 
  } = webhookData.content;
  
  // Store the signature proof URL in your database
  // Download the proof if needed
  console.log(`Signature proof generated for request: ${signatureRequestId}`);
  console.log(`Proof URL: ${signatureProofUrl}`);
  
  // You can now download and store the proof
}

// Always respond with 200 OK to acknowledge receipt
res.status(200).send('Webhook received');
});

// Register a callback for the signature proof generation event
client.registerWebhookCallback_SignatureProof(
async ({ content, error, msgNature, action, topic }) => {
  if (msgNature === 'ERROR') {
    console.error("Signature proof generation error:", error);
    return;
  }
  
  const { signatureRequestExternalId, signatureProofUrl } = content;
  console.log("Signature proof generated:", signatureRequestExternalId, signatureProofUrl);
  
  // Store the proof URL or download the proof
  await storeSignatureProof(signatureRequestExternalId, signatureProofUrl);
},
'GENERATED' // The action to listen for
);

// Consume the webhook in your route handler
app.post('/api/webhooks/ignisign', async (req, res) => {
await client.consumeWebhook(req.body);
res.status(200).send('Webhook received');
});

# Flask example
from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/api/webhooks/ignisign', methods=['POST'])
def ignisign_webhook():
  webhook_data = request.json
  
  # Process different webhook events
  if (webhook_data.get('topic') == 'SIGNATURE_PROOF' and 
      webhook_data.get('action') == 'GENERATED' and 
      webhook_data.get('msgNature') == 'SUCCESS'):
      
      # Extract information from the webhook content
      content = webhook_data.get('content', {})
      signature_request_id = content.get('signatureRequestId')
      signature_request_external_id = content.get('signatureRequestExternalId')
      signature_proof_url = content.get('signatureProofUrl')
      
      # Store the signature proof URL in your database
      print(f"Signature proof generated for request: {signature_request_id}")
      print(f"Proof URL: {signature_proof_url}")
      
      # You can now download and store the proof
  
  # Always respond with 200 OK to acknowledge receipt
  return jsonify({"status": "success"}), 200

tip

For more details on handling signature proofs via webhooks, see the Signature Proof Webhooks documentation.

For DIY Users

If you're not a developer, you can achieve similar results using the Ignisign Console:

1. Log in to the Ignisign Console
2. Navigate to your application
3. Go to "Signature Requests" and click "Create New"
4. Follow the on-screen instructions to upload your document and add signers
5. Click "Send" to initiate the signature process

Next Steps

After implementing this quick integration, you might want to explore:

• Main Signature Workflow for a deeper understanding of the signature process
• Embedding Signature Into Your Application to provide an in-app signing experience
• Signature Proof documentation for more details on handling signature proofs