Content repurposing with Claude: one piece into 10 distribution formats automatically

By the end of this tutorial, you’ll have a working Python + n8n pipeline that takes a single long-form blog post and automatically produces 10 distribution-ready formats — tweet threads, LinkedIn posts, email newsletters, TL;DRs, podcast scripts, and more. This is the content repurposing Claude automation setup I use for publishing workflows, and it runs for roughly $0.01–0.03 per article depending on length.

The core insight: Claude doesn’t need a different “repurposing tool” for each format. You need a well-structured orchestration layer that feeds the same source content into format-specific prompts and handles the outputs cleanly. Here’s how to build it.

1. Install dependencies — Set up the Python environment with the Anthropic SDK and supporting libraries
2. Define the format config — Map each output format to its prompt template and output schema
3. Build the repurposing engine — Write the core function that calls Claude for each format
4. Add parallel execution — Run all 10 formats concurrently to cut total latency
5. Wire up n8n orchestration — Trigger the workflow and route outputs to their destinations
6. Handle structured output and storage — Save results as JSON for downstream tools

Why Claude for Multi-Format Content Repurposing

Most repurposing workflows I’ve seen are brittle because they use one giant prompt asking for all formats at once. Claude handles that poorly — the outputs blend together, and you lose format fidelity. The better pattern is one API call per format, with a system prompt tailored to that specific output type.

Claude 3 Haiku is the right model here for most formats. At $0.25/MTok input and $1.25/MTok output (current pricing), a 2,000-word article costs roughly $0.003 in tokens per format call. For 10 formats, you’re under $0.04 total. If you need higher quality on the LinkedIn post or email newsletter, swap those specific calls to Sonnet — which I do in the implementation below. If you want a detailed breakdown of when Sonnet beats Haiku on real tasks, our Claude vs GPT-4 benchmark covers quality tradeoffs across model tiers.

The other reason to use Claude specifically: it follows nuanced format instructions reliably. “Write a tweet thread, 6 tweets, no hashtag spam, each tweet self-contained” produces exactly that. GPT-4 tends to add hashtags anyway. Small thing, but it matters when this runs unattended.

Step 1: Install Dependencies

pip install anthropic python-dotenv aiohttp asyncio tenacity

# repurpose_engine.py
import os
import asyncio
import json
from anthropic import AsyncAnthropic
from tenacity import retry, stop_after_attempt, wait_exponential
from dotenv import load_dotenv

load_dotenv()

client = AsyncAnthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

Step 2: Define the Format Config

Each format gets its own entry: a model choice, a system prompt, and an approximate max_tokens budget. Don’t try to centralize these — format-specific context in the system prompt is what produces usable output.

FORMAT_CONFIG = {
    "tweet_thread": {
        "model": "claude-haiku-4-5",
        "max_tokens": 600,
        "system": "You are a social media writer. Write a Twitter/X thread of exactly 6 tweets. "
                  "Number each tweet (1/6, 2/6...). Each tweet must stand alone and be under 280 characters. "
                  "No hashtag spam — max 1 hashtag per tweet, only if genuinely relevant. No filler openers.",
    },
    "linkedin_post": {
        "model": "claude-sonnet-4-5",  # Higher quality for LinkedIn — worth the cost
        "max_tokens": 500,
        "system": "You are a B2B content strategist. Write a single LinkedIn post (250-350 words). "
                  "Open with a hook sentence, not a question. Include one concrete insight. "
                  "End with a CTA. No emojis in the first line. Use line breaks for readability.",
    },
    "email_newsletter": {
        "model": "claude-sonnet-4-5",
        "max_tokens": 800,
        "system": "You are an email copywriter. Write a newsletter section: subject line, preview text, "
                  "body (300-400 words), and a single CTA button label. Use <subject>, <preview>, "
                  "<body>, <cta> XML tags to delimit sections. Conversational tone, no corporate speak.",
    },
    "tldr_summary": {
        "model": "claude-haiku-4-5",
        "max_tokens": 200,
        "system": "Write a TL;DR summary of the content in exactly 3 bullet points. "
                  "Each bullet is one sentence. Lead with the most actionable insight first.",
    },
    "podcast_script": {
        "model": "claude-haiku-4-5",
        "max_tokens": 900,
        "system": "Write a 3-5 minute podcast intro script (400-500 words spoken naturally). "
                  "Include a hook, the core problem, 3 key points with transitions, and an outro. "
                  "Write for spoken delivery — short sentences, natural pauses marked with [pause].",
    },
    "video_outline": {
        "model": "claude-haiku-4-5",
        "max_tokens": 400,
        "system": "Create a YouTube video outline with: title (click-worthy, not clickbait), "
                  "hook (first 30 seconds), 5 main sections with timestamps and 2-3 bullet points each, "
                  "and a CTA. Format it clearly with section headers.",
    },
    "seo_snippet": {
        "model": "claude-haiku-4-5",
        "max_tokens": 150,
        "system": "Write an SEO meta description (150-160 characters exactly) and a featured snippet "
                  "answer (40-60 words, direct answer format for a question the article targets). "
                  "Use <meta> and <snippet> tags.",
    },
    "short_form_reel": {
        "model": "claude-haiku-4-5",
        "max_tokens": 300,
        "system": "Write a 30-second short-form video script (Instagram Reel / TikTok). "
                  "Format: Hook (5s) → Problem (5s) → Solution (15s) → CTA (5s). "
                  "Include on-screen text suggestions in [brackets]. Keep it punchy.",
    },
    "slack_community_post": {
        "model": "claude-haiku-4-5",
        "max_tokens": 250,
        "system": "Write a Slack or Discord community post sharing this content. "
                  "Casual tone, like a team member sharing something useful. 100-150 words. "
                  "One genuine question to spark discussion at the end.",
    },
    "internal_briefing": {
        "model": "claude-haiku-4-5",
        "max_tokens": 400,
        "system": "Write a 200-word internal team briefing summarizing this content. "
                  "Format: What it covers, key takeaways (3 bullets), who should read it, "
                  "and one recommended action. Professional, scannable.",
    },
}

