Forem: 2slide Zhou

Slides Narration Video Best Practices (2Slides + Remotion) — From One Prompt to a Ready-to-Share MP4

2slide Zhou — Sat, 14 Feb 2026 12:18:35 +0000

Slides Narration Video Best Practices (2Slides + Remotion) — From One Prompt to a Ready-to-Share MP4

Creating a slides narration video used to be a multi-hour workflow: outline → design slides → write a script → record voiceover → sync timing → render.

With 2Slides + Remotion, you can now do it in one prompt and get a clean MP4 in ~10 minutes—good enough for product explainers, training, and marketing content.

This guide is a practical checklist for shipping higher-quality narration videos consistently.

What you’re building

A fully automated pipeline:

1) Generate slides (pages/PDF) with 2Slides
2) Generate narration audio with 2Slides
3) Download assets (pages + audio zip)
4) Create a Remotion project and sequence pages + audio
5) Render MP4

The 80/20: what makes narration videos feel “professional”

1) Script first, slides second (even if AI generates both)

A narration video is audio-led. If the narration is clear and well-paced, viewers forgive simple slides. If narration is messy, no amount of design saves it.

Best practices

Keep sentences short (spoken language, not blog language)
One idea per slide
Avoid reading dense paragraphs verbatim

2) Timing rules that never fail

Target 12–18 seconds per slide for explainers
Narration pace: ~140–170 wpm (English)
If narration for a slide exceeds 25–30s, split the slide

3) Visual rhythm: treat slides like cuts

A narration video should feel like “cuts” in video editing.

Alternate layouts (text-heavy → visual → text)
Insert an occasional “breathing slide” (a big headline + 1 icon)
Use consistent margins and font hierarchy

4) Audio quality: loudness and silence

Even with great TTS, you still want predictable audio levels.

Normalize to a consistent loudness target (e.g. -16 LUFS for web)
Add 200–500ms padding between slides when switching topics
Avoid abrupt starts: use a short fade-in (50–100ms)

5) Accessibility: subtitles are a multiplier

If the workflow can produce captions, do it.

Burn-in captions for social distribution
Or ship a sidecar .srt file

Recommended workflow in Claude Code + OpenClaw (copy/paste)

You can run this workflow from an agent environment (Claude Code / OpenClaw) by installing two skill packs:

2Slides skills: https://github.com/2slides/slides-generation-2slides-skills
Remotion skills: https://github.com/remotion-dev/remotion/tree/main/packages/skills

Then use a single prompt like this (replace the topic):

Please help me create a slides narration video for the topic: [YOUR_TOPIC_CONTENT]

- Create slides using 2Slides create pdf slides API; decide the slide pages count by AI.
- Generate voice narration using 2Slides API.
- Download slides pages and voices zip using 2Slides API.
- Create a Remotion project and a slides narration video using pages and voices in sequence.
- Render and output the video.

Real case demo:
https://www.youtube.com/watch?v=_KswiI-Tgdc

Best practices for each pipeline step

Step 1) Slide generation (pages/PDF)

Goal: create slides that are readable at video resolution.

Prefer larger fonts, fewer bullets
Avoid tiny charts (video compression kills them)
Use 16:9 layouts, high contrast

Pro tip: ask the agent to choose slide count based on content length.

Step 2) Voice narration

Goal: match narration structure to slide boundaries.

Generate narration per slide (not one giant audio)
Enforce a consistent tone ("confident, calm, concise")
For acronyms/brand terms: provide pronunciation hints

Step 3) Asset packaging (zip download)

Goal: make rendering deterministic.

Name assets in order: 001.jpg, 002.jpg… and 001.mp3, 002.mp3…
Keep everything in a single folder for Remotion

Step 4) Remotion sequencing

Goal: correct sync, zero glitches.

Set slide duration from audio length + padding
Crossfade (optional): 6–12 frames is enough
Consider a subtle background music bed at -28 to -32 dB

Step 5) Rendering

Goal: export a share-ready MP4.

Use H.264, 1080p, ~8–12 Mbps for most use cases
Validate on mobile (common failure: text too small)

QA checklist (before you ship)

Does each slide’s headline match the narration?
Any slide stays on screen for >25–30s? Split it.
Any slide shows tiny text? Increase font size.
Any abrupt audio start? Add a short fade/padding.
Add subtitles for social distribution.

Next step

Try it with a real topic you care about (a product feature, onboarding flow, or weekly update). If you can turn one prompt into a consistent video pipeline, you can ship content faster than your competitors.

2Slides Agent Skills: Automate AI Slide Workflows with MCP, Codex, and Claude Code

2slide Zhou — Sat, 14 Feb 2026 11:08:29 +0000

2Slides Agent Skills: Automate AI Slide Workflows with MCP, Codex, and Claude Code

