Product Demo API: Embed Interactive AI Demos in Your App

Most demo automation tools give you a link to share. That works for outbound email sequences, but it fails for three high-value use cases: in-app demos where you want to onboard users inside your own product, self-serve evaluation where prospects on your website should be able to start a demo without leaving the page, and partner enablement where channel partners need to demo your product from within their own portal. V100's Product Demo API enables all three by providing programmatic control over AI demo sessions.

The API follows REST conventions with JSON payloads. Authentication uses API keys with scoped permissions. All endpoints support both synchronous and webhook-based async patterns. Rate limits are generous: 1,000 session creations per minute on the standard plan, 10,000 on enterprise.

What the Demo API Enables

Before diving into endpoints, it helps to understand the three primary use cases the API is designed to serve.

In-app demos and onboarding. After a user signs up for your product, you can trigger an AI demo session embedded directly in your application. The agent walks them through the features relevant to their plan, answers questions, and tracks completion milestones. Unlike generic product tours, the demo is conversational. The user can say "I don't understand how permissions work" and the agent will explain it in context. This is onboarding that adapts to the user rather than following a rigid script.

Self-serve website demos. Embed the demo agent directly on your pricing page, feature page, or landing page. When a visitor clicks "See it in action," the agent appears in an iframe and begins a personalized demo. No form fills, no scheduling, no waiting. The visitor gets an immediate, interactive experience while their buying intent is highest.

Partner and channel enablement. If you sell through channel partners, the API lets them embed your AI demo agent in their own website or portal. Each partner gets a unique agent configuration with their branding, co-marketing messaging, and deal registration. The partner doesn't need product expertise to deliver a compelling demo because the AI agent has it.

Core API Endpoints

The API is organized around three resources: Agents, Sessions, and Knowledge Bases.

Create a Demo Session

POST /v1/demo/sessions

// Request body
{
  "agent_id": "agent_9k2mX4vR",
  "prospect": {
    "email": "jane@acmecorp.com",
    "name": "Jane Chen",
    "company": "Acme Corp",
    "metadata": {
      "plan_interest": "enterprise",
      "source": "pricing_page"
    }
  },
  "config": {
    "language": "auto",
    "qualification_framework": "MEDDIC",
    "handoff_enabled": true,
    "recording_enabled": true,
    "max_duration_minutes": 30
  }
}

// Response
{
  "session_id": "sess_aB3kL9mN",
  "join_url": "https://demo.v100.ai/s/aB3kL9mN",
  "embed_token": "etk_xY7pQ2wR...",
  "status": "waiting",
  "created_at": "2026-03-10T14:30:00Z"
}

The agent_id references a pre-configured demo agent with its avatar, voice, knowledge base, and conversation flow. The prospect object passes context to the agent so it can personalize the greeting and demo flow. The embed_token in the response is used for iframe embedding.

Embed in Your Website

The simplest embedding option is a script tag that creates the demo widget on your page.

<!-- Drop-in embed -->
<div id="v100-demo"></div>

<script src="https://cdn.v100.ai/demo-embed.js"></script>
<script>
  V100Demo.init({
    container: '#v100-demo',
    agentId: 'agent_9k2mX4vR',
    apiKey: 'pk_live_...',
    theme: {
      primaryColor: '#4f46e5',
      borderRadius: '12px',
      position: 'inline'  // or 'modal' or 'floating'
    },
    prospect: {
      email: user.email,       // pass from your auth context
      name: user.name,
      company: user.company
    },
    onSessionStart: (session) => {
      analytics.track('demo_started', { sessionId: session.id });
    },
    onSessionEnd: (session) => {
      analytics.track('demo_completed', {
        sessionId: session.id,
        duration: session.duration,
        qualScore: session.qualification_score
      });
    }
  });
</script>

The embed script handles all the complexity of WebRTC connection setup, avatar rendering, and audio processing. Your page just provides a container element and configuration. The theme object controls visual styling to match your brand. The position option controls rendering mode: inline renders in the container element, modal opens as a centered overlay, and floating creates a bottom-right widget similar to chat widgets.

Retrieve Session Data

GET /v1/demo/sessions/{session_id}

// Response
{
  "session_id": "sess_aB3kL9mN",
  "status": "completed",
  "duration_seconds": 847,
  "prospect": {
    "email": "jane@acmecorp.com",
    "name": "Jane Chen",
    "company": "Acme Corp"
  },
  "qualification": {
    "framework": "MEDDIC",
    "score": 78,
    "metrics": { "identified": true, "value": "Reduce onboarding by 50%" },
    "economic_buyer": { "identified": false },
    "decision_criteria": { "identified": true, "notes": "SOC 2 required, SSO mandatory" },
    "decision_process": { "identified": true, "notes": "VP Eng approval, 30-day eval" }
  },
  "features_shown": ["dashboard", "analytics", "permissions"],
  "questions_asked": 12,
  "sentiment_score": 0.82,
  "recording_url": "https://recordings.v100.ai/sess_aB3kL9mN.mp4",
  "transcript_url": "https://recordings.v100.ai/sess_aB3kL9mN.json",
  "handoff_triggered": false
}

Update the Knowledge Base

POST /v1/agents/{agent_id}/knowledge

// Upload a document to the knowledge base
{
  "type": "document",
  "title": "Enterprise Security Features",
  "content": "## SOC 2 Compliance\n\nV100 maintains SOC 2 Type II...",
  "category": "security",
  "priority": "high"
}

// Response
{
  "document_id": "doc_r8tYp3wQ",
  "status": "indexing",
  "chunks_created": 14,
  "estimated_ready_at": "2026-03-10T14:32:00Z"
}

