Automated video testimonial requests and content pipeline

You've got customer testimonials locked away in email threads and video files scattered across drives. Your sales team says they need them for the website. Your marketing team wants clips for social. Someone's been tasked with manually requesting videos from clients, waiting weeks for responses, then editing everything together by hand. It's slow, inconsistent, and costing you far more in coordination time than the testimonials are worth. What if testimonial videos could request themselves, film themselves, and edit themselves into social clips without a single person touching them? This workflow automates the entire pipeline: from sending personalised testimonial requests to prospects who've just converted, through receiving their responses, generating professional AI-hosted videos, and delivering ready-to-post social clips. The system runs on a schedule or triggers from a webhook when a deal closes. This is intermediate territory. You'll be working with APIs, webhooks, and conditional logic. But the payoff is enormous: instead of your team spending 15-20 hours per month coordinating and editing testimonials, this handles it in minutes.

What You'll Build - A workflow that triggers when a new customer is marked as ready for testimonial (via webhook, CRM integration, or schedule).

• An automated email sent to the customer with a personalised, time-limited link requesting they record or describe their use case.

• An email parser that captures responses and extracts the testimonial text.

• An AI video generation step that creates a professional video with an avatar speaking the testimonial.

• A secondary workflow that generates 15-second and 30-second clips optimised for TikTok, LinkedIn, and Instagram.

• A summary report showing how many testimonials were generated, which are ready to publish, and which need human review.

• Time saving: from 15-20 hours of manual coordination and editing per month down to roughly 2-3 hours for quality checks and approvals.

Prerequisites

Before you start, gather these: - ChatGPT account (free tier works for initial setup, though you may want ChatGPT Plus if running this frequently; you'll use it to craft and iterate email templates).

• Emailit account (paid plan required; includes transactional email and SMTP access needed for triggered sends and response parsing).

• Synthesia account (paid plan required; starts at around $24/month for basic avatar video generation).

• API keys: You'll need Emailit's API key (available in account settings) and Synthesia's API key (found under developer settings).

• An orchestration platform: Choose one of Zapier, n8n, Make, or direct API calls via a serverless function (AWS Lambda, Google Cloud Functions, or Cloudflare Workers are cheapest).

• A way to trigger the workflow: Either a CRM webhook (HubSpot, Pipedrive), a Slack command, or a simple form submission.

• Basic familiarity with JSON, REST APIs, and conditional logic.

• Estimated setup time: 55 minutes (including creating email templates, testing the Synthesia API, and running one end-to-end trial).

The Automated Workflow

Step 1:

Trigger the workflow on new customer conversion Your workflow needs a signal to start. Most commonly, this is a webhook from your CRM when a deal moves to "closed won" status, or from a form submission on your site. If you don't have a webhook available, you can use a time-based trigger (e.g. "run every day at 9 AM and pull new customers from the past 24 hours"). For this example, we'll assume you're using Zapier with a HubSpot trigger. If you're using n8n or Make, the concept is identical but you'll use their native webhook handlers instead. Set up a Zapier trigger:

CopyTrigger: HubSpot → Deal Updated
Filter: Deal Stage = "Closed Won"
AND Last Activity Date = Today

If you're using a direct webhook approach with a serverless function, expose an endpoint:

CopyPOST https://your-domain.com/testimonial-trigger
Content-Type: application/json { "customer_id": "cust_12345", "customer_name": "Acme Corp", "customer_email": "testimonial@acmecorp.com", "deal_value": "25000", "product_used": "Premium Plan"
}

Why this step: You only want to request testimonials from customers who've actually converted and are likely to have had time to experience the product. Filtering at the trigger prevents wasting email quota on prospects. Data flowing to next step: customer_id, customer_name, customer_email, product_used, and any custom fields from your CRM (company size, industry, use case). Error handling: If the webhook fails to fire, the workflow stalls. Set up a Slack alert in your orchestration tool to notify you if no testimonial requests have been sent in 24 hours. Example Slack message:

Copy{ "text": "Warning: No testimonial requests sent in the past 24 hours. Check the HubSpot → Zapier integration."
}

Step 2:

Generate a personalised email template Before sending anything, you need a template that feels personal, not robotic. Use ChatGPT to draft one, then store it in your orchestration tool's template system. Example template (you'll personalise the [BRACKETS]):