AI can write a decent outline for a deck in seconds. But turning that outline into a polished, brand-consistent, editable PPTX—reliably, repeatedly, and at scale—is still hard.

That’s why 2Slides Agent Skills exist.

They give your AI agents (Claude Code, OpenAI Codex, Cursor, etc.) a set of production-ready tools—so your workflow becomes:

brief → agent → skills → editable PPTX output

Skills page: https://2slides.com/skills
GitHub: https://github.com/2slides/slides-generation-2slides-skills
PickSkill: https://pickskill.ai/s/2slides-slides-generation-2slides-skills

This post explains what 2Slides Agent Skills are, why they’re the right abstraction for slide automation, and how to use them to build workflows that marketing, sales, and product teams can trust.

What are 2Slides Agent Skills?
Why “skills” beat one-shot prompting for decks
How 2Slides Agent Skills work
Core capabilities you get (and why they matter for SEO & growth)
Real-world use cases
Using 2Slides Agent Skills in OpenClaw
Getting started
FAQ
Next step

What are 2Slides Agent Skills?

2Slides Agent Skills are reusable, agent-friendly “tool definitions + integration docs” that let AI agent frameworks call 2Slides as a dependable slide engine.

Instead of asking a model to pretend it’s a presentation designer, you let it do what it’s best at (reasoning + writing) and delegate slide construction to skills that are built for:

structured slide layouts
theme/template control
editable PPTX output
consistent results across runs

Think of it like function-calling for presentations: your agent plans the story, the skills generate the deliverable.

Why skills beat one-shot prompting for decks

One-shot prompts like “make me a pitch deck” are fine for demos, but they tend to break in production because:

Output format isn’t guaranteed (you get text, not a real deck)
Design consistency is fragile (layout drifts between runs)
Brand + template rules are hard to enforce
Automation is unreliable (retries, validation, pipelines)

Skills fix this by making slide creation deterministic and testable—the same way mature engineering teams treat PDF generation, invoices, or reports.

How 2Slides Agent Skills work

At a high level, the workflow looks like this:

1) Input: brief / doc / notes / CRM fields / knowledge base
2) Agent reasoning: outline → narrative → slide mapping
3) Skill calls: generate slides + apply themes/templates + export
4) Output: editable PPTX deck + assets (images/links)

Why MCP matters here

If your stack supports MCP (Model Context Protocol), skills become even more valuable:

less glue code
fewer custom wrappers
easier multi-model routing
cleaner ops and maintenance

MCP is the “standard connector” that makes tool-based agents scale.

Core capabilities you get and why they matter for SEO & growth

1) Editable PPTX output (not a screenshot)

For real-world business workflows, editability is non-negotiable.

Growth teams need to:

tweak value props late
swap pricing or metrics
apply brand rules
localize quickly

2Slides is built around PPTX output so humans can review and polish without forcing the agent to regenerate everything.

2) Template and theme control

Instead of hoping the model “keeps a consistent style,” skills let you bind generation to actual templates/themes.

That’s the difference between "looks okay" and "ship-ready".

3) Automation-ready workflows

Skills are designed for repeatable automation:

scheduled reporting decks
sales enablement updates
customer-specific decks
multi-language training

When you can produce decks reliably, you can repurpose content faster—which compounds SEO and distribution.

Real-world use cases

Use case A: Blog/landing page → pitch deck

Turn existing content into decks that follow a consistent narrative structure.

Use case B: Multilingual training decks

Generate localized decks while keeping layout stable and readable across languages.

Use case C: Batch-generated weekly reports

Pull data, summarize, and export decks on a schedule—ready for internal updates or customer reporting.

Using 2Slides Agent Skills in OpenClaw

If you want to run slide-generation workflows straight from chat (Telegram/WhatsApp/Discord/iMessage) with a self-hosted agent gateway, OpenClaw is a great fit.

OpenClaw (https://openclaw.ai/) lets you host your own always-on assistant and connect it to your messaging apps, with tool use, sessions, and memory—so your “deck generation agent” can run from anywhere, on your own hardware.

What this enables

Trigger a deck workflow from chat: “Generate a 10-slide pitch deck from this doc”
Keep context across messages (per-sender / per-thread sessions)
Combine multiple tools: fetch a brief → generate slides via 2Slides → export PPTX → send back the link
Run the same workflow repeatedly (sales enablement, weekly reports, training decks)

High-level setup

1) Run OpenClaw Gateway on your machine or server (Node 22+).
2) Connect a chat channel (Telegram bot, WhatsApp bridge, etc.) so you can message your agent from your phone.
3) Add the 2Slides Agent Skills to your agent environment (from GitHub or PickSkill):

https://github.com/2slides/slides-generation-2slides-skills
https://pickskill.ai/s/2slides-slides-generation-2slides-skills 4) Configure credentials for 2Slides in the way your agent runner expects (API key / env vars).

Example prompts (copy/paste)

