Adobe Sign Webhooks MCP Server

Create a powerful Model Context Protocol (MCP) server for Adobe Sign Webhooks in minutes with our AI Gateway. This guide walks you through setting up real-time event notifications with enterprise-grade security and instant OAuth authentication.

About Adobe Sign Webhooks API

Adobe Sign Webhooks provide real-time notifications for agreement events, enabling automated workflows and instant updates. The Webhooks API allows you to configure, manage, and process event notifications for signature workflows, status changes, and document updates.

Key Capabilities

• Event Notifications: Real-time agreement updates
• Webhook Management: Create, update, delete webhooks
• Event Types: Comprehensive event coverage
• Payload Security: Signed webhook payloads
• Retry Logic: Automatic retry mechanisms
• Event History: Webhook delivery tracking
• Conditional Webhooks: Filter-based notifications
• Batch Processing: Multiple events per payload

API Features

• REST API v6: Webhook operations
• Event Subscription: Selective event types
• OAuth 2.0: Secure authentication
• HMAC Validation: Payload verification
• Webhook Testing: Sandbox environment
• Event Filtering: Conditional logic
• Delivery Status: Success/failure tracking
• Bulk Operations: Mass webhook management

What You Can Do with Adobe Sign Webhooks MCP Server

The MCP server transforms Adobe Sign Webhooks API into a natural language interface, enabling AI agents to:

Webhook Configuration

• Webhook Creation

  • "Create webhook for agreement signed events"
  • "Set up notification for all events"
  • "Configure webhook with custom headers"
  • "Enable webhook for specific agreements"

• Event Selection

  • "Subscribe to signature completed events"
  • "Monitor document upload events"
  • "Track agreement status changes"
  • "Watch for reminder sent events"

• URL Configuration

  • "Set webhook endpoint URL"
  • "Configure HTTPS endpoint"
  • "Add authentication headers"
  • "Set custom payload format"

Event Types Management

• Agreement Events

  • "Track agreement created"
  • "Monitor agreement signed"
  • "Watch agreement completed"
  • "Alert on agreement cancelled"

• Participant Events

  • "Notify when signer views"
  • "Alert on delegation"
  • "Track signer completion"
  • "Monitor decline events"

• Workflow Events

  • "Track workflow started"
  • "Monitor step completion"
  • "Watch approval status"
  • "Alert on workflow errors"

Security Configuration

• Authentication Setup

  • "Configure webhook API key"
  • "Set bearer token auth"
  • "Enable mutual TLS"
  • "Add custom headers"

• Payload Validation

  • "Enable HMAC signing"
  • "Verify webhook signatures"
  • "Configure shared secret"
  • "Validate payload integrity"

• Access Control

  • "Restrict webhook scope"
  • "Set IP allowlist"
  • "Configure rate limits"
  • "Enable webhook auth"

Event Processing

• Real-time Handling

  • "Process signature events"
  • "Update CRM on completion"
  • "Trigger workflow automation"
  • "Send notifications"

• Event Filtering

  • "Filter by agreement type"
  • "Process specific signers"
  • "Route by document name"
  • "Handle priority events"

• Error Handling

  • "Configure retry policy"
  • "Set failure notifications"
  • "Monitor delivery status"
  • "Handle timeout events"

Webhook Analytics

• Delivery Metrics

  • "Show successful deliveries"
  • "Track failed webhooks"
  • "Monitor response times"
  • "Calculate success rate"

• Event Statistics

  • "Count events by type"
  • "Track event frequency"
  • "Analyze peak times"
  • "Monitor event trends"

• Performance Monitoring

  • "Check endpoint health"
  • "Monitor latency"
  • "Track payload sizes"
  • "Review error rates"

Webhook Management

• Lifecycle Operations

  • "Update webhook configuration"
  • "Pause webhook temporarily"
  • "Resume webhook delivery"
  • "Delete obsolete webhooks"

