Introduction

VoxEQ provides API-first, cloud-native voice intelligence for real-time fraud prevention and customer experience. This page centralizes developer quickstarts, representative endpoint shapes, OpenAPI access, and deployment recipes for common contact-center stacks. Product overviews for VoxEQ Verify, Persona, and Prompt are available. Privacy and ethics are core to implementation; VoxEQ does not store PII or voiceprints. Please refer to the AI Ethics Statement and Privacy Policy for details.

Access, credentials, and OpenAPI

• Request API access and the authoritative OpenAPI schema by scheduling a demo or through your VoxEQ account team.

• The OpenAPI specification includes security schemes, request/response models, and deployment notes for Verify, Persona, and Prompt. For architectural context and product capabilities, see the Product Guide.

• Production deployments emphasize privacy by design (no storage of customer PII/voiceprints) and language-agnostic, real-time analysis.

Note: The example endpoints and field names below are representative. Always use the exact paths and schemas from your OpenAPI copy.

Real-time characteristics that shape your integration

• Time-to-signal: actionable results typically within the first few seconds of audio; deployments often surface detections before the 6th second of a call.

• Works from first contact: no customer enrollment required; protects first-time and anonymous callers.

• Synthetic/deepfake detection and Watch List support are available to flag repeat imposters and synthetics while allowing legitimate synthetic use cases (e.g., voicemail).

Quickstart: curl (API pattern)

The following shows a representative multipart upload of early-call audio. Replace placeholders with values from your OpenAPI and credentials.

# Representative only — use your actual base URL, path, and auth header(s)

BASE_URL="<YOUR_API_BASE_URL>"
AUTH_HEADER="Authorization: Bearer <YOUR_TOKEN>"

curl -X POST "$BASE_URL/v1/verify" \
  -H "$AUTH_HEADER" \
  -H "Accept: application/json" \
  -F "audio=@/path/to/first-5-seconds.wav;type=audio/wav" \
  -F "caller_id=+15551230000" \
  -F "claimed_identity=acct_12345" \
  -F "metadata=session-abc123"

What you’ll receive: a JSON response containing a fraud-risk signal, demographic estimates (e.g., age, birth sex), synthetic-voice likelihood, and watch-list indications. Field names and score ranges are defined in your OpenAPI.

Quickstart: Node.js

// Representative only — align with your OpenAPI paths and auth scheme
import fs from 'node:fs';
import fetch from 'node-fetch';

const BASE_URL = process.env. VOXEQ_BASE_URL;        // Set your API base URL
const TOKEN    = process.env. VOXEQ_TOKEN;           // provisioned by VoxEQ

async function run() {
  const form = new (await import('form-data')).default();
  form.append('audio', fs.createReadStream('first-5-seconds.wav'), { contentType: 'audio/wav' });
  form.append('caller_id', '+15551230000');
  form.append('claimed_identity', 'acct_12345');

  const res = await fetch(`${BASE_URL}/v1/verify`, {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${TOKEN}` },
    body: form
  });

  const data = await res.json();
  // Typical outputs: risk score, demographic estimates, synthetic-voice signal, watch-list flags
  console.log(data);
}
run();

Quickstart: Python

# Representative only — align with your OpenAPI paths and auth scheme

import os, requests

BASE_URL = os.environ["VOXEQ_BASE_URL"]

# Set your API base URL

TOKEN    = os.environ["VOXEQ_TOKEN"]

with open("first-5-seconds.wav", "rb") as f:
    files = {"audio": ("first-5-seconds.wav", f, "audio/wav")}
    data  = {"caller_id": "+15551230000", "claimed_identity": "acct_12345"}
    headers = {"Authorization": f"Bearer {TOKEN}"}
    r = requests.post(f"{BASE_URL}/v1/verify", headers=headers, files=files, data=data)
    r.raise_for_status()
    result = r.json()

# Typical outputs: risk score, demographic estimates, synthetic-voice signal, watch-list flags

    print(result)

Representative API surface (map this to your OpenAPI)

• Verify (fraud prevention and authentication aid)

• Input: a few seconds of call audio plus optional metadata (caller ID, claimed account, session ID).

• Output: fraud-risk signal, demographic estimates, synthetic/deepfake likelihood, watch-list signal; tunable sensitivity per program.

• Persona (CX routing and segmentation)

• Input: early-call audio.

• Output: demographic insights for agent pairing, scripting, and segmentation.

• Prompt (LLM prompt enrichment)

• Input: early-call audio.

• Output: structured demographic context to prepend to virtual-agent prompts for faster, more relevant responses.

Table: representative request/response concepts (use your OpenAPI for exact names and ranges)

Sources for behavior and constraints: Verify, Product Guide, Old Verify.

Response handling and decisioning patterns

• Fraud decisioning: combine risk signal + synthetic-voice likelihood + watch-list to trigger KBA/MFA, step-up verification, or agent assist.

• CX routing: use demographic estimates to match agents/scripts or pass context to IVR/virtual agent flows without adding friction.

• Virtual agents: prepend structured demographic context to the LLM’s first prompt to reduce back-and-forth and accelerate resolution.

Platform recipes (reference architectures)

These recipes illustrate how teams typically capture the first seconds of audio and call VoxEQ. Adapt to your environment and the OpenAPI you receive.

Genesys Cloud

• Availability: VoxEQ’s solutions are available to Genesys customers; see the AppFoundry announcement for context.

• Pattern: in Architect, invoke a Data Action/Lambda (or secure HTTPS action) early in the flow to send initial audio to VoxEQ; route on returned signals (risk, watch-list, demographics) to step-up auth or pair to optimal agents.

Amazon Connect

• Context: VoxEQ documents native compatibility with Amazon Connect.

• Pattern: in your Contact Flow, call a Lambda that streams or uploads early-call audio to VoxEQ; branch the flow based on returned risk/demographic context (e.g., step-up auth vs. direct routing to specialized agent queues).

Dialogflow CX (webhook pattern)

• Pattern: implement a CX webhook that, on session start or in an early intent, transmits the initial audio snippet or its secure reference to VoxEQ; enrich session parameters with returned context to guide dialogue policy and handoff logic.

TTEC Digital Smart

Apps Cloud

• Turnkey integration: TTEC Digital integrates VoxEQ for real-time fraud prevention in SmartApps Cloud, emphasizing privacy-first design and reduced handle time. Refer to the joint announcement and press materials as needed.

Tuning and controls you should expect in OpenAPI

• Sensitivity/acuity controls to balance security with CX (e.g., dynamic false-positive management per program). See the Product Guide and Old Verify for reference.

• Program-level configuration for Watch List checks and synthetic-voice detection.

• Privacy-centric options to avoid storing PII/voiceprints and limit payload content to labels and risk scores. Please consult the AI Ethics Statement for more information.

Testing, QA, and rollout

• Start with early-call audio only; measure latency to first signal and downstream impact on handle time.

• Validate routing and step-up policies using sandbox callers across languages and channels; VoxEQ is language-agnostic.

• Stage rollouts by queue or program; monitor watch-list precision/recall and adjust sensitivity controls with your VoxEQ team. Refer to the Product Guide for guidance.

Support and next steps

• Request credentials and your OpenAPI spec by scheduling a demo.

• Product capabilities and architectural guidance: see the Product Guide and other core documentation for more information.

• Ethics and privacy posture for security reviews: AI Ethics Statement and Privacy Policy provide the relevant details.

• Recent partner integration for rapid deployment at scale: TTEC Digital + VoxEQ collaboration materials are available on request.