From a brief to a deck

Use 2Slides skills to generate an editable PPTX pitch deck (12 slides). Audience: B2B SaaS buyers. Include problem → solution → product → pricing → roadmap → CTA.

Template-controlled generation

Generate the deck using a clean minimal theme. Keep typography consistent, avoid dense paragraphs, and prefer diagrams or bullets.

Batch workflow

For each item in this list, generate a 6-slide one-pager deck and return downloadable PPTX links.

Note: exact tool names/steps depend on the agent platform you run behind OpenClaw (Claude Code / Codex / Cursor). The main idea is consistent: OpenClaw routes your chat message to an agent, and the agent calls 2Slides skills to produce the PPTX.

Getting started

1) Open the skills page: https://2slides.com/skills
2) Choose your agent platform (Claude Code, Codex, Cursor, etc.)
3) Install the skills:

GitHub: https://github.com/2slides/slides-generation-2slides-skills
PickSkill: https://pickskill.ai/s/2slides-slides-generation-2slides-skills 4) Configure credentials (API key / env vars depending on your platform) 5) Run a minimal workflow: outline → generate PPTX → download

FAQ

Are 2Slides Agent Skills only for developers?

No. Developers integrate the workflow; operators and growth teams benefit from repeatable, reliable deck production.

Can I use this with Claude Code, Codex, or Cursor?

Yes. The /skills page links to common agent platforms and explains how to load and run skills.

Do I get editable PPTX files?

Yes. PPTX is the core output format.

Next step

Go to https://2slides.com/skills, pick your agent platform, and run your first automated slide workflow.

Beyond Chatbots: Empowering AI Agents with Professional Presentation Generation (The 2slides Engine Review)

2slide Zhou — Thu, 20 Nov 2025 09:58:42 +0000

By Sarah Elizabeth Senior Solutions Architect & AI Automation Lead November 21, 2025

The "Last Mile" Problem in Generative AI
What is the 2slides AI Presentation Engine?
The Game Changer: MCP Server Integration
Real-World Use Cases: From Data to Deck
Market Analysis: 2slides vs. Gamma vs. Plus AI vs. Slidespeak
Solving Common Developer Pain Points
Conclusion & Next Steps
About Us / Contact

The "Last Mile" Problem in Generative AI

In the last two years, I have overseen the deployment of dozens of Enterprise AI Agents. We’ve mastered the art of RAG (Retrieval-Augmented Generation) for extracting insights and LLMs for summarizing complex reports.

However, we hit a consistent wall: The Deliverable.

Business stakeholders don’t want Markdown text or a chatbot stream. They want a PowerPoint presentation. They want branded, formatted, editable slides that fit their corporate template. Until recently, bridging the gap between an AI Agent’s text output and a pixel-perfect .pptx file was a nightmare of fragile Python scripts and broken layouts.

Enter the 2slides AI Presentation Generation Engine.

What is the 2slides AI Presentation Engine?

2slides.com has evolved from a standard "text-to-slide" tool into a robust infrastructure play. Unlike consumer-facing tools that focus on making pretty web slides, the 2slides Engine is built for developers and enterprise integration.

It is a backend service that allows AI Agents (like those built on LangChain, AutoGen, or custom stacks) to output native PowerPoint files programmatically.

Core Capabilities

Strict Brand Compliance: It doesn't just "guess" a layout. It ingests your master .pptx template (Slide Masters, placeholders, font schemes) and populates it.
Structured Data to Visuals: It converts JSON outputs from LLMs into native PowerPoint text boxes, tables.
Workflow Automation: It is designed to run in the background as part of a larger automated workflow (e.g., "Analyze Q3 sales data -> Generate Report -> Email PPT to Manager").

The Game Changer: MCP Server Integration

The standout feature of 2slides is its delivery via MCP (Model Context Protocol) Server.

For those new to the concept, MCP is an emerging standard that standardizes how AI models interact with external data and tools.

Why this matters for Developers:

Instead of writing complex custom API wrappers for every agent, 2slides providing an MCP Server means you can plug it directly into MCP-compliant environments (like Claude Desktop or custom MCP clients).

The Architecture:

The Agent (e.g., a customized Claude instance) decides it needs to create a slide deck.
The MCP Protocol exposes the 2slides tool definition to the Agent.
The Agent sends structured content + the Template ID.
2slides Engine renders the file and returns the download link or file stream.

My Experience: In a recent internal hackathon, we reduced the time to build a "Market Research Agent" from 3 days to 4 hours because the 2slides MCP server handled all the document formatting logic out of the box.

Real-World Use Cases: From Data to Deck

Here are three scenarios where we have successfully implemented the 2slides Engine.

1. The Automated Weekly Business Review (WBR)