• Bulk Operations

  • "List all active webhooks"
  • "Update multiple webhooks"
  • "Disable webhooks by type"
  • "Export webhook configs"

• Testing & Debugging

  • "Test webhook endpoint"
  • "Send sample payload"
  • "Verify connectivity"
  • "Debug failed deliveries"

Advanced Features

• Conditional Logic

  • "Send if amount > $10000"
  • "Notify only for templates"
  • "Filter by signer email"
  • "Route by metadata"

• Transformation Rules

  • "Map to custom format"
  • "Extract specific fields"
  • "Enrich with metadata"
  • "Transform timestamps"

• Integration Patterns

  • "Queue events for processing"
  • "Batch similar events"
  • "Deduplicate notifications"
  • "Chain webhook handlers"

Event History

• Audit Trail

  • "View webhook history"
  • "Track all deliveries"
  • "Review failed attempts"
  • "Export event logs"

• Replay Capabilities

  • "Resend failed events"
  • "Replay specific timeframe"
  • "Reprocess events"
  • "Simulate past events"

• Compliance Tracking

  • "Audit webhook access"
  • "Track configuration changes"
  • "Monitor data flow"
  • "Generate reports"

Prerequisites

• Access to Cequence AI Gateway
• Adobe Sign Business or Enterprise plan
• Webhook configuration permissions
• HTTPS endpoint for receiving webhooks

Step 1: Create Adobe Sign Integration

1.1 Access Adobe Sign Admin

1. Log in to Adobe Sign as administrator
2. Go to Account Webhooks
3. Navigate to API Applications
4. Select your API application

1.2 Configure OAuth Application

1. Ensure application has webhook scopes:
   • Application Name: "AI Gateway Webhooks MCP"
   • Webhook Permissions: Enabled
   • Redirect URI:

     https://auth.aigateway.cequence.ai/v1/outbound/oauth/callback

1.3 Set Application Scopes

Select required scopes:

• webhook_read - View webhooks
• webhook_write - Manage webhooks
• webhook_retention - Access history
• agreement_read - Agreement context
• event_read - Event details
• audit_read - Audit logs

1.4 Get Credentials

1. After creation, view application
2. Copy Client ID
3. Copy Client Secret
4. Note the Base URI for your region

Step 2-4: Standard Setup

Follow standard steps to access AI Gateway, find Adobe Sign Webhooks API, and create MCP server.

Step 5: Configure API Endpoints

1. Base URL: Your regional API endpoint
   • Example: https://api.na1.adobesign.com/api/rest/v6
2. Select Webhooks endpoints:
   • Webhooks endpoints
   • Events endpoints
   • Subscriptions endpoints
3. Click Next

Step 6: MCP Server Configuration

1. Name: "Adobe Sign Webhooks"
2. Description: "Real-time event notifications"
3. Configure production mode
4. Click Next

Step 7: Configure Authentication

1. Authentication Type: OAuth 2.0
2. Authorization URL:

   https://secure.{region}.adobesign.com/public/oauth/v2

3. Token URL:

   https://api.{region}.adobesign.com/oauth/v2/token

4. Enter Client ID and Secret
5. Select required scopes

Available Adobe Sign Webhooks OAuth Scopes

Webhook Management

• webhook_read:self

  • View own webhooks
  • Access webhook details
  • Check delivery status
  • View configurations

• webhook_write:self

  • Create webhooks
  • Update configurations
  • Delete webhooks
  • Manage subscriptions

• webhook_retention:self

  • Access event history
  • View delivery logs
  • Track failures
  • Export records

Extended Permissions

• webhook_read:group

  • View group webhooks
  • Monitor team events
  • Access shared webhooks

• webhook_write:group

  • Manage group webhooks
  • Configure team notifications
  • Update shared webhooks

• webhook_read:account

  • Full webhook visibility
  • Administrative access
  • Compliance monitoring

Recommended Scope Combinations

For Event Monitoring:

webhook_read:self
agreement_read:self
event_read:self
audit_read:self

For Webhook Administration:

