For publicly accessible endpoints that don't require authentication:

formData.append('ddxE_webhookUrl', 'https://yourapp.com/api/signed-docs');

Request to your webhook:

POST https://yourapp.com/api/signed-docs
Content-Type: application/pdf

[Binary PDF data]

For private endpoints requiring authentication (headers, params, custom logic):

Step 1: Encrypt Your Configuration

const crypto = require('crypto');

// Get DDX_PUBLIC_KEY from your application's edit section
function encryptWebhookConfig(publicKeyBase64, config) {
  const publicKeyPEM = Buffer.from(publicKeyBase64, 'base64').toString('utf8');

  const payload = JSON.stringify({
    url: 'https://your-api.com/webhook/endpoint',
    params: {                    // Optional: Query parameters for the URL
      key1: 'value1',
      key2: 'value2'
    },
    headers: {                   // Optional: HTTP headers for authentication
      'Authorization': 'Bearer YOUR_TOKEN',
      'X-Custom-Header': 'your_value'
    },
    responseType: 'base64',      // Optional: 'base64' or omit for stream
    metadata: {                  // Optional: Custom data (only sent with base64)
      customField1: 'value1',
      customField2: 123
    }
  });

  const encryptedBuffer = crypto.publicEncrypt(publicKeyPEM, Buffer.from(payload, 'utf8'));
  return encryptedBuffer.toString('base64');
}

// Usage
const encryptedUrl = encryptWebhookConfig(DDX_PUBLIC_KEY, config);
formData.append('ddxE_encrypted_url', encryptedUrl);

Step 2: Receive Signed Document

When responseType: 'base64':

POST https://your-api.com/webhook/endpoint?key1=value1&key2=value2
Content-Type: application/json
Authorization: Bearer YOUR_TOKEN
X-Custom-Header: your_value

{
  "customField1": "value1",
  "customField2": 123,
  "ddx_file": "JVBERi0xLjQKJeLjz9MK..."  // base64 encoded PDF
}

When responseType is omitted (stream):

POST https://your-api.com/webhook/endpoint?key1=value1&key2=value2
Content-Type: application/pdf
Authorization: Bearer YOUR_TOKEN
X-Custom-Header: your_value

[Binary PDF stream]

Simple Public Webhook

API Request:

const formData = new FormData();
formData.append('ddx_template', templateFile);
formData.append('ddx_outputFormat', 'pdf');
formData.append('ddxE_signers', JSON.stringify([
  {
    signerRole: 'client',
    signerEmail: 'client@example.com',
    signerName: 'John Doe',
    required: ['signature', 'date']
  }
]));
formData.append('ddxE_senderEmail', 'sender@yourcompany.com');
formData.append('ddxE_webhookUrl', 'https://yourapp.com/api/signed-docs');

const response = await fetch('https://api.datawise.app/api/datawise_document_exchange', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer YOUR_API_KEY' },
  body: formData
});

Webhook Handler:

app.post('/api/signed-docs', async (req, res) => {
  // req.body is the PDF binary stream
  const pdfBuffer = await streamToBuffer(req);
  fs.writeFileSync('signed-document.pdf', pdfBuffer);

  res.status(200).send('Received');
});

Encrypted Webhook with Base64

const crypto = require('crypto');

// Step 1: Create encryption function
// Get DDX_PUBLIC_KEY from your application's edit section
function encryptConfig(config) {
  const publicKeyPEM = Buffer.from(process.env.DDX_PUBLIC_KEY, 'base64').toString('utf8');
  const payload = JSON.stringify(config);
  const encrypted = crypto.publicEncrypt(publicKeyPEM, Buffer.from(payload, 'utf8'));
  return encrypted.toString('base64');
}

// Step 2: Send DDX request
const formData = new FormData();
formData.append('ddx_template', templateFile);
formData.append('ddx_outputFormat', 'pdf');
formData.append('ddxE_signers', JSON.stringify([
  {
    signerRole: 'signer1',
    signerEmail: 'signer@example.com',
    signerName: 'Jane Smith',
    required: ['signature', 'initials', 'date']
  }
]));
formData.append('ddxE_senderEmail', 'noreply@yourapp.com');