The Challenge: Account managers spent 4 hours every Friday copying data from Salesforce into a corporate PowerPoint template.
The Solution: An AI Agent fetches the data, summarizes key wins/risks, and uses 2slides to populate the exact corporate template.
Result: 100% brand consistent. Zero manual formatting.

2. Hyper-Personalized Sales Outreach

The Challenge: SDRs wanted to send custom decks to 500 leads, referencing specific news about each prospect's company.
The Solution: A script scrapes prospect news, an LLM writes a 5-slide pitch customized to that news, and 2slides generates the distinct PPTX files.
Result: 3x increase in response rate due to high personalization.

3. Training Material Conversion

The Challenge: An EdTech company needed to convert 1,000 PDF textbooks into lecture slides.
The Solution: 2slides ingested the chunked text from the PDFs and mapped them to the company's educational layouts.

Market Analysis: 2slides vs. Gamma vs. Plus AI vs. Slidespeak

As a developer, you have choices. I have tested the APIs of the leading contenders. Below is a comparative analysis based on API capabilities (not just the web UI).

Feature	2slides	Plus AI	Gamma	Slidespeak
Primary Focus	API & Automation (Developer First)	Google Slides Add-on / Enterprise	Web-based Presentation Tool	Document-to-Presentation
API Availability	High (MCP Server + REST API)	High (Robust API)	Limited (Focus is mostly UI)	Medium (REST API available)
Custom Templates	Excellent. Uses your actual `.pptx` masters.	Good. Strong theme editing.	Low. Must use Gamma's "Themes" (web-first).	Medium. Basic template support.
Output Format	Native `.pptx` (Editable)	Google Slides & `.pptx`	Web Page (Export to PDF/PPT)	`.pptx`
Integration Ease	Best for Agents (due to MCP)	Good for Google Workspace	Good for manual users	Simple REST calls
Pricing Model	Usage-based	SaaS Tiered	SaaS Tiered	SaaS Tiered

Detailed Breakdown

1. 2slides (Best for Agent Integration)

Verdict: If you are building an AI Agent that needs to silently generate reports in the background using a strict corporate template, this is the winner. The MCP integration makes it future-proof for LLM development.
Link: 2slides.com

2. Plus AI (Best for Google Workspace)

Verdict: Plus AI is fantastic if your organization lives in Google Slides. Their API is strong, but their "Snapshots" feature acts more like a screenshot tool in some contexts. Good for "Remixing" content.
Link: plusai.com/features/powerpoint-api

3. Gamma (Best for "Pretty" Web Decks)

Verdict: Gamma is undeniably the most beautiful design tool. However, for API usage, it is restrictive. It generates "Gamma decks" which can be exported, but often lose formatting when converted to PowerPoint. It is hard to force it to strictly follow a corporate style guide via API.
Link: gamma.app

4. Slidespeak (Best for Doc-to-PPT)

Verdict: Excellent at taking a Word doc and making a generic presentation. The API is functional, but in my testing, it lacked the granular control over slide masters that 2slides offers.
Link: slidespeak.co

Solving Common Developer Pain Points

When integrating PowerPoint generation APIs, things usually break in specific ways. Here is how the 2slides Engine handles them:

Problem 1: "The text overflows the text box."

The Fix: 2slides Engine has an "Auto-Fit" optimization in the slide engine. It calculates the text density and can either shrink the font size (within brand limits) or automatically split the content onto a "continuation slide" without breaking the flow.

Problem 2: "It doesn't look like our company deck."

The Fix: This is the core value proposition. You can upload your deck as the branded template. Unlike consumer tools that rely solely on AI to "guess" your layout—often resulting in broken designs or misaligned elements—2slides prioritizes rendering fidelity. When you upload your corporate .pptx, the 2slides team manually configures and optimizes the template logic in the backend. While this setup requires a short turnaround time, it solves the "AI layout hallucination" problem, guaranteeing that every subsequent deck generated by your Agent is pixel-perfect and strictly adheres to your brand guidelines.

Conclusion & Next Steps

The era of copy-pasting from ChatGPT to PowerPoint is over. For enterprises scaling their AI operations, the ability to programmatically generate branded presentations is the key to unlocking actual productivity gains.

While tools like Gamma are great for human creativity, 2slides stands out as the infrastructure choice for AI Agents and Automation, particularly due to its MCP Server implementation.

Ready to automate your reporting?
I recommend starting with a Proof of Concept (POC):

Export your company's standard "Weekly Update" template.
Connect the 2slides MCP server to your internal LLM.
Run a test batch using last week's data.

About Me

Sarah Elizabeth, the author, is a certified Cloud Architect with 15 years of experience in software engineering and 4 years dedicated specifically to Generative AI workflows.

Disclaimer: This article is based on technical testing performed in November 2025. API features and pricing are subject to change by the respective providers.

2slides - Free AI Presentations via a Simple API

2slide Zhou — Sat, 11 Oct 2025 06:29:35 +0000

