How to Use Vidiome's API to Automate Article Generation from Video

Vidiome's public REST API lets developers automate the full video-to-article pipeline programmatically — no browser required, no manual uploads. A single POST /api/v1/articles request returns a structured, SEO-optimized blog article from any YouTube URL or video file.

This tutorial covers the endpoint specification, authentication, code examples in curl and Node.js, use case patterns for batch processing and CMS integration, and an automation workflow diagram.

Who This Tutorial Is For

• SaaS developers building content automation features for clients or internal tools
• Content agencies processing 20+ videos per week and needing to eliminate manual Vidiome usage
• Platform teams integrating video-to-article into an existing CMS or content workflow
• Startups building on top of Vidiome's capabilities as a content infrastructure layer

If you're an individual creator rather than a developer, the Vidiome web app is the faster path — this tutorial is specifically for programmatic API usage.

Prerequisites

• A Vidiome account with at least Starter plan (API access requires a paid or trial plan)
• Your Vidiome API key (found in Account Settings → API Keys)
• Basic familiarity with HTTP REST APIs and either curl or Node.js

Vidiome gives 120 free credits on signup — you can test the web app workflow before committing to API integration.

---

Endpoint Overview: POST /api/v1/articles

Vidiome's article generation endpoint accepts a video source and generation parameters, then returns a complete article object.

Request

POST https://vidiome.com/api/v1/articles
Content-Type: application/json
Authorization: Bearer YOUR_API_KEY

Request body

{
  "source": {
    "type": "youtube_url",
    "url": "https://www.youtube.com/watch?v=XXXXXXXXXXX"
  },
  "generation": {
    "language": "en",
    "focus_keyword": "how to convert YouTube video to blog post",
    "output_format": "markdown"
  }
}

source object

Field	Type	Required	Description
type	string	Yes	"youtube_url" or "file_upload"
url	string	Required if type = youtube_url	Full YouTube video URL
file_id	string	Required if type = file_upload"	File ID from a prior /api/v1/files upload

generation object

Field	Type	Required	Description
language	string	Yes	ISO 639-1 code. Supported: en, fr, es, pt, de, ru, hi, uk, id, tr
focus_keyword	string	No	Target SEO keyword — improves H1 and meta alignment
output_format	string	No	"markdown" (default) or "html"

Response

{
  "id": "art_01HZXXX",
  "status": "completed",
  "created_at": "2026-05-15T10:23:41Z",
  "processing_time_seconds": 187,
  "credits_used": 12,
  "article": {
    "title": "How to Convert a YouTube Video to a Blog Post in 5 Minutes",
    "meta_description": "Vidiome converts any YouTube URL to a structured SEO blog post in under 5 minutes. Step-by-step tutorial with Whisper transcription at 95%+ accuracy.",
    "content": "# How to Convert a YouTube Video...\n\n## What You'll Need\n...",
    "word_count": 1247,
    "language": "en",
    "focus_keyword": "how to convert YouTube video to blog post"
  },
  "transcript": {
    "text": "Hey everyone, today I want to show you...",
    "segments": [
      { "start": 0.0, "end": 4.2, "text": "Hey everyone, today I want to show you" },
      ...
    ]
  }
}

Status values

Status	Meaning
queued	Request accepted, processing not started
processing	Transcription and/or article generation in progress
completed	Article ready in response body
failed	Processing error — see error field

For asynchronous polling, use GET /api/v1/articles/{id} with the returned id.

---

Code Examples

curl

curl -X POST https://vidiome.com/api/v1/articles \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "source": {
      "type": "youtube_url",
      "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    },
    "generation": {
      "language": "en",
      "focus_keyword": "content repurposing strategy",
      "output_format": "markdown"
    }
  }'

Poll for completion:

# Replace art_01HZXXX with the id from the initial response
curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://vidiome.com/api/v1/articles/art_01HZXXX

Node.js (fetch)

const VIDIOME_API_KEY = process.env.VIDIOME_API_KEY;