Step 3: Build the Repurposing Engine

The retry decorator here is important — Claude API calls occasionally time out or hit rate limits, especially when you’re firing 10 concurrent requests. Proper retry logic for LLM production workflows is worth getting right early, not bolting on later.

@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=2, max=10)
)
async def repurpose_format(
    format_name: str,
    source_content: str,
    config: dict
) -> dict:
    """Call Claude for a single output format. Returns format name + output text."""
    
    response = await client.messages.create(
        model=config["model"],
        max_tokens=config["max_tokens"],
        system=config["system"],
        messages=[
            {
                "role": "user",
                "content": f"Here is the source content to repurpose:\n\n{source_content}"
            }
        ]
    )
    
    return {
        "format": format_name,
        "model_used": config["model"],
        "output": response.content[0].text,
        "input_tokens": response.usage.input_tokens,
        "output_tokens": response.usage.output_tokens,
    }

Step 4: Add Parallel Execution

Running sequentially would take 30-60 seconds for 10 formats. Running concurrently takes 5-10 seconds. asyncio.gather with return_exceptions=True means one failed format doesn’t abort the rest — you get partial results and can log the failures.

async def repurpose_all(source_content: str) -> dict:
    """
    Repurpose one piece of content into all configured formats concurrently.
    Returns a dict with all outputs and aggregate token usage.
    """
    tasks = [
        repurpose_format(fmt, source_content, config)
        for fmt, config in FORMAT_CONFIG.items()
    ]
    
    results = await asyncio.gather(*tasks, return_exceptions=True)
    
    outputs = {}
    total_cost_usd = 0.0
    errors = []
    
    for result in results:
        if isinstance(result, Exception):
            errors.append(str(result))
            continue
        
        fmt = result["format"]
        outputs[fmt] = result["output"]
        
        # Rough cost calculation — update rates as Anthropic changes pricing
        model = result["model_used"]
        if "haiku" in model:
            cost = (result["input_tokens"] / 1_000_000 * 0.25) + \
                   (result["output_tokens"] / 1_000_000 * 1.25)
        else:  # sonnet
            cost = (result["input_tokens"] / 1_000_000 * 3.00) + \
                   (result["output_tokens"] / 1_000_000 * 15.00)
        total_cost_usd += cost
    
    return {
        "outputs": outputs,
        "errors": errors,
        "estimated_cost_usd": round(total_cost_usd, 5),
        "format_count": len(outputs),
    }


# Entry point for direct use
if __name__ == "__main__":
    import sys
    
    source = sys.stdin.read()  # Pipe article content in
    result = asyncio.run(repurpose_all(source))
    print(json.dumps(result, indent=2))

Step 5: Wire Up n8n Orchestration