About 2Slides

What is 2Slides?

2Slides is a modern AI-driven presentation generation agent. It automatically generates professional slide presentations based on user input (raw text or content intention), supporting multiple template types and themes.

Overview

The 2slides API allows you to generate professional presentations programmatically using AI. With support for multiple presentation types including timelines, roadmaps, mind maps, and more, you can create stunning slides from simple text input.

Key Features

AI-Powered Generation: Automatically create professional presentations from text
Multiple Template Types: Support for timelines, roadmaps, mind maps, pitch decks, infographics and more
Multi-language Support: Generate content in multiple languages
Rich Template Library: Access to hundreds of professionally designed templates
Custom Templates: Upload and use your own custom slide templates
Search templates: Search template via name, keywords and tags
Download Options: Get presentations in PowerPoint (.pptx) format
Real-time Status Tracking: Monitor generation progress with job status endpoints

Featured Presentation Types

All presentation templates are available here: 2slides Templates. Specifically, there are some featured presentation types that works very well for specific purpose and scenario.

Timeline Slides - Perfect for project timelines and historical events
Roadmap Slides - Ideal for product roadmaps and project planning
Mind Map Slides - Great for concept mapping and knowledge structure

Getting Started

Base URL

All API requests should be made to:

https://2slides.com

Prerequisites

Account Setup: Create an account at 2slides.com
API Key: Generate an API key from your API management page
Credits: Ensure you have sufficient credits for slide generation (10 credits per slide page)

Quick Start

Get your API key from the API management page
Search for a theme using the themes search endpoint, or browse the templates to get the slide theme id
Generate slides with your content and selected theme id, this is an asynchronous call with job id returned
Check job status until completion, the generated slides download URL will be provided
Download your presentation using the provided download URL

Authentication

All API endpoints require authentication using an API key. You can manage your API keys through the API management interface.

API Key Format

API keys follow this format:

sk-2slides-{64-character-hex-string}

Authentication Methods

Authorization Header

Authorization: Bearer sk-2slides-your-api-key-here

API Key Management

Maximum Keys: Each user can create up to 10 API keys
Key Naming: Give your keys descriptive names for easy identification
Security: Keep your API keys secure and never share them publicly
Rotation: Regularly rotate your API keys for enhanced security

⚠️ Important Security Notice: 2slides platform does NOT store your API keys in plaintext for security reasons. Once generated, you must copy and securely store your API key immediately. If you lose your API key, you will need to generate a new one as the original cannot be recovered.

API Endpoints

1. Generate Slides

Generate slides from text input using a specific theme.

Endpoint: POST /api/v1/slides/generate

Headers:

Authorization: Bearer sk-2slides-your-api-key-here
Content-Type: application/json

Request Body:

{
  "userInput": "Your presentation content here...",
  "themeId": "theme-uuid-here",
  "responseLanguage": "Auto"
}

Parameters:

userInput (required): The content you want to generate slides for
themeId (required): ID of the theme to use for slides generation. This can be:
- Public themes from the templates gallery
- Your own custom uploaded themes (accessible through your account)
responseLanguage (optional): Language for the generated slides. Use "Auto" for automatic detection

Available Languages:

Auto - Auto detect language from input (default)
English - English
Simplified Chinese - 简体中文
Traditional Chinese - 繁體中文
Spanish - Español
Arabic - العربية
Portuguese - Português
Indonesian - Bahasa Indonesia
Japanese - 日本語
Russian - Русский
Hindi - हिंदी
French - Français
German - Deutsch
Vietnamese - Tiếng Việt
Turkish - Türkçe
Polish - Polski
Italian - Italiano
Korean - 한국어

Response:

{
  "success": true,
  "data": {
    "jobId": "job-uuid-here",
    "status": "processing",
    "message": "Slides generation started. Use the jobId to check status.",
    "credits": {
      "current": 150,
      "required": 30
    }
  }
}

2. Check Job Status

Check the status of a slides generation job and get results when complete.

Endpoint: GET /api/v1/jobs/{jobId}

Headers:

Authorization: Bearer sk-2slides-your-api-key-here

Response Examples:

Processing:

{
  "success": true,
  "data": {
    "jobId": "job-uuid-here",
    "status": "processing",
    "message": "Slides generation in progress",
    "createdAt": 1703123456789,
    "updatedAt": 1703123460000
  }
}

Success:

{
  "success": true,
  "data": {
    "jobId": "job-uuid-here",
    "status": "success",
    "message": "Slides generated successfully",
    "downloadUrl": "https://presigned-url-here",
    "createdAt": 1703123456789,
    "updatedAt": 1703123500000,
    "duration": 33211,
    "slidePageCount": 3
  }
}

Failed:

