Orchestration

SEON_API_KEY=your_api_key_here
SEON_BASE_URL=https://orchestration.seondev.space  # Development
WORKFLOW_ID=your_workflow_uuid
SEON_WEBHOOK_SECRET=your_webhook_secret  # For signature verification

const express = require('express');
const app = express();
app.use(express.json());

const SEON_API_KEY = process.env.SEON_API_KEY;
const SEON_BASE_URL = process.env.SEON_BASE_URL;
const WORKFLOW_ID = process.env.WORKFLOW_ID;

app.post('/api/init-verification', async (req, res) => {
  const { userId, email, phoneNumber } = req.body;

  try {
    const response = await fetch(`${SEON_BASE_URL}/v1/init-workflow`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': SEON_API_KEY,
      },
      body: JSON.stringify({
        workflowId: WORKFLOW_ID,
        inputs: {
          user_id: userId,
          email: email,
          phone_number: phoneNumber,
        },
      }),
    });

    if (!response.ok) {
      const error = await response.json();
      return res.status(response.status).json({ error: error.message });
    }

    const { data } = await response.json();
    
    // Store executionId for webhook correlation
    await storeExecutionId(userId, data.executionId);
    
    // Return only the token to frontend
    res.json({ token: data.token });
  } catch (error) {
    console.error('Failed to initialize workflow:', error);
    res.status(500).json({ error: 'Failed to initialize verification' });
  }
});

import os
import requests
from flask import Flask, request, jsonify

app = Flask(__name__)

SEON_API_KEY = os.environ.get('SEON_API_KEY')
SEON_BASE_URL = os.environ.get('SEON_BASE_URL')
WORKFLOW_ID = os.environ.get('WORKFLOW_ID')

@app.route('/api/init-verification', methods=['POST'])
def init_verification():
    data = request.get_json()
    
    response = requests.post(
        f'{SEON_BASE_URL}/v1/init-workflow',
        headers={
            'Content-Type': 'application/json',
            'x-api-key': SEON_API_KEY,
        },
        json={
            'workflowId': WORKFLOW_ID,
            'inputs': {
                'user_id': data.get('userId'),
                'email': data.get('email'),
                'phone_number': data.get('phoneNumber'),
            },
        },
    )

    if not response.ok:
        return jsonify({'error': response.json().get('message')}), response.status_code

    result = response.json()['data']
    
    # Store executionId for webhook correlation
    store_execution_id(data.get('userId'), result['executionId'])
    
    return jsonify({'token': result['token']})

npm install @seontechnologies/seon-orchestration
# or
yarn add @seontechnologies/seon-orchestration

import { SeonOrchestration } from '@seontechnologies/seon-orchestration';

async function startVerification(userId) {
  // 1. Get token from your backend
  const response = await fetch('/api/init-verification', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ userId }),
  });
  const { token } = await response.json();

  // 2. Start the verification flow
  await SeonOrchestration.start({ token });
}

import { SeonOrchestration } from '@seontechnologies/seon-orchestration';

// Set up event listeners (do this once on page load)
SeonOrchestration.on('completed', (status) => {
  // status: 'success' | 'pending' | 'failed' | 'unknown'
  console.log('Verification completed:', status);
  
  if (status === 'success') {
    showSuccessMessage();
  } else if (status === 'pending') {
    showPendingMessage();
  } else {
    showFailureMessage();
  }
});

SeonOrchestration.on('error', (errorCode) => {
  console.error('Verification error:', errorCode);
  showErrorMessage(errorCode);
});

SeonOrchestration.on('cancelled', () => {
  console.log('User cancelled verification');
});

// Start verification function
async function startVerification(userId) {
  try {
    const response = await fetch('/api/init-verification', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ userId }),
    });
    
    if (!response.ok) {
      throw new Error('Failed to initialize verification');
    }
    
    const { token } = await response.json();
    
    await SeonOrchestration.start({
      token,
      language: 'en',
      renderingMode: 'fullscreen',
    });
  } catch (error) {
    console.error('Failed to start:', error);
  }
}

import { useEffect, useState } from 'react';
import { SeonOrchestration, CompletionTypes, ErrorCodes } from '@seontechnologies/seon-orchestration';

export function VerificationButton({ userId, onComplete, onError }) {
  const [isLoading, setIsLoading] = useState(false);

  useEffect(() => {
    const handleCompleted = (status: CompletionTypes) => {
      setIsLoading(false);
      onComplete(status);
    };

    const handleError = (errorCode: ErrorCodes) => {
      setIsLoading(false);
      onError(errorCode);
    };

    SeonOrchestration.on('completed', handleCompleted);
    SeonOrchestration.on('error', handleError);
    SeonOrchestration.on('closed', () => setIsLoading(false));

    return () => {
      SeonOrchestration.off('completed', handleCompleted);
      SeonOrchestration.off('error', handleError);
      SeonOrchestration.off('closed', () => setIsLoading(false));
    };
  }, [onComplete, onError]);

  const startVerification = async () => {
    setIsLoading(true);
    
    try {
      const response = await fetch('/api/init-verification', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ userId }),
      });
      const { token } = await response.json();
      
      await SeonOrchestration.start({ token, language: 'en' });
    } catch (error) {
      onError('init_failed');
    } finally {
      setIsLoading(false);
    }
  };

  return (
    <button onClick={startVerification} disabled={isLoading}>
      {isLoading ? 'Starting...' : 'Verify Identity'}
    </button>
  );
}

await SeonOrchestration.start({
  token,
  renderingMode: 'fullscreen'
});

await SeonOrchestration.start({
  token,
  renderingMode: 'popup'
});

<div id="verification-container" style="min-height: 600px;"></div>

await SeonOrchestration.start({
  token,
  renderingMode: 'inline',
  containerId: 'verification-container'
});

{
  "event": "orchestration/workflow_execution_finished",
  "timestamp": "2025-01-12T14:30:00Z",
  "data": {
    "id": "a1b2c3d4-e5f6-7890-1234-567890abcdef",
    "workflow": {
      "id": "550e8400-e29b-41d4-a716-446655440000",
      "name": "KYC Onboarding Flow"
    },
    "status": "APPROVED"
  }
}

{
  "event": "idv/session_finished",
  "timestamp": "2025-01-12T14:30:00Z",
  "data": {
    "status": "APPROVED",
    "sessionId": "a1b2c3d4-e5f6-7890-1234-567890abcdef",
    "executionId": "f0e9d8c7-b6a5-4321-fedc-ba9876543210",
    "userId": "user-98765",
    "documentCheckResult": {
      "overallResult": "APPROVED",
      "documentValidityCheckResult": "PASSED",
      "imageQualityCheckResult": "PASSED"
    },
    "documentCheckExtractedData": {
      "fullName": "Jane Doe",
      "birthDate": "1990-05-15",
      "documentType": "PASSPORT",
      "country": "US"
    },
    "selfieVerificationResult": {
      "overallResult": "APPROVED",
      "livenessCheckResult": "PASSED",
      "faceMatchingResult": "PASSED"
    }
  }
}

const { executionId, token } = data;
console.log(`Started verification: execution ${executionId}`);
// Store executionId alongside userId in your database

['opened', 'closed', 'started', 'completed', 'cancelled', 'error'].forEach(event => {
  SeonOrchestration.on(event, (...args) => {
    console.log(`[SEON] ${event}:`, ...args);
  });
});