Creating a Verification Session

import fetch from 'node-fetch';
 
// Function to get client token (implement according to Authentication API)
async function getClientToken() {
  // Implementation details in Authentication API documentation
  // ...
}
 
async function createSession(
  access_token,
  workflow_id,
  vendor_data,
  callback = null,
  metadata = null,
  email = null,
  email_lang = null,
  phone = null,
  expected_details = null
) {
  const url = "https://verification.didit.me/v2/session/";
 
  // Prepare request body
  const body = { workflow_id, vendor_data };
  if (callback) body.callback = callback;
  if (metadata) body.metadata = metadata;
  if (email) body.contact_details = { email, email_lang, phone };
  if (expected_details) body.expected_details = expected_details;
 
  const requestOptions = {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Authorization": `Bearer ${access_token}`,
    },
    body: JSON.stringify(body),
  };
 
  try {
    const response = await fetch(url, requestOptions);
    const data = await response.json();
 
    if (!response.ok) {
      throw new Error(data.detail || "Failed to create session");
    }
 
    return data;
  } catch (error) {
    console.error("Error:", error.message);
    throw error;
  }
}
 
// Example usage
async function createSessionFlow(workflow_id, vendor_data) {
  try {
    // 1. Get client token
    const token = await getClientToken();
    if (!token) {
      throw new Error("Failed to fetch client token");
    }
 
    // 2. Create session
    const session = await createSession(token.access_token, workflow_id, vendor_data);
 
    // Redirect user to the session URL
    if (session.url) {
      console.log(`Redirect user to: ${session.url}`);
      // window.location.href = session.url;
    }
 
    return session;
  } catch (error) {
    console.error("Session creation failed:", error);
  }
}

import requests
 
# Function to get client token (implement according to Authentication API)
def get_client_token():
    # Implementation details in Authentication API documentation
    # ...
    pass
 
def create_session(
    access_token: str,
    workflow_id: str,
    vendor_data: str,
    callback: str = None,
    metadata: dict = None,
    email: str = None,
    email_lang: str = None,
    phone: str = None,
    expected_details: dict = None
):
    url = "https://verification.didit.me/v2/session/"
 
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {access_token}"
    }
 
    body = {"workflow_id": workflow_id, "vendor_data": vendor_data}
    if callback:
        body["callback"] = callback
    if metadata:
        body["metadata"] = metadata
    if email:
        body["contact_details"] = { "email": email, "email_lang": email_lang, "phone": phone }
    if expected_details:
        body["expected_details"] = expected_details
 
    try:
        response = requests.post(url, headers=headers, json=body)
        response.raise_for_status()
        return response.json()
    except requests.RequestException as e:
        error_msg = e.response.json().get('detail', str(e)) if e.response else str(e)
        raise Exception(f"Failed to create session: {error_msg}")
 
# Example usage
def create_session_flow(workflow_id, vendor_data):
    # 1. Get client token
    token = get_client_token()
    if not token:
        raise Exception("Failed to fetch client token")
 
    # 2. Create session
    session = create_session(token["access_token"], workflow_id, vendor_data)
 
    # Redirect user to the session URL or display it as a QR code
    return redirect(session['url'])