AI Avatar Video

Complete framework for creating realistic AI talking-head videos — from script writing to multi-scene production.

Part 1: Avatar Video Strategy (Standalone)

1.1 Script Writing for Talking-Head Content

Avatar scripts must feel like natural speech, not written copy. Follow these rules:

Pacing Rules

Authenticity Markers

Scripts that sound like real people include:

• Contractions: "I'm" not "I am", "don't" not "do not"
• Sentence fragments: "Pretty cool, right?" not "This is quite impressive, is it not?"
• Casual transitions: "So here's the thing..." / "Now, this is where it gets interesting..."
• Direct address: "You know what? You're gonna love this."
• Self-correction: "It's fast — actually, it's really fast."

Hook-to-CTA Structure for Avatar Scripts

15-second script template:

HOOK (0-3s): [Pattern interrupt or question — 8-12 words]
BRIDGE (3-7s): [Connect hook to product — 15-20 words]
BENEFIT (7-12s): [Core value proposition — 15-20 words]
CTA (12-15s): [Clear next step — 8-12 words]

30-second script template:

HOOK (0-3s): [Attention grab — 8-12 words]
PROBLEM (3-8s): [Relatable pain point — 15-25 words]
SOLUTION (8-15s): [Product introduction + key feature — 20-30 words]
PROOF (15-22s): [Social proof or demonstration — 15-25 words]
CTA (22-30s): [Urgency + next step — 15-25 words]

60-second script template:

HOOK (0-5s): [Strong opening — 12-18 words]
STORY/PROBLEM (5-15s): [Relatable scenario — 25-40 words]
DISCOVERY (15-25s): [How you found the product — 25-35 words]
FEATURES (25-40s): [2-3 key benefits with specifics — 35-50 words]
PROOF (40-50s): [Results, testimonials, data — 25-35 words]
CTA (50-60s): [Compelling close — 20-30 words]

Script Do's and Don'ts

1.2 Avatar/Persona Selection Framework

Choosing the right avatar is as important as the script. Match demographics to your target audience.

Trust Signals by Vertical

Diversity Considerations