webhook_read:account
webhook_write:account
webhook_retention:account
event_read:account
audit_read:account

Step 8-10: Complete Setup

Configure security, choose deployment, and deploy.

Using Your Adobe Sign Webhooks MCP Server

With Claude Desktop

{
  "servers": {
    "adobe-sign-webhooks": {
      "url": "your-mcp-server-url",
      "auth": {
        "type": "oauth2",
        "client_id": "your-client-id"
      }
    }
  }
}

Natural Language Commands

• "Create webhook for agreement signed events"
• "Show all active webhooks"
• "Update webhook endpoint URL"
• "Check webhook delivery status for today"
• "Disable webhook for agreement created events"

API Integration Example

// Initialize MCP client
const mcpClient = new MCPClient({
  serverUrl: 'your-mcp-server-url',
  auth: {
    type: 'oauth2',
    token: 'access-token'
  }
});

// Create webhook subscription
const webhook = await mcpClient.adobeSign.webhooks.create({
  name: 'Agreement Status Monitor',
  scope: 'ACCOUNT',
  state: 'ACTIVE',
  webhookSubscriptionEvents: [
    'AGREEMENT_CREATED',
    'AGREEMENT_ACTION_COMPLETED',
    'AGREEMENT_WORKFLOW_COMPLETED',
    'AGREEMENT_EMAIL_VIEWED',
    'AGREEMENT_MODIFIED',
    'AGREEMENT_SHARED',
    'AGREEMENT_OFFLINE_SYNC',
    'AGREEMENT_USER_ACK_AGREEMENT_MODIFIED'
  ],
  webhookUrlInfo: {
    url: 'https://api.yourcompany.com/webhooks/adobe-sign',
    headers: {
      'X-API-Key': 'your-webhook-api-key',
      'Content-Type': 'application/json'
    }
  },
  webhookConditionalParams: {
    webhookAgreementEvents: {
      includeSignedAgreements: true,
      includeParticipantsInfo: true,
      includeDocumentsInfo: true
    }
  }
});

// Configure event filtering
const filteredWebhook = await mcpClient.adobeSign.webhooks.create({
  name: 'High Value Agreement Monitor',
  scope: 'GROUP',
  state: 'ACTIVE',
  webhookSubscriptionEvents: [
    'AGREEMENT_WORKFLOW_COMPLETED'
  ],
  webhookUrlInfo: {
    url: 'https://api.yourcompany.com/webhooks/high-value'
  },
  webhookConditionalParams: {
    webhookAgreementEvents: {
      conditionalParameterFilterInfo: {
        include: true,
        filterCondition: {
          aggregateFilterCondition: {
            filterConditions: [
              {
                fieldName: 'agreementAmount',
                fieldComparisonOperator: 'GREATER_THAN',
                fieldComparisonValue: '10000'
              },
              {
                fieldName: 'agreementStatus',
                fieldComparisonOperator: 'EQUALS',
                fieldComparisonValue: 'SIGNED'
              }
            ],
            booleanLogicOperator: 'AND'
          }
        }
      }
    }
  }
});

// Update webhook configuration
await mcpClient.adobeSign.webhooks.update({
  webhookId: webhook.id,
  state: 'ACTIVE',
  webhookSubscriptionEvents: [
    ...webhook.webhookSubscriptionEvents,
    'AGREEMENT_RECALLED',
    'AGREEMENT_REJECTED'
  ],
  webhookUrlInfo: {
    url: 'https://api.yourcompany.com/webhooks/adobe-sign-v2',
    headers: {
      'X-API-Key': 'new-api-key',
      'X-Webhook-Version': 'v2'
    }
  }
});

// Test webhook endpoint
const testResult = await mcpClient.adobeSign.webhooks.test({
  webhookId: webhook.id,
  testPayload: {
    webhookId: webhook.id,
    event: 'AGREEMENT_CREATED',
    agreement: {
      id: 'test-agreement-123',
      name: 'Test Agreement',
      status: 'OUT_FOR_SIGNATURE'
    }
  }
});