// Encrypt webhook configuration
const encryptedUrl = encryptConfig({
  url: 'https://internal-api.company.com/webhooks/ddx',
  params: {
    api_key: process.env.INTERNAL_API_KEY,
    project_id: '12345'
  },
  headers: {
    'Authorization': `Bearer ${process.env.INTERNAL_TOKEN}`,
    'X-Custom-Header': 'custom-value'
  },
  responseType: 'base64',
  metadata: {
    projectId: 12345,
    userId: 67890,
    documentType: 'contract'
  }
});

formData.append('ddxE_encrypted_url', encryptedUrl);

await fetch('https://api.datawise.app/api/datawise_document_exchange', {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${process.env.DDX_API_KEY}` },
  body: formData
});

// Step 3: Handle webhook callback
app.post('/webhooks/ddx', async (req, res) => {
  // Verify custom header
  if (req.headers['x-custom-header'] !== 'custom-value') {
    return res.status(401).send('Unauthorized');
  }

  const { projectId, userId, documentType, ddx_file } = req.body;

  // Decode base64 PDF
  const pdfBuffer = Buffer.from(ddx_file, 'base64');

  // Save to database or storage
  await saveSignedDocument({
    projectId,
    userId,
    type: documentType,
    pdfData: pdfBuffer
  });

  res.status(200).json({ success: true });
});

Python with Encrypted Webhook

import requests
import json
import base64
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import hashes

def encrypt_webhook_config(public_key_base64, config):
    """
    Encrypt webhook configuration using RSA public key.
    Get public_key_base64 from your application's edit section (DDX_PUBLIC_KEY).
    """
    # Decode public key
    public_key_pem = base64.b64decode(public_key_base64).decode('utf-8')

    # Load public key
    public_key = serialization.load_pem_public_key(
        public_key_pem.encode('utf-8')
    )

    # Encrypt payload
    payload = json.dumps(config).encode('utf-8')
    encrypted = public_key.encrypt(
        payload,
        padding.PKCS1v15()
    )

    return base64.b64encode(encrypted).decode('utf-8')

# Configuration
config = {
    'url': 'https://api.myapp.com/webhooks/signed-docs',
    'headers': {
        'Authorization': f'Bearer {os.getenv("MY_API_TOKEN")}',
        'X-Project-ID': '12345'
    },
    'responseType': 'base64',
    'metadata': {
        'orderId': 789,
        'customerId': 456
    }
}

# Encrypt configuration
encrypted_url = encrypt_webhook_config(
    os.getenv('DDX_PUBLIC_KEY'),
    config
)

# Send request to DDX
files = {
    'ddx_template': ('template.docx', open('template.docx', 'rb')),
}

data = {
    'ddx_outputFormat': 'pdf',
    'ddxE_signers': json.dumps([{
        'signerRole': 'customer',
        'signerEmail': 'customer@example.com',
        'signerName': 'Alice Johnson',
        'required': ['signature', 'date']
    }]),
    'ddxE_senderEmail': 'contracts@mycompany.com',
    'ddxE_encrypted_url': encrypted_url
}

response = requests.post(
    'https://api.datawise.app/api/datawise_document_exchange',
    headers={'Authorization': f'Bearer {os.getenv("DDX_API_KEY")}'},
    files=files,
    data=data
)

# Webhook handler (Flask example)
@app.route('/webhooks/signed-docs', methods=['POST'])
def handle_signed_doc():
    # Verify authorization
    if request.headers.get('Authorization') != f'Bearer {os.getenv("MY_API_TOKEN")}':
        return jsonify({'error': 'Unauthorized'}), 401

    data = request.json
    order_id = data['orderId']
    customer_id = data['customerId']
    pdf_base64 = data['ddx_file']

    # Decode PDF
    pdf_bytes = base64.b64decode(pdf_base64)

    # Save to file or database
    with open(f'signed_contract_{order_id}.pdf', 'wb') as f:
        f.write(pdf_bytes)

    return jsonify({'success': True}), 200