CopySubject: Can we share your [PRODUCT_NAME] success story? Hi [CUSTOMER_NAME], We'd love to feature your experience with [PRODUCT_NAME] on our website and social channels. Your story could help other teams like [COMPANY_SIZE] and in the [INDUSTRY] space. Would you be willing to record a 60-second testimonial? It takes just a minute, and you can do it on your phone. Answer one or both of these:
1. What's one thing [PRODUCT_NAME] has made easier for your team?

2. What was the biggest win you've had since implementing [PRODUCT_NAME]? Reply directly to this email with your answer, or record a video and attach it. Thanks so much,
[YOUR_NAME] P.S. This link expires in 7 days: [UNIQUE_LINK]

Use your orchestration tool to substitute variables before sending. For example, in Zapier:

CopyFrom: testimonials@yourcompany.com
To: [CUSTOMER_EMAIL]
Subject: Can we share your [PRODUCT_USED] success story?
Body: [Use template above, with variables substituted]

Why this step: A template ensures consistency and allows you to personalise at scale without manual effort. Data flowing to next step: The customer's email address is tagged internally so the orchestration tool knows which responses to associate with which customer. Error handling: If the email bounces (invalid address), Emailit will return a 4xx status code. Catch this and log it to a spreadsheet or Slack channel for manual follow-up. Example:

Copyjson
{ "error": "email_invalid", "customer_id": "cust_12345", "email": "typo@acme.com", "action": "manual_review_required"
}

Step 3:

Parse email responses and extract testimonial text Responses will come back as replies to your testimonial request email. You need a system to capture them automatically. Emailit provides IMAP/POP support, but the cleanest approach is to use a dedicated email-parsing service or middleware.

Option A: Direct polling via Emailit's API

Every 30 minutes, query for new emails matching your testimonial inbox:

CopyGET https://api.emailit.io/messages?folder=testimonials&status=unread
Authorization: Bearer YOUR_EMAILIT_API_KEY

The response will include:

Copyjson
{ "messages": [ { "id": "msg_9876", "from": "testimonial@acmecorp.com", "subject": "Re: Can we share your Premium Plan success story?", "body": "We've saved about 8 hours a week on reporting. Your automation features are a game changer for our team.", "received_at": "2026-03-15T14:32:00Z" } ]
}

Option B: Webhook-based parsing (recommended)

Forward testimonial replies to a webhook URL you control:

CopyPOST https://your-domain.com/testimonial-response
Content-Type: application/json { "from": "testimonial@acmecorp.com", "subject": "Re: Can we share your Premium Plan success story?", "body": "We've saved about 8 hours a week on reporting. Your automation features are a game changer for our team.", "timestamp": "2026-03-15T14:32:00Z"
}

Now use a simple Node.js or Python script to extract the testimonial text and match it to the original customer:

Copyjavascript
async function parseTestimonial(emailBody) { const response = await fetch('https://api.openai.com/v1/chat/completions', { method: 'POST', headers: { 'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`, 'Content-Type': 'application/json' }, body: JSON.stringify({ model: 'GPT-4o mini', messages: [{ role: 'user', content: `Extract the core testimonial from this email. Remove salutations, signatures, and unrelated text. Return only the testimonial quote:\n\n${emailBody}` }], temperature: 0.3, max_tokens: 150 }) }); const data = await response.json(); return data.choices[0].message.content;
}

Why this step: Automated parsing eliminates the need to manually copy-paste testimonials from email into a document. GPT-4o mini is fast and cheap for this task. Data flowing to next step: The cleaned testimonial text, customer_id, and a confidence score (0-1) indicating how confident the extraction was. Error handling: If the email doesn't contain a clear testimonial (e.g. it's a "maybe later, busy right now" response), flag it for human review instead of moving to video generation. Example:

Copyjson
{ "status": "needs_review", "customer_id": "cust_12345", "reason": "response_too_short_or_unclear", "original_email": "Thanks for asking! I'll get back to you next week."
}

Step 4:

Generate video using Synthesia Once you have clean testimonial text, send it to Synthesia to generate a professional avatar video. Synthesia hosts avatars and will render your testimonial in roughly 2-5 minutes. Call the Synthesia API to create a video:

CopyPOST https://api.synthesia.io/v1/videos
Authorization: Bearer YOUR_SYNTHESIA_API_KEY
Content-Type: application/json { "script": { "type": "text", "input": "We've saved about 8 hours a week on reporting. Your automation features are a game changer for our team." }, "avatarConfig": { "avatarName": "Amy", "position": "centre" }, "output": { "format": "mp4", "resolution": "1080p" }, "callbackUrl": "https://your-domain.com/video-ready"
}

Synthesia returns a video_id immediately:

Copyjson
{ "id": "video_5432", "status": "in_progress", "estimatedTime": "3 minutes"
}

Store the video_id and poll Synthesia's status endpoint every 30 seconds until status = "completed":

CopyGET https://api.synthesia.io/v1/videos/video_5432
Authorization: Bearer YOUR_SYNTHESIA_API_KEY

When complete, you'll receive:

Copyjson
{ "id": "video_5432", "status": "completed", "downloadUrl": "https://videos.synthesia.io/output/video_5432.mp4"
}

Why Synthesia over alternatives: It produces photorealistic avatars, is straightforward to integrate, and doesn't require you to source or record footage. The cost per video is low (roughly 50p-£1 depending on length). Data flowing to next step: The download URL, video_id, customer_id, and original testimonial text. Error handling: If Synthesia returns status = "failed", log the error and send a Slack notification. Common causes include unsupported characters in the script or rate limiting. Retry up to 2 times with exponential backoff (wait 5 minutes, then 10 minutes).

Copypython
import time def retry_video_generation(script, max_retries=2): for attempt in range(max_retries): response = create_synthesia_video(script) if response['status'] == 'completed': return response elif response['status'] == 'failed': if attempt < max_retries - 1: wait_time = 5 * (2 ** attempt) time.sleep(wait_time * 60) else: return None

Step 5:

Download video and create social clips Once the video is generated, download it and create shortened versions for social media (15-second and 30-second clips). You have two options: Option A: Use Synthesia's built-in clip generation (if available on your plan) Pass a clips parameter in the initial API call:

Copyjson
{ "script": { ... }, "clips": [ { "duration": 15, "format": "mp4" }, { "duration": 30, "format": "mp4" } ]
}

Option B: Use FFmpeg or a video processing API

Download the full video and trim it locally or via a service like Mux or Cloudinary:

Copybash
ffmpeg -i video_5432.mp4 -ss 0 -t 15 -c:v libx264 -c:a aac output_15s.mp4
ffmpeg -i video_5432.mp4 -ss 0 -t 30 -c:v libx264 -c:a aac output_30s.mp4

Or use the Cloudinary API:

CopyGET https://res.cloudinary.com/yourcloud/video/upload/fl_splice,l_video:sample.mp4,so_0,eo_15/video_5432.mp4

Why this step: Social platforms have different best video lengths. TikTok and Instagram Reels prefer 15-30 seconds. LinkedIn works with longer clips. Pre-generating multiple versions saves your team from doing this manually. Data flowing to next step: URLs for the full video, 15-second clip, and 30-second clip, plus metadata (customer_name, company, original testimonial). Error handling: If video download fails (network timeout, Synthesia CDN issue), retry the download up to 3 times. If all retries fail, send the download URL directly to a Slack channel for manual processing, rather than blocking the entire workflow.

Step 6:

Store videos and metadata, then notify team Save the video URLs, metadata, and status to a database or spreadsheet for easy access and approval. Use Airtable, Google Sheets, or a database like Supabase. Example Airtable record:

Copyjson
{ "customer_id": "cust_12345", "customer_name": "Acme Corp", "testimonial_text": "We've saved about 8 hours a week on reporting...", "full_video_url": "https://videos.synthesia.io/output/video_5432.mp4", "clip_15s_url": "https://videos.synthesia.io/output/video_5432_15s.mp4", "clip_30s_url": "https://videos.synthesia.io/output/video_5432_30s.mp4", "date_created": "2026-03-15", "status": "ready_for_review", "approved": false
}

Then send a notification to your marketing team with a preview and links:

Copyjson
POST https://hooks.slack.com/services/YOUR/WEBHOOK/URL { "blocks": [ { "type": "section", "text": { "type": "mrkdwn", "text": "✅ New testimonial video ready for review\n*Acme Corp*\n\"We've saved about 8 hours a week on reporting...\"" } }, { "type": "section", "fields": [ { "type": "mrkdwn", "text": "*Full Video*\nhttps://videos.synthesia.io/output/video_5432.mp4" }, { "type": "mrkdwn", "text": "*30s Clip*\nhttps://videos.synthesia.io/output/video_5432_30s.mp4" } ] }, { "type": "actions", "elements": [ { "type": "button", "text": { "type": "plain_text", "text": "Approve" }, "value": "approve_cust_12345" }, { "type": "button", "text": { "type": "plain_text", "text": "Request Changes" }, "value": "review_cust_12345" } ] } ]
}

Why this step: It creates an audit trail, allows for human approval before publishing, and makes videos discoverable for your team. Data flowing to next step: An approval status (approved/pending/rejected). Error handling: If the database write fails, retry with exponential backoff. If it fails after 3 retries, email the team a summary of which testimonials couldn't be logged.

The Manual Alternative

If you're testing before automating, or prefer more control, here's the lightweight version: Day 1-3: Draft a testimonial request email template in your email client. Send it personally to 5-10 recent customers. Track responses in a spreadsheet or Slack channel. Day 4-7: As responses come in, copy the best quotes into a document. Use Synthesia's web interface (no API required) to manually create 2-3 videos, choosing avatars and adjusting playback speed as needed. This takes about 3-5 minutes per video. Day 8+: Download the videos, use a free online video trimmer or Kapwing to create 15-second clips, and upload to your social channels or shared drive for approval. Cost: Your time, roughly 2-3 hours per week. Synthesia's pay-as-you-go plan (around 50p per video) if you use the web interface rather than the API. When to do this: If you're only generating 2-3 testimonials per month, manual doesn't cost much. But if you're consistently generating 10+ per month, automation saves time and eliminates tedious copy-pasting.

Pro Tips Batch API calls to reduce token usage:

Instead of calling GPT-4o mini on each email individually, batch process testimonials every hour. Send 10 emails at once in a single API call with instruction to extract each one:

Copyjson
{ "model": "GPT-4o mini", "messages": [{ "role": "user", "content": "Extract testimonials from these 10 emails. Return a JSON array:\n\n1. [Email 1 body]\n\n2. [Email 2 body]\n\n... etc" }]
}

This cuts token usage by roughly 20-30% compared to individual calls, and reduces API latency. Add a rate limit delay between Synthesia requests: Synthesia can queue multiple videos, but if you submit 20 at once, they'll deprioritise yours. Add a 2-3 second delay between submissions:

Copypython
import time
for testimonial in testimonials: create_synthesia_video(testimonial) time.sleep(3)

This ensures consistent rendering speed instead of long queues. Monitor video generation failures with a dashboard: Set up a simple spreadsheet or Grafana dashboard that counts videos by status (completed, failed, in_progress). If failure rate exceeds 10% in a day, Synthesia may be experiencing an outage. Example Google Sheets formula:

Copy=COUNTIF(StatusColumn, "failed") / COUNTA(StatusColumn)

Pre-screen responses with a confidence threshold: Not every reply will be a good testimonial. Use GPT-4o mini to score each one (1-10 scale) on relevance and sentiment before sending to Synthesia. Reject scores below 6 and send a follow-up email asking for more detail:

Copyjson
{ "model": "GPT-4o mini", "messages": [{ "role": "user", "content": "Rate this testimonial 1-10 on relevance and enthusiasm. Score 1-3: generic/negative, 4-6: okay, 7-10: great. Return only the number.\n\n[Email body]" }]
}

Set up CloudWatch or Datadog alerts for failures: Monitor your orchestration tool's error logs. If more than 3 emails in a row fail to parse, or if Synthesia returns 5+ failures in 24 hours, trigger an automated Slack alert. This catches problems before a week's worth of testimonials are stuck in a queue. Cache video URLs with a CDN: Store the Synthesia download URLs in a CDN (Cloudflare, AWS CloudFront) to ensure fast loading on your website and social platforms. Use Cloudflare's cache rules to cache video assets for 30 days:

CopyCache everything: 30 days
Applies to: *.synthesia.io/*

Cost Breakdown