Healthcare patient education video pipeline

Creating patient education videos is one of those tasks that should be routine but currently isn't. A typical workflow requires a scriptwriter to draft content, a voiceover artist or text-to-speech service to record narration, a video creator to assemble visuals, and then manual review before publishing. For a healthcare organisation producing dozens of videos monthly, this becomes a significant operational bottleneck. Each handoff introduces delay, and each manual step creates opportunity for inconsistency....... For more on this, see Healthcare clinic patient education video creation. For more on this, see Healthcare patient education video creation from clinical....

This workflow combines two AI tools to eliminate those handoffs entirely. ElevenLabs handles voice generation with natural-sounding narration; Hour One creates animated video from scripts and audio. By connecting these through an orchestration platform, you can move from a finished script to a publishable video without touching a single interface. A script drops in, and a complete video emerges ready for your patient portal.

The beauty of this setup is that it's genuinely zero manual handoff once configured. No exporting audio files, no uploading to separate platforms, no waiting for someone to stitch things together. The entire pipeline runs automatically.

The Automated Workflow

The flow works like this: a trigger event (perhaps a new row in a spreadsheet, or a webhook from your content management system) provides the script. The orchestration tool passes that script to ElevenLabs to generate audio. Once audio is ready, it goes to Hour One along with metadata (title, presenter name, etc.) to generate video. The completed video is saved to cloud storage or your systems.

Choosing Your Orchestration Tool

For this workflow, n8n is the strongest choice, though Zapier works well if you want simplicity. Here's why n8n wins: it handles conditional logic better, offers more granular control over API interactions, and includes built-in file handling. Make works fine too but adds friction around file management.

If your organisation already runs n8n self-hosted, that's ideal for cost and data residency. If not, the cloud version costs around £25/month and includes ample request quotas.

Step-by-Step Workflow Architecture

Step 1: Trigger

Your trigger mechanism depends on how scripts arrive. Common options:

• Google Sheets: new row with script content
• Form submission: a healthcare staff member fills a form with script details
• Email: script arrives as an attachment or body text
• Webhook: your CMS or document system sends the script directly

For this example, assume a Google Sheet where a new row means "process this script into video". n8n watches for new rows; when found, it extracts the fields: script text, video title, presenter name (optional), and target language.

Step 2: Generate Voiceover with ElevenLabs

ElevenLabs converts your script into professional audio. You'll need an API key from your ElevenLabs account.

The relevant endpoint is the Text-to-Speech API. Here's what a request looks like:

Copy
POST https://api.elevenlabs.io/v1/text-to-speech/{voice_id}
Authorization: xi-api-key YOUR_API_KEY
Content-Type: application/json

{
  "text": "Your patient education script here",
  "model_id": "eleven_monolingual_v1",
  "voice_settings": {
    "stability": 0.5,
    "similarity_boost": 0.75
  }
}

For healthcare content, choose a clear, professional voice. ElevenLabs provides pre-made voice IDs (search their documentation for options like "Rachel" or "Adam"). The stability parameter controls consistency; 0.5 is neutral. Similarity_boost at 0.75 keeps the voice recognisable across different scripts.

In n8n, this becomes an HTTP Request node configured as follows:

Copy
Method: POST
URL: https://api.elevenlabs.io/v1/text-to-speech/21m00Tcm4TlvDq8ikWAM
Headers:
  - Key: xi-api-key
    Value: {{ $env.ELEVENLABS_API_KEY }}
  - Key: Content-Type
    Value: application/json
Body:
{
  "text": {{ $json.script_text }},
  "model_id": "eleven_monolingual_v1",
  "voice_settings": {
    "stability": 0.5,
    "similarity_boost": 0.75
  }
}

The response includes audio as base64-encoded data. n8n receives this and stores it for the next step. The entire process takes 5-15 seconds depending on script length.

Step 3: Prepare Video Metadata

Before calling Hour One, structure your metadata. This includes:

• script text (unchanged from original)
• audio URL (the ElevenLabs output)
• video title
• presenter name (or leave blank for animation-only mode)
• language code (en-US, en-GB, etc.)

Create a node that formats this into Hour One's expected structure:

Copy
{
  "script": {{ $json.script_text }},
  "audioUrl": {{ $json.elevenlabs_audio_url }},
  "title": {{ $json.video_title }},
  "presenter": {{ $json.presenter_name || "" }},
  "language": "en-GB",
  "outputFormat": "mp4"
}

Step 4: Generate Video with Hour One

Hour One's API takes your audio, script, and metadata to produce video. You'll need an API key from Hour One's dashboard.

The relevant endpoint is the Video Creation API:

Copy
POST https://api.hourone.com/api/v1/videos
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

{
  "script": "Your full script text",
  "audio_url": "https://path-to-audio-file.mp3",
  "title": "Understanding Diabetes Management",
  "presenter": {
    "name": "Dr Sarah Chen",
    "style": "professional"
  },
  "settings": {
    "quality": "1080p",
    "language": "en-GB",
    "background": "medical_clinic"
  }
}

In n8n, configure this HTTP Request node:

Copy
Method: POST
URL: https://api.hourone.com/api/v1/videos
Headers:
  - Key: Authorization
    Value: Bearer {{ $env.HOURONE_API_KEY }}
  - Key: Content-Type
    Value: application/json
Body:
{
  "script": {{ $json.script_text }},
  "audio_url": {{ $json.elevenlabs_audio_url }},
  "title": {{ $json.video_title }},
  "presenter": {
    "name": {{ $json.presenter_name }},
    "style": "professional"
  },
  "settings": {
    "quality": "1080p",
    "language": "en-GB",
    "background": "medical_clinic"
  }
}