async function generateArticle(youtubeUrl, focusKeyword, language = 'en') {
  // Step 1: Submit article generation request
  const response = await fetch('https://vidiome.com/api/v1/articles', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${VIDIOME_API_KEY}`,
    },
    body: JSON.stringify({
      source: {
        type: 'youtube_url',
        url: youtubeUrl,
      },
      generation: {
        language,
        focus_keyword: focusKeyword,
        output_format: 'markdown',
      },
    }),
  });

  const job = await response.json();

  if (!response.ok) {
    throw new Error(`Vidiome API error: ${job.message}`);
  }

  // Step 2: Poll until completed
  return await pollUntilComplete(job.id);
}

async function pollUntilComplete(articleId, maxAttempts = 30, intervalMs = 10000) {
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    await new Promise(resolve => setTimeout(resolve, intervalMs));

    const res = await fetch(`https://vidiome.com/api/v1/articles/${articleId}`, {
      headers: { 'Authorization': `Bearer ${VIDIOME_API_KEY}` },
    });

    const article = await res.json();

    if (article.status === 'completed') {
      return article;
    }

    if (article.status === 'failed') {
      throw new Error(`Article generation failed: ${article.error}`);
    }

    console.log(`[Vidiome] Status: ${article.status} (attempt ${attempt + 1}/${maxAttempts})`);
  }

  throw new Error('Vidiome: polling timeout exceeded');
}

// Usage
const result = await generateArticle(
  'https://www.youtube.com/watch?v=XXXXXXXXXXX',
  'how to repurpose video content'
);

console.log(result.article.title);
console.log(`Word count: ${result.article.word_count}`);
console.log(`Credits used: ${result.credits_used}`);
// Write to file, push to CMS, etc.

---

Automation Workflow Diagram

Here is the full automation architecture for a typical batch processing pipeline using Vidiome:

┌─────────────────────────────────────────────────────────┐
│                   VIDEO SOURCE LAYER                     │
│  YouTube playlist / RSS feed / CMS video library        │
└──────────────────────┬──────────────────────────────────┘
                       │  Video URLs / file references
                       ▼
┌─────────────────────────────────────────────────────────┐
│                  ORCHESTRATION LAYER                     │
│  Cron job / webhook trigger / n8n / Make.com            │
│  - Deduplication (skip already-processed URLs)          │
│  - Rate limiting (respect API credits budget)           │
│  - Queue management                                     │
└──────────────────────┬──────────────────────────────────┘
                       │  POST /api/v1/articles
                       ▼
┌─────────────────────────────────────────────────────────┐
│                   VIDIOME API                           │
│  1. Whisper transcription (60-sec chunks, 95%+ acc.)   │
│  2. LLM article generation (structure + SEO)           │
│  3. Returns: title, meta, content (MD/HTML), transcript │
└──────────────────────┬──────────────────────────────────┘
                       │  Completed article object
                       ▼
┌─────────────────────────────────────────────────────────┐
│                POST-PROCESSING LAYER                    │
│  - Human review queue (optional but recommended)        │
│  - Internal link injection (add links to existing posts)│
│  - Featured image assignment                            │
│  - Schema markup injection (Article JSON-LD)           │
└──────────────────────┬──────────────────────────────────┘
                       │  Publish-ready article
                       ▼
┌─────────────────────────────────────────────────────────┐
│                    CMS / PLATFORM                       │
│  WordPress (REST API) / Ghost (Admin API)               │
│  Webflow CMS / Contentful / Sanity / Custom DB          │
└─────────────────────────────────────────────────────────┘

---

Use Cases

Batch processing a YouTube channel

Process an entire YouTube channel's back-catalog in one run:

async function processYouTubeChannel(channelVideoUrls, options = {}) {
  const {
    language = 'en',
    concurrency = 3,       // max parallel Vidiome requests
    delayMs = 2000,        // delay between batches (rate limiting)
  } = options;

  const results = [];

  // Process in batches of `concurrency`
  for (let i = 0; i < channelVideoUrls.length; i += concurrency) {
    const batch = channelVideoUrls.slice(i, i + concurrency);

    const batchResults = await Promise.allSettled(
      batch.map(url => generateArticle(url, '', language))
    );

    results.push(...batchResults);
    console.log(`Processed ${Math.min(i + concurrency, channelVideoUrls.length)}/${channelVideoUrls.length} videos`);

    if (i + concurrency < channelVideoUrls.length) {
      await new Promise(resolve => setTimeout(resolve, delayMs));
    }
  }

  return results;
}