// Get webhook delivery status
const deliveryStatus = await mcpClient.adobeSign.webhooks.getDeliveryStatus({
  webhookId: webhook.id,
  startDate: '2025-01-01',
  endDate: '2025-01-31',
  status: 'FAILED'
});

// Retry failed deliveries
for (const failure of deliveryStatus.failures) {
  await mcpClient.adobeSign.webhooks.retryDelivery({
    webhookId: webhook.id,
    deliveryId: failure.id
  });
}

// List all webhooks
const allWebhooks = await mcpClient.adobeSign.webhooks.list({
  scope: 'ACCOUNT',
  showInactiveWebhooks: true,
  pageSize: 100
});

// Process webhook payload (in your endpoint)
function processWebhook(payload, headers) {
  // Verify HMAC signature
  const signature = headers['x-adobe-sign-signature'];
  const isValid = verifyHMAC(payload, signature, webhookSecret);
  
  if (!isValid) {
    throw new Error('Invalid webhook signature');
  }
  
  // Process event
  const event = JSON.parse(payload);
  
  switch (event.eventType) {
    case 'AGREEMENT_CREATED':
      handleAgreementCreated(event);
      break;
    case 'AGREEMENT_ACTION_COMPLETED':
      handleSignatureCompleted(event);
      break;
    case 'AGREEMENT_WORKFLOW_COMPLETED':
      handleWorkflowCompleted(event);
      break;
    default:
      console.log(`Unhandled event type: ${event.eventType}`);
  }
}

// Create webhook with retry configuration
const reliableWebhook = await mcpClient.adobeSign.webhooks.create({
  name: 'Reliable Event Handler',
  webhookUrlInfo: {
    url: 'https://api.yourcompany.com/webhooks/reliable'
  },
  webhookConfig: {
    retryConfiguration: {
      maxRetries: 5,
      retryInterval: 60, // seconds
      backoffMultiplier: 2
    },
    timeoutConfiguration: {
      connectionTimeout: 10000, // ms
      responseTimeout: 30000 // ms
    }
  }
});

// Monitor webhook health
const health = await mcpClient.adobeSign.webhooks.getHealth({
  webhookId: webhook.id,
  timeframe: 'LAST_24_HOURS'
});

console.log(`Success rate: ${health.successRate}%`);
console.log(`Average latency: ${health.avgLatency}ms`);
console.log(`Failed deliveries: ${health.failedCount}`);

Common Use Cases

Agreement Automation

• Status change notifications
• Signature completion alerts
• Document workflow updates
• Reminder tracking

System Integration

• CRM synchronization
• Document management
• Workflow automation
• Analytics pipelines

Compliance Monitoring

• Audit trail updates
• Security event tracking
• Access monitoring
• Policy enforcement

Business Process

• Contract lifecycle
• Approval workflows
• Notification systems
• Reporting automation

Security Best Practices

1. Webhook Security:

   • Use HTTPS endpoints only
   • Implement HMAC validation
   • Verify webhook source
   • Rate limit incoming requests

2. Endpoint Protection:

   • Authenticate requests
   • Validate payloads
   • Implement timeouts
   • Handle errors gracefully

3. Data Handling:

   • Encrypt sensitive data
   • Log security events
   • Monitor access patterns
   • Implement retention policies

Troubleshooting

Common Issues

1. Delivery Failures

   • Verify endpoint URL
   • Check authentication
   • Validate SSL certificates
   • Review firewall rules

2. Missing Events

   • Confirm event subscriptions
   • Check webhook state
   • Verify scope permissions
   • Review filter conditions

3. Performance Issues

   • Monitor endpoint latency
   • Implement async processing
   • Use queue systems
   • Scale endpoint capacity

Getting Help

• Documentation: AI Gateway Docs
• Support: support@cequence.ai
• Adobe Sign API: helpx.adobe.com/sign/using/api.html

---