The knowledge base API lets you programmatically update what the agent knows. This is essential for keeping the agent current as your product evolves. You can integrate it into your CI/CD pipeline to automatically update the agent's knowledge base when documentation changes are deployed. The indexing process typically completes within 2 minutes for documents under 50,000 words.

Customization Options

The API exposes four dimensions of customization: avatar appearance, voice characteristics, conversation behavior, and visual branding.

Avatar. Select from stock avatars or use a custom clone. The agent configuration stores the avatar model reference, background environment (virtual office, neutral backdrop, or transparent for overlay), and wardrobe preferences. Custom avatars created from the 5-minute training video are referenced by their avatar_id.

Voice. Custom voice clones are referenced by voice_id. You can also select from V100's stock voices. Language settings can be fixed (always respond in English) or automatic (detect the prospect's language and match it). The pronunciation dictionary API lets you define custom pronunciations for product names and technical terms.

Conversation. The conversation flow is defined by a structured configuration that specifies: the greeting message, discovery questions to ask, the demo sequence (which features to show and in what order), conditional branching rules (if the prospect mentions X, show feature Y), qualification criteria, CTA messages, and handoff triggers. You can create multiple conversation flows per agent for different use cases (SMB demo vs enterprise demo vs onboarding).

Branding. Colors, logo, background, and UI elements are all configurable through the theme API. White-label mode removes all V100 branding, which is required for partner enablement and agencies deploying agents for clients.

Webhook Events for CRM Sync

V100 fires webhook events at key session milestones. You configure webhook URLs per agent, and events are delivered with HMAC-SHA256 signatures for verification. Failed deliveries are retried with exponential backoff for up to 24 hours.

// Webhook: session.completed
{
  "event": "session.completed",
  "timestamp": "2026-03-10T14:44:07Z",
  "data": {
    "session_id": "sess_aB3kL9mN",
    "agent_id": "agent_9k2mX4vR",
    "prospect": {
      "email": "jane@acmecorp.com",
      "name": "Jane Chen",
      "company": "Acme Corp"
    },
    "duration_seconds": 847,
    "qualification_score": 78,
    "features_shown": ["dashboard", "analytics", "permissions"],
    "sentiment_score": 0.82,
    "next_action": "schedule_followup",
    "recording_url": "https://recordings.v100.ai/sess_aB3kL9mN.mp4"
  }
}

The event payload includes everything your CRM integration needs to create or update a contact record, log the interaction, assign a lead score, and trigger the appropriate next step in your sales workflow. Available events include:

Salesforce Integration Example

Here is a practical example of using the webhook to sync demo data into Salesforce. This Node.js webhook handler processes the session.completed event, creates or updates a Lead in Salesforce, and logs a Task with the demo details.

const express = require('express');
const crypto = require('crypto');
const jsforce = require('jsforce');

app.post('/webhooks/v100', async (req, res) => {
  // Verify webhook signature
  const signature = req.headers['x-v100-signature'];
  const expected = crypto
    .createHmac('sha256', process.env.V100_WEBHOOK_SECRET)
    .update(JSON.stringify(req.body))
    .digest('hex');

  if (signature !== expected) return res.status(401).send('Invalid signature');

  const { event, data } = req.body;

  if (event === 'session.completed') {
    const conn = new jsforce.Connection({ /* SF config */ });
    await conn.login(process.env.SF_USER, process.env.SF_PASS);

    // Upsert Lead by email
    await conn.sobject('Lead').upsert({
      Email: data.prospect.email,
      FirstName: data.prospect.name.split(' ')[0],
      LastName: data.prospect.name.split(' ').slice(1).join(' '),
      Company: data.prospect.company,
      LeadSource: 'AI Demo Agent',
      Rating: data.qualification_score > 70 ? 'Hot' : 'Warm',
      V100_Demo_Score__c: data.qualification_score,
      V100_Demo_Recording__c: data.recording_url
    }, 'Email');

    // Create Task for AE follow-up
    await conn.sobject('Task').create({
      Subject: `AI Demo Follow-up: ${data.prospect.company}`,
      Description: [
        `Duration: ${Math.round(data.duration_seconds / 60)} min`,
        `Features shown: ${data.features_shown.join(', ')}`,
        `Qual score: ${data.qualification_score}/100`,
        `Sentiment: ${data.sentiment_score}`,
        `Recording: ${data.recording_url}`
      ].join('\n'),
      Priority: data.qualification_score > 70 ? 'High' : 'Normal',
      Status: 'Not Started'
    });
  }

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

This pattern works for any CRM. Replace the jsforce calls with HubSpot's API client or Pipedrive's SDK and the same webhook payload maps to the same CRM operations. V100 also provides pre-built native integrations for Salesforce and HubSpot that handle the mapping automatically without custom webhook code, but the webhook approach gives you full control over the data transformation.

Rate Limits and Authentication

API authentication uses key pairs: a publishable key (pk_live_...) for client-side embedding and a secret key (sk_live_...) for server-side operations. The publishable key can be safely included in frontend code since it can only create sessions and retrieve public agent configurations. The secret key is used for knowledge base management, session data retrieval, and webhook configuration.

Rate limits are designed to be generous enough that you never hit them under normal usage. Standard plan: 1,000 session creations/minute, 10,000 API calls/minute. Enterprise plan: 10,000 session creations/minute, 100,000 API calls/minute. Rate limit headers (X-RateLimit-Remaining, X-RateLimit-Reset) are included in every response.