{
  "success": true,
  "data": {
    "jobId": "job-uuid-here",
    "status": "failed",
    "message": "Slides generation failed",
    "errorMessage": "Insufficient credits for generation",
    "createdAt": 1703123456789,
    "updatedAt": 1703123460000
  }
}

3. Search Themes

Search for available slide themes by keyword. This includes both public themes and your own custom uploaded themes.

Endpoint: GET /api/v1/themes/search

Headers:

Authorization: Bearer sk-2slides-your-api-key-here

Query Parameters:

query (required): Keyword to search in theme name, description, and tags
limit (optional): Maximum number of results (1-100, default 20)

Example Request:

GET /api/v1/themes/search?query=timeline&limit=10

Response:

{
  "success": true,
  "data": {
    "total": 25,
    "themes": [
      {
        "id": "theme-uuid-1",
        "name": "Modern Timeline",
        "description": "Clean and modern timeline template for project presentations",
        "tags": "timeline, modern, project, clean"
      },
      {
        "id": "theme-uuid-2",
        "name": "Business Roadmap",
        "description": "Professional roadmap template for business planning",
        "tags": "roadmap, business, planning, professional"
      }
    ]
  }
}

Rate Limiting

The API implements rate limiting to ensure fair usage and system stability. Different endpoints have different rate limits:

Endpoint	Time Window	Max Requests	Description
`/api/v1/slides/generate`	1 minute	6 requests	Core generation endpoint
`/api/v1/jobs`	1 minute	10 requests	Job status checking
`/api/v1/themes/search`	1 minute	30 requests	Theme search

Rate Limit Headers

When rate limits are exceeded, the API returns a 429 Too Many Requests response with these headers:

HTTP/1.1 429 Too Many Requests
X-RateLimit-Limit: 6
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1703123600
Retry-After: 45

Handling Rate Limits

You need to handle the API call rate limit carefully, here is an example in Javascript.

async function makeApiRequest(url, options) {
  try {
    const response = await fetch(url, options);

    if (response.status === 429) {
      const retryAfter = response.headers.get('Retry-After');
      console.log(`Rate limited. Retry after ${retryAfter} seconds`);
      await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
      return makeApiRequest(url, options); // Retry
    }

    return response;
  } catch (error) {
    console.error('API request failed:', error);
    throw error;
  }
}

Credit System

2slides uses a credit-based system for slide generation. Each slide page costs 10 credits.

Credit Rules

New Users: Receive 100 free credits upon registration
Cost: 10 credits per slide page generated
Minimum: Users need at least 10 credits to start generation
Deduction: Credits are deducted only after successful generation
Refunds: Credits are refunded if generation fails

Checking Credits

You can check your credit balance through the account dashboard or by examining the credit information in API responses.

Purchasing Credits

Additional credits can be purchased through the pricing page using various payment methods.

Examples

Complete Workflow Example

Here's a complete example of generating slides using the 2slides API in Javascript and Python:

const API_KEY = 'sk-2slides-your-api-key-here';
const BASE_URL = 'https://2slides.com';

async function generateSlides() {
  try {
    // Step 1: Search for a theme
    const themeResponse = await fetch(
      `${BASE_URL}/api/v1/themes/search?query=timeline&limit=5`,
      {
        headers: {
          'Authorization': `Bearer ${API_KEY}`,
          'Content-Type': 'application/json'
        }
      }
    );

    const themeData = await themeResponse.json();
    const themeId = themeData.data.themes[0].id;

    // Step 2: Generate slides
    const generateResponse = await fetch(
      `${BASE_URL}/api/v1/slides/generate`,
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${API_KEY}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          userInput: "Create a timeline for our product development: Q1 - Research and planning, Q2 - MVP development, Q3 - Beta testing, Q4 - Public launch",
          themeId: themeId,
          responseLanguage: "English"
        })
      }
    );

    const generateData = await generateResponse.json();
    const jobId = generateData.data.jobId;

    // Step 3: Poll for completion
    let jobStatus;
    do {
      await new Promise(resolve => setTimeout(resolve, 2000)); // Wait 2 seconds

      const statusResponse = await fetch(
        `${BASE_URL}/api/v1/jobs/${jobId}`,
        {
          headers: {
            'Authorization': `Bearer ${API_KEY}`
          }
        }
      );

      jobStatus = await statusResponse.json();
      console.log(`Status: ${jobStatus.data.status}`);

    } while (jobStatus.data.status === 'processing' || jobStatus.data.status === 'pending');

    // Step 4: Handle result
    if (jobStatus.data.status === 'success') {
      console.log('Slides generated successfully!');
      console.log('Download URL:', jobStatus.data.downloadUrl);
      console.log('Pages generated:', jobStatus.data.slidePageCount);

      // Download the file
      const downloadResponse = await fetch(jobStatus.data.downloadUrl);
      const blob = await downloadResponse.blob();

      // Create download link
      const url = window.URL.createObjectURL(blob);
      const a = document.createElement('a');
      a.href = url;
      a.download = 'presentation.pptx';
      a.click();
      window.URL.revokeObjectURL(url);

    } else {
      console.error('Generation failed:', jobStatus.data.errorMessage);
    }

  } catch (error) {
    console.error('Error:', error);
  }
}