• Test multiple demographics — different audiences respond to different presenters
• Match market: Use local-looking avatars for geo-targeted campaigns
• A/B test gender: Some products convert better with male vs female presenters (test, don't assume)
• Age alignment: Your avatar should look like your customer OR who your customer trusts

1.3 Multi-Scene Composition Guide

Multi-scene videos feel more dynamic and retain attention better than single-shot talking heads.

When to Switch Scenes

• Every 5-8 seconds for fast-paced content (TikTok/Reels)
• Every 8-15 seconds for medium-paced (YouTube, Feed ads)
• At every major transition point (problem → solution, feature → feature)

Scene Transition Best Practices

1. Cut on speech breaks — switch scenes at natural pauses
2. Alternate speaker/background — change avatar, background, or both
3. Use B-roll inserts — product shots between talking segments
4. Progress the story — each scene should advance the narrative

Recommended Scene Structures

2-Scene (15s):

Scene 1: Hook + Problem (avatar talking, neutral background)
Scene 2: Solution + CTA (avatar talking, product-relevant background)

3-Scene (30s):

Scene 1: Hook + Problem (avatar A, office background)
Scene 2: Solution + Features (avatar A, product demo background)
Scene 3: Social Proof + CTA (avatar A or B, branded background)

5-Scene (60s):

Scene 1: Hook (avatar, eye-catching background)
Scene 2: Problem deep-dive (avatar, relatable setting)
Scene 3: Product introduction (product B-roll or demo)
Scene 4: Features + Proof (avatar with data/reviews overlay)
Scene 5: CTA (avatar, clean branded background)

1.4 Audio & Voice Best Practices

Emotion Modulation

• Excitement: Slightly faster pace, higher energy, emphasis on benefit words
• Empathy: Slower pace, softer tone, pause after pain points
• Authority: Measured pace, confident tone, declarative sentences
• Urgency: Fast pace, short sentences, emphasis on time/scarcity words

Pronunciation Guidance

For product names, brand names, or technical terms:

• Write phonetically in the script: "Creatify" → "cree-ATE-ih-fy"
• Use periods for letter-by-letter: "A.I." reads as "A I" not "ai"
• Numbers: Write "fifteen percent" not "15%"

Pause Placement

• After the hook (let it sink in)
• Before the CTA (build anticipation)
• After stating a surprising stat
• Between major sections

Accent Selection by Market

• US Market: Standard American English
• UK Market: British RP or light regional
• Global/Neutral: Standard American (most universally understood)
• Local campaigns: Match regional accent to target geography

1.5 Green Screen / Transparent Background Techniques

AI avatars with transparent backgrounds can be overlaid on:

Best Practices for Transparent Overlays

• Use 9:16 format for mobile overlays, 1:1 for square placements
• Position avatar in lower-third or right side (don't block main content)
• Keep gestures contained — wide arm movements may clip at edges
• Match avatar lighting to background lighting direction
• Use WebM format for transparency (MP4 doesn't support alpha channel)

1.6 UGC-Style Avatar Strategy

Making AI avatars feel like authentic user-generated content:

Visual Authenticity Cues

• Casual backgrounds: Living room, kitchen, outdoor — not studio
• Natural lighting: Slightly warm, not perfectly even
• Casual framing: Slightly off-center, phone-selfie angle
• Minimal branding: No logos in first 3 seconds

Script Tone for UGC

• First person: "I've been using this for 2 weeks and..."
• Imperfect language: "Honestly? I was skeptical at first"
• Specific details: "I ordered the blue one on Tuesday" (not "I purchased the product")
• Emotional reactions: "I was literally shook when I saw the results"
• Conversational asides: "Okay but wait, it gets even better"

UGC Avatar Selection

• Choose avatars that look 20-35, casually dressed
• Avoid "too polished" presenters — slightly imperfect = more authentic
• Match the avatar to your customer demographic
• Test multiple avatars — UGC performance varies wildly by presenter

Part 2: API Automation

Automate avatar video production at scale.

2.1 Setup & Authentication

import requests

CREATIFY_API_ID = "your-api-id"
CREATIFY_API_KEY = "your-api-key"

HEADERS = {
    "Content-Type": "application/json",
    "X-API-ID": CREATIFY_API_ID,
    "X-API-KEY": CREATIFY_API_KEY,
}
BASE_URL = "https://api.creatify.ai/api"

Don't have an API key yet? No problem — grab one in under 2 minutes:

1. Sign up free at creatify.ai
2. Go to Settings → API
3. Copy your API ID and API Key — that's it. New accounts get free credits to start.

def poll_until_done(url, headers, max_wait=600, interval=10):
    """Poll a status endpoint until the job completes."""
    import time
    elapsed = 0
    while elapsed < max_wait:
        resp = requests.get(url, headers=headers)
        data = resp.json()
        if data.get("status") == "done":
            return data
        elif data.get("status") in ("failed", "error"):
            raise Exception(f"Job failed: {data.get('failed_reason', 'Unknown')}")
        time.sleep(interval)
        elapsed += interval
    raise TimeoutError(f"Job did not complete within {max_wait}s")

2.2 AI Avatar v1 (Single Scene)

Generate a video of a single avatar speaking from text. Simple, fast, great for short content.

Cost: 5 credits per 30 seconds

List Available Personas

def list_personas():
    """Get all 1,500+ available avatar personas."""
    resp = requests.get(f"{BASE_URL}/personas/", headers=HEADERS)
    resp.raise_for_status()
    return resp.json()  # Each has: id, name, gender, thumbnail, etc.

Create Avatar Video

def create_avatar_video(text, creator_id, aspect_ratio="9:16", model_version="aurora_v1_fast"):
    """Generate a single-scene avatar video from text."""
    resp = requests.post(f"{BASE_URL}/lipsyncs/", headers=HEADERS, json={
        "text": text,
        "creator": creator_id,
        "aspect_ratio": aspect_ratio,
        "model_version": model_version,
    })
    resp.raise_for_status()
    return resp.json()

def check_avatar_status(lipsync_id):
    """Check avatar video generation status."""
    resp = requests.get(f"{BASE_URL}/lipsyncs/{lipsync_id}/", headers=HEADERS)
    resp.raise_for_status()
    return resp.json()

Create Transparent Background Avatar

def create_transparent_avatar(text, creator_id, aspect_ratio="9:16"):
    """Generate avatar with transparent background (WebM format)."""
    resp = requests.post(f"{BASE_URL}/lipsyncs/", headers=HEADERS, json={
        "text": text,
        "creator": creator_id,
        "aspect_ratio": aspect_ratio,
        "transparent_background": True,
    })
    resp.raise_for_status()
    return resp.json()

2.3 AI Avatar v2 (Multi-Scene)

Create multi-scene videos with different avatars, voices, backgrounds, and CTAs per scene.

Cost: 5 credits per 30 seconds

def create_multi_scene_video(scenes, aspect_ratio="9:16", webhook_url=None):
    """Create a multi-scene avatar video.

    scenes: list of dicts, each with:
        - text (str): Script for this scene
        - creator (str): Avatar persona ID
        - voice_id (str, optional): Override voice
        - background (str, optional): Background image/video URL
    """
    payload = {
        "scenes": scenes,
        "aspect_ratio": aspect_ratio,
    }
    if webhook_url:
        payload["webhook_url"] = webhook_url

    resp = requests.post(f"{BASE_URL}/lipsyncs_v2/", headers=HEADERS, json=payload)
    resp.raise_for_status()
    return resp.json()

# Example: 3-scene product ad
scenes = [
    {
        "text": "Stop what you're doing. I need to tell you about something.",
        "creator": "18fccce8-86e7-5f31-abc8-18915cb872be",
    },
    {
        "text": "This serum literally transformed my skin in two weeks. No exaggeration.",
        "creator": "18fccce8-86e7-5f31-abc8-18915cb872be",
    },
    {
        "text": "Link is in my bio. Trust me, your future self will thank you.",
        "creator": "18fccce8-86e7-5f31-abc8-18915cb872be",
    },
]

video = create_multi_scene_video(scenes, aspect_ratio="9:16")

2.4 Aurora (Image + Audio → Video)

Generate studio-grade avatar videos from a reference image and audio file. Best-in-class lip sync.

Cost: 5 credits per 30 seconds

def create_aurora_video(image_url, audio_url, model_version="aurora_v1_fast", webhook_url=None):
    """Generate a studio-grade avatar video from image + audio."""
    payload = {
        "image": image_url,
        "audio": audio_url,
        "model_version": model_version,
    }
    if webhook_url:
        payload["webhook_url"] = webhook_url

    resp = requests.post(f"{BASE_URL}/aurora/", headers=HEADERS, json=payload)
    resp.raise_for_status()
    return resp.json()

def check_aurora_status(aurora_id):
    """Check Aurora generation status."""
    resp = requests.get(f"{BASE_URL}/aurora/{aurora_id}/", headers=HEADERS)
    resp.raise_for_status()
    return resp.json()

2.5 Text to Speech

Convert scripts into studio-quality voiceover audio.

Cost: 1 credit per 30 seconds

def list_voices():
    """List all available TTS voices and accents."""
    resp = requests.get(f"{BASE_URL}/voices/", headers=HEADERS)
    resp.raise_for_status()
    return resp.json()

def generate_tts(script, accent_id, webhook_url=None):
    """Generate voiceover audio from a script."""
    payload = {
        "script": script,
        "accent": accent_id,
    }
    if webhook_url:
        payload["webhook_url"] = webhook_url

    resp = requests.post(f"{BASE_URL}/text_to_speech/", headers=HEADERS, json=payload)
    resp.raise_for_status()
    return resp.json()

def check_tts_status(tts_id):
    """Check TTS generation status."""
    resp = requests.get(f"{BASE_URL}/text_to_speech/{tts_id}/", headers=HEADERS)
    resp.raise_for_status()
    return resp.json()

2.6 Voice Cloning

Clone a custom voice for brand consistency.

def clone_voice(audio_url, name):
    """Clone a voice from an audio sample."""
    resp = requests.post(f"{BASE_URL}/voices/clone/", headers=HEADERS, json={
        "audio_url": audio_url,
        "name": name,
    })
    resp.raise_for_status()
    return resp.json()

2.7 Custom Avatars (BYOA)

Upload your own video to create a custom avatar persona.

Note: Custom avatar creation takes 1-2 days for processing/approval.

def create_custom_avatar(lipsync_video_url, name, gender="m", scene="office"):
    """Create a custom avatar from your own video."""
    resp = requests.post(f"{BASE_URL}/personas/", headers=HEADERS, json={
        "lipsync_input": lipsync_video_url,
        "creator_name": name,
        "gender": gender,
        "video_scene": scene,
    })
    resp.raise_for_status()
    return resp.json()

def check_custom_avatar_status(persona_id):
    """Check custom avatar creation status."""
    resp = requests.get(f"{BASE_URL}/personas/{persona_id}/", headers=HEADERS)
    resp.raise_for_status()
    return resp.json()

2.8 Recipes

Recipe: TTS → Aurora Pipeline

Generate audio first, then pair with any image for avatar video.

def tts_to_aurora(script, accent_id, image_url):
    """Pipeline: script → audio → avatar video."""
    # Step 1: Generate audio
    tts = generate_tts(script, accent_id)
    tts_result = poll_until_done(
        f"{BASE_URL}/text_to_speech/{tts['id']}/", HEADERS, max_wait=120
    )
    audio_url = tts_result["output"]

    # Step 2: Generate Aurora video
    aurora = create_aurora_video(image_url, audio_url)
    aurora_result = poll_until_done(
        f"{BASE_URL}/aurora/{aurora['id']}/", HEADERS, max_wait=600
    )

    return aurora_result

Recipe: Batch Avatar A/B Test

Test multiple avatars with the same script to find the best performer.

def batch_avatar_ab_test(script, creator_ids, aspect_ratio="9:16"):
    """Generate the same script with multiple avatars for A/B testing."""
    jobs = []
    for creator_id in creator_ids:
        video = create_avatar_video(script, creator_id, aspect_ratio)
        jobs.append({"creator_id": creator_id, "video_id": video["id"]})

    results = []
    for job in jobs:
        try:
            result = poll_until_done(
                f"{BASE_URL}/lipsyncs/{job['video_id']}/", HEADERS, max_wait=600
            )
            results.append({
                "creator_id": job["creator_id"],
                "video_url": result.get("output") or result.get("video_output"),
                "status": "done"
            })
        except Exception as e:
            results.append({
                "creator_id": job["creator_id"],
                "error": str(e),
                "status": "failed"
            })

    return results

Recipe: Multi-Script Avatar Batch

Generate multiple scripts with the same avatar for hook testing.

def multi_script_batch(scripts, creator_id, aspect_ratio="9:16"):
    """Generate multiple scripts with the same avatar."""
    jobs = []
    for script in scripts:
        video = create_avatar_video(script, creator_id, aspect_ratio)
        jobs.append({"script": script[:50], "video_id": video["id"]})

    results = []
    for job in jobs:
        try:
            result = poll_until_done(
                f"{BASE_URL}/lipsyncs/{job['video_id']}/", HEADERS, max_wait=600
            )
            results.append({
                "script_preview": job["script"],
                "video_url": result.get("output") or result.get("video_output"),
                "status": "done"
            })
        except Exception as e:
            results.append({
                "script_preview": job["script"],
                "error": str(e),
                "status": "failed"
            })

    return results

2.9 Credit Costs & Latency Reference

2.10 Decision Matrix

See Also

• video-ad-generator — Product URL → video ad pipeline
• ai-ad-prompt-guide — Battle-tested prompting for AI ad creative
• ad-creative-evaluator — Score any video ad with AI expert panel
• video-ad-reverse-engineer — Reverse-engineer competitor ads
• static-ad-concept-generator — 320+ proven ad concept templates