The n8n workflow is straightforward. If you’re still evaluating orchestration platforms, our n8n vs Make vs Zapier comparison covers the architectural tradeoffs — but for self-hosted Python execution, n8n’s Execute Command node is the most flexible option.

n8n Workflow Structure

• Trigger: Webhook (POST with article JSON body) or RSS Feed node polling your CMS
• Extract content: Function node to pull the article body from the payload
• Execute Python: Execute Command node running echo "$ARTICLE" | python repurpose_engine.py
• Parse JSON output: JSON Parse node on the stdout result
• Route outputs: Switch node → Buffer each format to its destination

For the routing step, typical destinations per format:

• tweet_thread → Buffer node → Tweet scheduling tool (Hypefury, Buffer API)
• linkedin_post → Airtable or Notion for review queue (don’t auto-post LinkedIn without human review)
• email_newsletter → ConvertKit / Mailchimp draft via their API
• tldr_summary → Append to CMS post as excerpt field
• internal_briefing → Slack message to #content-team channel

I’d strongly recommend not auto-posting LinkedIn and email formats. The quality is high enough 80% of the time, but the 20% where Claude misses your brand voice is embarrassing at newsletter scale. Queue them for a 30-second human scan instead.

Step 6: Handle Structured Output and Storage

For the outputs you want to store and track over time, write to a simple JSON file structure or a Postgres table. Here’s the storage wrapper:

import sqlite3
from datetime import datetime

def store_results(article_id: str, article_title: str, results: dict):
    """Store repurposing results in SQLite for auditing and reuse."""
    
    conn = sqlite3.connect("repurpose_log.db")
    conn.execute("""
        CREATE TABLE IF NOT EXISTS repurposing_runs (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            article_id TEXT,
            article_title TEXT,
            format TEXT,
            output TEXT,
            estimated_cost_usd REAL,
            created_at TEXT
        )
    """)
    
    timestamp = datetime.utcnow().isoformat()
    
    for fmt, output_text in results["outputs"].items():
        conn.execute(
            "INSERT INTO repurposing_runs VALUES (NULL, ?, ?, ?, ?, ?, ?)",
            (
                article_id,
                article_title,
                fmt,
                output_text,
                results["estimated_cost_usd"] / results["format_count"],  # Per-format cost
                timestamp
            )
        )
    
    conn.commit()
    conn.close()

This gives you a queryable audit log. When someone asks “what did we generate for that AWS post last month?”, you can pull it in seconds rather than re-running Claude.

Common Errors and How to Fix Them

Error 1: Output truncation on longer formats

Symptom: Podcast scripts or email bodies cut off mid-sentence. Cause: max_tokens set too low, or Claude front-loads verbose context before the actual content. Fix: Bump max_tokens for podcast_script to 1,200 and add “Skip any preamble — output only the script itself” to the system prompt. The preamble problem is real; Claude 3 Haiku especially likes to acknowledge the task before doing it.

Error 2: Rate limit errors with 10 concurrent calls

Symptom: anthropic.RateLimitError on 2-3 of the format calls. Cause: Free tier or Tier 1 API limits — roughly 50 RPM on Haiku. Ten concurrent calls from one script can breach this if you’re running multiple articles. Fix: Add a asyncio.Semaphore(5) to limit concurrency to 5 simultaneous calls, or use the Claude Batch API if you’re processing more than 20 articles at a time.

# Add semaphore to limit concurrent Claude calls
sem = asyncio.Semaphore(5)

async def repurpose_format_limited(format_name, source_content, config):
    async with sem:
        return await repurpose_format(format_name, source_content, config)

Error 3: XML tag parsing fails on email_newsletter output

Symptom: n8n can’t extract the subject/body/CTA because Claude formatted them differently. Cause: Haiku occasionally ignores XML tag instructions when the content has complex formatting. Claude 3.5 Sonnet is far more reliable at structured output. Fix: Either upgrade email_newsletter to Sonnet (which I already have in the config above), or add output validation that checks for the expected tags and retries if missing. See our guide on structured output verification patterns for the retry pattern implementation.

What to Build Next

Add a voice/tone profile layer. Right now, every run uses generic format prompts. The natural extension is a brand voice document that gets injected into each system prompt — a 200-word description of your writing style, phrases you use, things you never say. Store it as a JSON config, merge it with each FORMAT_CONFIG entry at runtime, and suddenly all 10 outputs sound like you rather than generic Claude. Pair this with role prompting techniques to get consistent voice across formats without bloating your context window.