// Run the example
generateSlides();

Python Example

import requests
import time
import json

API_KEY = 'sk-2slides-your-api-key-here'
BASE_URL = 'https://2slides.com'

def generate_slides():
    headers = {
        'Authorization': f'Bearer {API_KEY}',
        'Content-Type': 'application/json'
    }

    try:
        # Step 1: Search for a theme
        theme_response = requests.get(
            f'{BASE_URL}/api/v1/themes/search',
            params={'query': 'roadmap', 'limit': 5},
            headers=headers
        )
        theme_data = theme_response.json()
        theme_id = theme_data['data']['themes'][0]['id']

        # Step 2: Generate slides
        generate_payload = {
            'userInput': 'Create a product roadmap for our mobile app: Phase 1 - Core features, Phase 2 - Advanced features, Phase 3 - AI integration',
            'themeId': theme_id,
            'responseLanguage': 'English'
        }

        generate_response = requests.post(
            f'{BASE_URL}/api/v1/slides/generate',
            headers=headers,
            json=generate_payload
        )
        generate_data = generate_response.json()
        job_id = generate_data['data']['jobId']

        # Step 3: Poll for completion
        while True:
            time.sleep(2)  # Wait 2 seconds

            status_response = requests.get(
                f'{BASE_URL}/api/v1/jobs/{job_id}',
                headers=headers
            )
            status_data = status_response.json()
            status = status_data['data']['status']

            print(f'Status: {status}')

            if status in ['success', 'failed']:
                break

        # Step 4: Handle result
        if status == 'success':
            print('Slides generated successfully!')
            print(f'Download URL: {status_data["data"]["downloadUrl"]}')
            print(f'Pages generated: {status_data["data"]["slidePageCount"]}')

            # Download the file
            download_response = requests.get(status_data['data']['downloadUrl'])
            with open('presentation.pptx', 'wb') as f:
                f.write(download_response.content)
            print('File downloaded as presentation.pptx')

        else:
            print(f'Generation failed: {status_data["data"]["errorMessage"]}')

    except Exception as error:
        print(f'Error: {error}')

# Run the example
generate_slides()

cURL Examples

Search for themes:

curl -X GET "https://2slides.com/api/v1/themes/search?query=timeline&limit=5" \
  -H "Authorization: Bearer sk-2slides-your-api-key-here" \
  -H "Content-Type: application/json"

Generate slides:

curl -X POST "https://2slides.com/api/v1/slides/generate" \
  -H "Authorization: Bearer sk-2slides-your-api-key-here" \
  -H "Content-Type: application/json" \
  -d '{
    "userInput": "Create a timeline for our project milestones",
    "themeId": "theme-uuid-here",
    "responseLanguage": "English"
  }'

Check job status:

curl -X GET "https://2slides.com/api/v1/jobs/job-uuid-here" \
  -H "Authorization: Bearer sk-2slides-your-api-key-here"

Error Handling

The API uses standard HTTP status codes and returns detailed error information in JSON format.

Common Error Responses

400 Bad Request:

{
  "success": false,
  "error": "userInput is required and must be a non-empty string"
}

401 Unauthorized:

{
  "success": false,
  "error": "Authentication required"
}

403 Forbidden:

{
  "success": false,
  "error": "Access denied"
}

404 Not Found:

{
  "success": false,
  "error": "Theme not found"
}

429 Too Many Requests:

{
  "success": false,
  "error": "Rate limit exceeded"
}

500 Internal Server Error:

{
  "success": false,
  "error": "Internal server error"
}

Error Handling Best Practices

async function handleApiRequest(url, options) {
  try {
    const response = await fetch(url, options);
    const data = await response.json();

    if (!response.ok) {
      switch (response.status) {
        case 400:
          throw new Error(`Bad Request: ${data.error}`);
        case 401:
          throw new Error('Authentication failed. Please check your API key.');
        case 403:
          throw new Error('Access denied. You may not have permission for this resource.');
        case 404:
          throw new Error('Resource not found.');
        case 429:
          throw new Error('Rate limit exceeded. Please try again later.');
        case 500:
          throw new Error('Server error. Please try again later.');
        default:
          throw new Error(`API Error: ${data.error || 'Unknown error'}`);
      }
    }

    return data;
  } catch (error) {
    if (error.name === 'TypeError' && error.message.includes('fetch')) {
      throw new Error('Network error. Please check your internet connection.');
    }
    throw error;
  }
}

Best Practices

1. API Key Security