A channel with 100 videos processed at 3 concurrent requests: approximately 100 minutes total (average 3 minutes per video × 100 ÷ 3 concurrent).

CMS integration (WordPress example)

After Vidiome returns the article, push it directly to WordPress via the REST API:

async function publishToWordPress(vidiomeArticle, wpConfig) {
  const { siteUrl, username, appPassword } = wpConfig;
  const credentials = Buffer.from(`${username}:${appPassword}`).toString('base64');

  const response = await fetch(`${siteUrl}/wp-json/wp/v2/posts`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Basic ${credentials}`,
    },
    body: JSON.stringify({
      title: vidiomeArticle.article.title,
      content: vidiomeArticle.article.content,  // HTML format recommended for WP
      excerpt: vidiomeArticle.article.meta_description,
      status: 'draft',  // Always draft first for human review
    }),
  });

  return await response.json();
}

Multilingual batch: one video, 10 languages

Generate the same article in all 10 supported languages simultaneously:

const SUPPORTED_LANGUAGES = ['en', 'fr', 'es', 'pt', 'de', 'ru', 'hi', 'uk', 'id', 'tr'];

async function generateMultilingual(youtubeUrl, focusKeywords = {}) {
  const requests = SUPPORTED_LANGUAGES.map(lang =>
    generateArticle(
      youtubeUrl,
      focusKeywords[lang] || focusKeywords['en'] || '',
      lang
    )
  );

  // Run all 10 languages in parallel
  const results = await Promise.allSettled(requests);

  return results.reduce((acc, result, index) => {
    const lang = SUPPORTED_LANGUAGES[index];
    if (result.status === 'fulfilled') {
      acc[lang] = result.value;
    } else {
      console.error(`Failed for ${lang}:`, result.reason);
    }
    return acc;
  }, {});
}

This generates 10 language versions of a single video in roughly 5–8 minutes (parallel processing).

---

Rate Limits and Credit Budgeting

Plan	API rate limit	Credits/month
Free (120 credits)	2 req/min	120 (one-time)
Starter	10 req/min	Per plan
Pro	30 req/min	Per plan
Agency	60 req/min	Per plan

Credit consumption: Each article generation uses 10–15 credits depending on video length. A 10-minute video uses approximately 10 credits; a 60-minute video uses approximately 15 credits.

Budget recommendation for batch processing: Estimate ceil(video_duration_minutes / 4) + 10 credits per video as a conservative budget.

---

Error Handling

The Vidiome API uses standard HTTP status codes:

Code	Meaning	Action
200	Success	Process response
400	Invalid request (bad URL, unsupported language, etc.)	Fix request parameters
401	Invalid or missing API key	Check Authorization header
402	Insufficient credits	Top up account or reduce batch size
429	Rate limit exceeded	Implement exponential backoff
500	Server error	Retry with exponential backoff (max 3 attempts)

---

Frequently Asked Questions

Does Vidiome's API support file uploads, or only YouTube URLs?

Vidiome's API supports both YouTube URLs and direct file uploads. For file uploads, first call POST /api/v1/files with your video file (MP4, MOV, or WebM, up to 2GB), receive a file_id, then pass that file_id to POST /api/v1/articles with "type": "file_upload". This is useful for processing videos not hosted on YouTube — webinar recordings, Loom videos, internal training content, and Vimeo-hosted videos.

How do I handle long videos (60+ minutes) via the API?

Vidiome processes videos up to 4 hours via the API. For videos over 60 minutes, the API response is asynchronous by default — you'll receive a job id immediately, then poll GET /api/v1/articles/{id} every 15–30 seconds until the status is completed. A 90-minute video typically processes in 6–9 minutes. Vidiome's 60-second audio chunking architecture means even very long videos don't hit timeout issues.

Is there a webhook option instead of polling?

Yes. Vidiome supports webhook callbacks for article completion. Add a "webhook_url" field to your POST request body pointing to your endpoint, and Vidiome will send a POST request with the full article object when processing completes — eliminating the need for polling. The webhook payload is identical to the GET /api/v1/articles/{id} response format.

---

Next Steps

• Full Vidiome API reference →
• Convert YouTube videos manually via the web app →
• Repurpose a webinar into 5 articles →
• Try Vidiome free — 120 credits, no card required →