Hour One processes this asynchronously. The response includes a video_id and a status_url. You'll need to poll this URL until the video reaches "completed" status. Typical generation time is 2-5 minutes.

Step 5: Poll for Completion

Add a loop that checks the video status every 30 seconds:

Copy
GET https://api.hourone.com/api/v1/videos/{video_id}/status
Authorization: Bearer YOUR_API_KEY

Configure n8n to repeat this check up to 20 times (10 minutes maximum wait), stopping early when status becomes "completed".

Step 6: Retrieve and Store Video

Once complete, Hour One provides a download URL. Use n8n's file handling to download the video and save it somewhere useful. Common destinations:

• Google Drive: ideal for review and sharing
• AWS S3: for direct integration with your portal
• Azure Blob Storage: if you're already in Azure
• Local network drive: for on-premises setups

Here's how to save to Google Drive using n8n's built-in Google Drive node:

Copy
Configure the Google Drive node:
- Operation: Upload a File
- Parent Folder ID: {{ $json.drive_folder_id }}
- File Name: {{ $json.video_title }}_{{ now().format('YYYY-MM-DD') }}.mp4
- Binary Data: {{ $json.video_binary_data }}

Step 7: Update Tracking

Finally, update your original record to mark the video as complete. If using Google Sheets:

Copy
- Operation: Update a Row
- Sheet: Video Production Log
- Document ID: {{ $env.SHEET_ID }}
- Row: {{ $json.original_row_number }}
- Data to Set:
  - Video Status: Complete
  - Video URL: {{ $json.drive_video_url }}
  - Completion Time: {{ now().toIsoString() }}

This creates an audit trail and prevents reprocessing the same script twice.

Complete n8n Workflow Structure

Your n8n workflow looks like this (in order):

1. Google Sheets Trigger (watches for new rows)
2. Set Variables (stores script text, title, etc.)
3. ElevenLabs HTTP Request (generates audio)
4. Wait node (pause 2 seconds for audio processing)
5. Hour One HTTP Request (starts video generation)
6. Loop/Wait node (polls video status every 30 seconds, max 10 minutes)
7. Download Video (retrieves completed video file)
8. Google Drive Upload (saves video)
9. Google Sheets Update (marks row complete with video URL)
10. Error Handler (catches failures, sends notification)

The entire flow typically completes in 5-10 minutes per video.

The Manual Alternative

If you prefer more control, handle each step separately. Export your script, upload it to ElevenLabs' web interface manually, download the audio, log into Hour One, upload audio and script, wait for completion, download the video, then manually save it to your system.

This approach works fine if you're producing one or two videos weekly. Beyond that, the manual effort becomes significant. You lose consistency (different voice settings per video), introduce human error, and spend time on tasks machines handle better. Most organisations find the orchestrated approach worthwhile after their first week of manual work.

Pro Tips

Error Handling and Notifications

The orchestration will occasionally fail. Network timeouts, API rate limits, or malformed scripts all cause issues. Configure error handlers in n8n to catch these gracefully:

• If ElevenLabs rejects the script (e.g., too long), log the error and send an email notification with the problematic script.

• If Hour One video generation fails, retry once after 5 minutes before flagging for manual review.

• If Google Drive upload fails, save the video locally as backup before alerting support.

Add a notification node (email, Slack, Teams) at the end of your error handler so someone knows immediately when something breaks.

Rate Limits and Throttling

ElevenLabs limits free tier users to 10,000 characters monthly. Paid tiers go higher but still cap out. If processing multiple videos, space them out. Configure n8n to process one script every 10 minutes rather than dumping ten scripts at once. This keeps you well within quotas and spreads costs evenly.

Hour One also has concurrent video generation limits (typically 3-5 simultaneous videos on standard plans). Don't trigger video generation until the previous one completes. Use a queue node in n8n to serialize requests.

Cost Optimisation

ElevenLabs pricing depends on character count. A typical 2-minute patient education script is 400-500 characters. Their pro plan ($22/month) includes 100,000 characters monthly, supporting 200+ videos. That's excellent value.

Hour One costs per video. Standard quality runs approximately £1-2 per video; premium quality costs more. For a healthcare organisation producing 50 videos monthly, budget £50-100. Negotiate volume discounts with their sales team; many do so once you hit consistent monthly usage.

If budget is tight, start with basic settings (standard quality, single presenter style). Upgrade later if patient feedback warrants higher production value.

Testing and Iteration

Before running production scripts through the workflow, test with dummy data. Create a test spreadsheet with sample scripts, run the workflow on a development n8n instance, and review outputs. Check:

• Does ElevenLabs choose the right voice tone for medical content?

• Does Hour One produce readable text overlays?

• Are videos generating in under 10 minutes consistently?

• Does the video URL stored in your spreadsheet actually work?

Fix issues in the test environment before touching production.

Handling Script Variations

Your scripts won't all be identical length or complexity. Some might be 200 words; others 800. Build flexibility into your workflow:

• Set maximum character limits and reject oversized scripts automatically (with notification).

• Allow optional fields like presenter name and language selection; provide sensible defaults if missing.

• Test your workflow with the longest expected script to ensure timeout settings work.

This prevents surprises in production.

Cost Breakdown

For organisations producing 10-20 videos monthly, this cost is negligible compared to freelance voiceover or video production work. A single freelancer typically charges £200-400 per video. Even at low volume, automation pays for itself quickly.