Never expose API keys in client-side code or public repositories
Use environment variables to store API keys securely
Rotate keys regularly for enhanced security
Monitor key usage through the API management dashboard
Store keys securely: Remember that 2slides does not store your API keys, so you must keep them safe
Backup your keys: Store API keys in a secure password manager or encrypted storage

2. Efficient API Usage

Cache theme search results to avoid repeated requests
Implement proper polling intervals for job status checks (2-5 seconds)
Handle rate limits gracefully with exponential backoff
Batch operations when possible to reduce API calls

3. Error Handling

Always check response status codes
Implement retry logic for transient failures
Log errors appropriately for debugging
Provide user-friendly error messages

4. Performance Optimization

Use appropriate polling intervals to avoid unnecessary requests
Implement request timeouts to prevent hanging requests
Cache frequently used data like theme information
Monitor your credit usage to avoid unexpected charges

5. Content Guidelines

Provide clear, structured input for better slide generation
Use appropriate themes for your content type
Specify language when needed for international content
Keep content concise for optimal slide layout

Support & Resources

Documentation & Resources

API Documentation - Interactive API documentation and playground
Templates Gallery - Browse available slide templates
Pricing Information - Credit packages and pricing
Blog - Latest updates and tips

Getting Help

API Playground: Test your API calls directly in the browser at 2slides.com/api
Account Dashboard: Manage your credit usage at 2slides.com/account
Support: Contact support through the main website

Community & Updates

Feature Updates: Stay updated with new features and improvements
Template Library: Regular additions of new professional templates
API Enhancements: Continuous improvements to API performance and features

Conclusion

The 2slides API provides a powerful and flexible way to generate professional presentations programmatically. With its comprehensive feature set, robust error handling, and extensive template library, you can integrate AI-powered slide generation into any application or workflow.

Start building amazing presentations today with the 2slides API! Visit 2slides.com/api to get your API key and begin creating.

Forem: 2slide Zhou

Slides Narration Video Best Practices (2Slides + Remotion) — From One Prompt to a Ready-to-Share MP4

Slides Narration Video Best Practices (2Slides + Remotion) — From One Prompt to a Ready-to-Share MP4

What you’re building

The 80/20: what makes narration videos feel “professional”

1) Script first, slides second (even if AI generates both)

2) Timing rules that never fail

3) Visual rhythm: treat slides like cuts

4) Audio quality: loudness and silence

5) Accessibility: subtitles are a multiplier

Recommended workflow in Claude Code + OpenClaw (copy/paste)

Best practices for each pipeline step

Step 1) Slide generation (pages/PDF)

Step 2) Voice narration

Step 3) Asset packaging (zip download)

Step 4) Remotion sequencing

Step 5) Rendering

QA checklist (before you ship)

Next step

2Slides Agent Skills: Automate AI Slide Workflows with MCP, Codex, and Claude Code

2Slides Agent Skills: Automate AI Slide Workflows with MCP, Codex, and Claude Code

Table of Contents

What are 2Slides Agent Skills?

Why skills beat one-shot prompting for decks

How 2Slides Agent Skills work

Why MCP matters here

Core capabilities you get and why they matter for SEO & growth

1) Editable PPTX output (not a screenshot)

2) Template and theme control

3) Automation-ready workflows

Real-world use cases

Use case A: Blog/landing page → pitch deck

Use case B: Multilingual training decks

Use case C: Batch-generated weekly reports

Using 2Slides Agent Skills in OpenClaw

What this enables

High-level setup

Example prompts (copy/paste)

Getting started

FAQ

Are 2Slides Agent Skills only for developers?

Can I use this with Claude Code, Codex, or Cursor?

Do I get editable PPTX files?

Next step

Beyond Chatbots: Empowering AI Agents with Professional Presentation Generation (The 2slides Engine Review)

Table of Contents

The "Last Mile" Problem in Generative AI

What is the 2slides AI Presentation Engine?

Core Capabilities

The Game Changer: MCP Server Integration

Why this matters for Developers:

Real-World Use Cases: From Data to Deck

1. The Automated Weekly Business Review (WBR)

2. Hyper-Personalized Sales Outreach

3. Training Material Conversion

Market Analysis: 2slides vs. Gamma vs. Plus AI vs. Slidespeak

Detailed Breakdown

1. 2slides (Best for Agent Integration)

2. Plus AI (Best for Google Workspace)

3. Gamma (Best for "Pretty" Web Decks)

4. Slidespeak (Best for Doc-to-PPT)

Solving Common Developer Pain Points

Problem 1: "The text overflows the text box."

Problem 2: "It doesn't look like our company deck."

Conclusion & Next Steps

About Me

2slides - Free AI Presentations via a Simple API

About 2Slides

What is 2Slides?

Overview

Key Features

Featured Presentation Types

Getting Started

Base URL

Prerequisites

Quick Start

Authentication

API Key Format

Authentication Methods

Authorization Header