# AI Video Meme Maker (`prodmarkllc/ai-video-maker`) Actor

Create viral-worthy multi-scene videos using AI. Just describe what you want, and an AI agent orchestrates the entire creative process - from making a plan, finding/editing reference images to generating the final scenes.

The Claude Code agent uses tools to call fal.ai models.

- **URL**: https://apify.com/prodmarkllc/ai-video-maker.md
- **Developed by:** [Mark Rieck](https://apify.com/prodmarkllc) (community)
- **Categories:** AI, Agents, Videos
- **Features:** Limited permissions
- **Stats:** 99 total users, 0 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## AI Meme Maker - Generate Meme Images & Videos from Text Prompts

Create viral-worthy meme images and videos using AI. Just describe what you want, and an AI agent orchestrates the entire creative process - from finding reference images to generating the final meme.

**This actor uses an AI Agent** powered by Claude to intelligently create memes. It searches for reference photos, generates custom images, and combines them into the perfect meme. For videos, it animates your meme with realistic motion using Google's Veo 3.1.

### What does AI Meme Maker do?

AI Meme Maker transforms text descriptions into meme content through a multi-step creative process:

1. **Understands your concept** - Analyzes your prompt to determine the best approach
2. **Gathers reference images** - Searches for real photos or generates fictional characters
3. **Creates the meme** - Combines references into a polished final image
4. **Animates (for video)** - Brings the meme to life with AI-generated motion and audio
5. **Adds captions (optional)** - TikTok-style animated text overlays

#### Why Multi-Step?

Single-shot image generation often fails for memes because:

- AI models struggle to generate recognizable real people without reference
- Generic prompts produce generic results
- The "vibe" of a meme matters as much as the subject

By using a reference-image-first approach, AI Meme Maker creates dramatically better results than simple text-to-image generation.

### Output Types

#### Image Meme

A single still image. Fast and cheap - good for static social posts.

#### Video Meme (default)

A 4-8 second animated video with AI-generated motion and audio. Veo 3.1 can make characters talk with automatic lip sync when you include dialogue in your prompt.

#### Story Mode

Multi-scene videos for longer narratives. The agent breaks your story into 2-6 scenes, generates each one, and stitches them together into a cohesive video (15-45 seconds total).

**Story mode supports two workflows:**

1. **Full execution** - Describe your story and the agent plans + generates everything
2. **Dry run (plan only)** - Get the scene plan first, review it, then execute with approval

### Voiceover vs Character Dialogue

For videos, you have two options for audio:

#### Option 1: Character Dialogue (Default for Veo)

Include dialogue in your video prompt and Veo 3.1 generates the audio with automatic lip sync.

Example prompt: `"Elon Musk looking at the camera saying 'I'm going to Mars, want to come?'"`

#### Option 2: Voiceover/Narration

Request a voiceover in your prompt for off-screen narration. The agent will generate the video without dialogue, create TTS audio with ElevenLabs, and merge them.

Example prompt: `"A cat exploring space with dramatic narration: 'This is one small step for cat, one giant leap for feline kind.'"`

Use voiceover for:

- Explainer videos with product demos
- Documentary-style narration
- Tutorials where you show something while explaining
- Any "narrator voice" that isn't a visible character

### How much will it cost to run?

#### Pricing

AI Meme Maker uses pay-per-use pricing based on what gets generated:

| Event | Price | Description |
|:------|:------|:------------|
| Image Operation | $0.25 | Each image generated, edited, or expanded |
| Video Second | $0.55 | Per second of video generated (4s, 6s, or 8s) |
| TTS Generation | $0.05 | Each voiceover/narration generated |
| Audio Merge | $0.02 | Each audio-video merge operation |
| Agent Turn | $0.01 | Each AI reasoning step |
| Agent Tool Use | $0.01 | Each tool the agent calls |
| Agent Image Read | $0.02 | Each time the agent views an image |

#### Typical Costs

| Meme Type | Typical Cost | What You Get |
|:----------|:-------------|:-------------|
| **Image Meme** | $1-3 | Reference search + 1-3 image generations + agent overhead |
| **Video Meme (4s)** | $4-6 | Image generation + 4s video ($2.60) + agent overhead |
| **Video Meme (8s)** | $6-9 | Image generation + 8s video ($5.20) + agent overhead |
| **Video with Voiceover** | $5-10 | Video + TTS + audio merge + agent overhead |
| **Story (3 scenes)** | $12-20 | Multiple scene generations + merging |
| **Story Dry Run** | $0.10-0.30 | Agent overhead only (no generation) |

With the Free plan's $5 monthly credit, you can create 1-2 image memes or explore the actor's capabilities.

#### Save Money with Your Own Fal.ai API Key

Provide your own fal.ai API key to **eliminate image and video generation charges** (typically 60-80% of the total cost). You'll only pay for agent overhead.

| Meme Type | With Our Key | With Your Key | You Save |
|:----------|:-------------|:--------------|:---------|
| **Image Meme** | $1-3 | $0.20-0.50 | ~80% |
| **Video Meme (4s)** | $4-6 | $0.50-1.00 | ~80% |
| **Video Meme (8s)** | $6-9 | $0.50-1.00 | ~85% |
| **Story (3 scenes)** | $12-20 | $1-3 | ~85% |

**How to get a fal.ai API key:**

1. Sign up at [fal.ai](https://fal.ai) (free tier available)
2. Go to your dashboard and create an API key
3. Paste it in the `falApiKey` input field

Fal.ai offers competitive pay-as-you-go pricing for image/video generation. You'll be billed directly by fal.ai for the generation costs.

### How to use AI Meme Maker

#### Step 1: Write your prompt

Describe the meme you want to create. Be specific about:

- **Who/what** is in the meme
- **The mood/emotion** they should convey
- **The scene/setting**
- **The joke or message** (if applicable)

**Good prompt examples:**

- `"Elon Musk looking confused at a whiteboard full of complicated equations"`
- `"A cute blue alien dancing on the moon"`
- `"Mark Zuckerberg trying to act human at a BBQ"`

**For stories, describe the narrative arc:**

- `"A day in the life of a stressed programmer: waking up tired, fighting with code, celebrating when it finally works"`

**For voiceover, include the narration text:**

- `"A timelapse of a flower blooming with narration: 'Nature's patience teaches us that growth takes time.'"`

#### Step 2: Choose output type

- **video** (default) - Animated meme with motion and audio
- **image** - Static meme image
- **story** - Multi-scene narrative video

#### Step 3: Run the actor

Click "Start" and wait. The agent will:

1. Search for reference images (for real people) or generate them (for fictional)
2. Combine references into the meme scene
3. Review the result and regenerate if needed
4. For videos: expand to correct aspect ratio and animate
5. For stories: repeat for each scene, then merge all videos

#### Step 4: Get your meme

Results are saved to:

- **OUTPUT** key in Key-Value Store - The final result URL
- **Dataset** - Full details including all generated URLs and costs

### Input Parameters

#### Required

| Field | Type | Description |
|:------|:-----|:------------|
| `prompt` | String | Describe the meme you want to create. For stories, describe the narrative arc. For voiceovers, include the narration text. |

#### Optional

| Field | Type | Default | Description |
|:------|:-----|:--------|:------------|
| `memeType` | String | `"video"` | Output type: `"image"`, `"video"`, or `"story"` |
| `dryRun` | Boolean | `false` | Story mode only: return the scene plan without generating content |
| `storyPlan` | Object | - | Story mode only: execute a pre-approved plan from a previous dry run |
| `refineFeedback` | String | - | Story mode only: feedback to refine a previous plan (use with `storyPlan` + `dryRun`) |
| `maxAttempts` | Integer | `5` | Max regeneration attempts before giving up |
| `addCaptions` | Boolean | `true` | Add TikTok-style animated captions (video/story only) |
| `captionPreset` | String | `"bounce"` | Caption style: `"bounce"`, `"highlightColor"`, or `"backgroundBox"` |
| `falApiKey` | String | - | Your own fal.ai API key to save on generation costs |

### Input Examples

#### Simple Image Meme

```json
{
  "prompt": "Elon Musk looking confused at a whiteboard full of complicated equations",
  "memeType": "image"
}
```

#### Video Meme with Character Dialogue

```json
{
  "prompt": "A golden retriever wearing a tiny business suit giving a TED talk, saying 'And that's why treats should be tax deductible'",
  "memeType": "video",
  "addCaptions": true,
  "captionPreset": "bounce"
}
```

#### Video with Voiceover Narration

```json
{
  "prompt": "A majestic eagle soaring over mountains with dramatic narration: 'Freedom isn't given. It's taken. One wing beat at a time.'",
  "memeType": "video"
}
```

#### Story Mode - Full Execution

```json
{
  "prompt": "The rise and fall of a TikTok influencer: starting with zero followers filming in their bedroom, going viral, living the celebrity life, then getting cancelled and back to the bedroom",
  "memeType": "story",
  "maxAttempts": 5
}
```

#### Story Mode - Dry Run (Plan Only)

Get the scene plan first without generating any content:

```json
{
  "prompt": "A day in the life of a cat: waking up, demanding food, ignoring the human, napping in a sunbeam, causing chaos at 3am",
  "memeType": "story",
  "dryRun": true
}
```

**Dry run output example:**

```json
{
  "dry_run": true,
  "story_plan": {
    "title": "A Day in the Life of a Cat",
    "summary": "Follow a house cat through a typical day of demanding attention, strategic napping, and nocturnal chaos.",
    "estimatedTotalDuration": 24,
    "scenes": [
      {
        "sceneNumber": 1,
        "title": "Morning Demands",
        "videoPrompt": "Orange tabby cat sitting next to empty food bowl, meowing loudly at camera",
        "duration": 4,
        "referenceStrategy": "generate",
        "generationPrompt": "fluffy orange tabby cat sitting next to empty silver food bowl, morning kitchen light"
      },
      {
        "sceneNumber": 2,
        "title": "Ignoring the Human",
        "videoPrompt": "Cat deliberately turning away from human's outstretched hand, looking aloof",
        "duration": 4,
        "referenceStrategy": "generate",
        "generationPrompt": "orange tabby cat looking away dismissively, human hand reaching toward it"
      }
    ],
    "styleNotes": "Comedic, relatable cat owner humor"
  },
  "message": "Story plan created - review and execute with storyPlan parameter",
  "total_charge_usd": 0.15
}
```

#### Story Mode - Execute Pre-Approved Plan

After reviewing and optionally editing the dry run plan, execute it:

```json
{
  "prompt": "Execute the cat story",
  "memeType": "story",
  "storyPlan": {
    "title": "A Day in the Life of a Cat",
    "summary": "Follow a house cat through a typical day...",
    "estimatedTotalDuration": 24,
    "scenes": [
      {
        "sceneNumber": 1,
        "title": "Morning Demands",
        "videoPrompt": "Orange tabby cat sitting next to empty food bowl, meowing loudly at camera",
        "duration": 4,
        "referenceStrategy": "generate",
        "generationPrompt": "fluffy orange tabby cat sitting next to empty silver food bowl, morning kitchen light"
      }
    ]
  }
}
```

#### Story Mode - Refine a Plan

Not happy with the plan? Pass it back with feedback to refine it:

```json
{
  "prompt": "A day in the life of a cat",
  "memeType": "story",
  "dryRun": true,
  "storyPlan": { "...previous plan from dry run..." },
  "refineFeedback": "Add a scene where the cat knocks things off a table. Also make the final scene longer - 8 seconds instead of 4."
}
```

The agent receives the full system prompt plus your previous plan and feedback, then returns an updated plan. You can refine multiple times until satisfied, then execute.

#### Complex Scene with Voiceover

```json
{
  "prompt": "Donald Trump and Joe Biden playing chess in Central Park, both looking intensely focused. Narration: 'In Washington, every move is calculated. Every piece has a purpose. But only one can win.'",
  "memeType": "video",
  "maxAttempts": 5
}
```

#### Using Your Own Fal.ai Key (Save ~80%)

```json
{
  "prompt": "A cat astronaut floating in space looking majestic",
  "memeType": "video",
  "falApiKey": "your-fal-api-key-here"
}
```

### API Usage Examples

#### Using cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~ai-meme-maker/runs" -H "Content-Type: application/json" -H "Authorization: Bearer YOUR_APIFY_TOKEN" -d '{"prompt": "A cat astronaut floating in space looking majestic", "memeType": "video"}'
```

#### Story Dry Run via cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~ai-meme-maker/runs" -H "Content-Type: application/json" -H "Authorization: Bearer YOUR_APIFY_TOKEN" -d '{"prompt": "A programmer debugging code at 3am, finding the bug, celebrating", "memeType": "story", "dryRun": true}'
```

#### Using JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';

const apifyClient = new ApifyClient({
    token: 'YOUR_APIFY_TOKEN',
});

// Simple video meme
const run = await apifyClient
    .actor('YOUR_USERNAME~ai-meme-maker')
    .call({
        prompt: 'A cat astronaut floating in space looking majestic',
        memeType: 'video',
        addCaptions: true
    });

console.log('Run started:', run);

// Wait for completion and get results
const { items } = await apifyClient
    .dataset(run.defaultDatasetId)
    .listItems();

console.log('Meme URL:', items[0]?.result_url);
```

#### Story Mode with Plan Refinement (JavaScript)

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const actor = client.actor('YOUR_USERNAME~ai-meme-maker');

// Step 1: Get initial plan (dry run)
const planRun = await actor.call({
    prompt: 'A dog learning to skateboard: first attempts, falling, practicing, finally succeeding',
    memeType: 'story',
    dryRun: true
});

const planResult = await client.dataset(planRun.defaultDatasetId).listItems();
let storyPlan = planResult.items[0].story_plan;

console.log('Initial plan:', JSON.stringify(storyPlan, null, 2));

// Step 2: Refine the plan with feedback
const refineRun = await actor.call({
    prompt: 'A dog learning to skateboard',
    memeType: 'story',
    dryRun: true,
    storyPlan: storyPlan,
    refineFeedback: 'Make it funnier - add a scene where the dog crashes into a trash can. Also add a triumphant ending scene.'
});

const refineResult = await client.dataset(refineRun.defaultDatasetId).listItems();
storyPlan = refineResult.items[0].story_plan;

console.log('Refined plan:', JSON.stringify(storyPlan, null, 2));

// Step 3: Execute the final plan
const executeRun = await actor.call({
    prompt: 'Execute the skateboarding dog story',
    memeType: 'story',
    storyPlan: storyPlan
});

const result = await client.dataset(executeRun.defaultDatasetId).listItems();
console.log('Final video:', result.items[0].result_url);
```

#### Using Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')

run = client.actor('YOUR_USERNAME~ai-meme-maker').call(
    run_input={
        'prompt': 'A cat astronaut floating in space looking majestic',
        'memeType': 'video',
        'addCaptions': True
    }
)

dataset_items = client.dataset(run['defaultDatasetId']).list_items().items

print('Meme URL:', dataset_items[0]['result_url'])
```

#### Story Mode with Plan Refinement (Python)

```python
from apify_client import ApifyClient
import json

client = ApifyClient('YOUR_APIFY_TOKEN')
actor = client.actor('YOUR_USERNAME~ai-meme-maker')

## Step 1: Get initial plan (dry run)
plan_run = actor.call(run_input={
    'prompt': 'A chef cooking a disaster: starting confident, things catching fire, serving burnt food with a smile',
    'memeType': 'story',
    'dryRun': True
})

plan_result = client.dataset(plan_run['defaultDatasetId']).list_items().items[0]
story_plan = plan_result['story_plan']

print('Initial plan:')
print(json.dumps(story_plan, indent=2))

## Step 2: Refine the plan with feedback
refine_run = actor.call(run_input={
    'prompt': 'A chef cooking a disaster',
    'memeType': 'story',
    'dryRun': True,
    'storyPlan': story_plan,
    'refineFeedback': 'Add more drama - include a scene where the smoke alarm goes off. Make the final scene more awkward.'
})

refine_result = client.dataset(refine_run['defaultDatasetId']).list_items().items[0]
story_plan = refine_result['story_plan']

print('Refined plan:')
print(json.dumps(story_plan, indent=2))

## Step 3: Execute the final plan
execute_run = actor.call(run_input={
    'prompt': 'Execute the chef story',
    'memeType': 'story',
    'storyPlan': story_plan
})

result = client.dataset(execute_run['defaultDatasetId']).list_items().items[0]
print('Final video:', result['result_url'])
```

#### Get Run Status

```bash
curl "https://api.apify.com/v2/actor-runs/RUN_ID" -H "Authorization: Bearer YOUR_APIFY_TOKEN"
```

#### Get Results

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items" -H "Authorization: Bearer YOUR_APIFY_TOKEN"
```

### Results

#### Output Structure

```json
{
  "result_url": "https://fal.media/files/example/final-meme.mp4",
  "message": "Created video meme of cat astronaut in space",
  "meme_type": "video",
  "image_gen_count": 2,
  "video_gen_count": 1,
  "video_duration": 4,
  "tts_gen_count": 0,
  "audio_merge_count": 0,
  "total_charge_usd": 4.85,
  "prompt": "A cat astronaut floating in space looking majestic",
  "processing_time_ms": 180000,
  "all_generated_urls": [
    "https://fal.media/files/example/reference.png",
    "https://fal.media/files/example/expanded.png",
    "https://fal.media/files/example/final-meme.mp4"
  ]
}
```

#### Story Mode Output

```json
{
  "result_url": "https://fal.media/files/example/merged-story.mp4",
  "message": "Created 3-scene story video",
  "meme_type": "story",
  "image_gen_count": 6,
  "video_gen_count": 3,
  "video_duration": 16,
  "tts_gen_count": 0,
  "audio_merge_count": 0,
  "total_charge_usd": 15.20,
  "story_plan": { "...plan object..." },
  "scene_results": [
    {
      "sceneNumber": 1,
      "videoUrl": "https://...",
      "duration": 4
    }
  ],
  "canvas_export": { "...canvas format for import..." }
}
```

#### Output Fields

| Field | Description |
|:------|:------------|
| `result_url` | URL to the final meme (image or video) |
| `message` | Description of what was created |
| `meme_type` | `"image"`, `"video"`, or `"story"` |
| `image_gen_count` | Number of image operations performed |
| `video_gen_count` | Number of videos generated |
| `video_duration` | Video length in seconds (0 for images) |
| `tts_gen_count` | Number of TTS/voiceover generations |
| `audio_merge_count` | Number of audio-video merges |
| `total_charge_usd` | Total cost of this run |
| `all_generated_urls` | All intermediate and final assets created |
| `story_plan` | (Story only) The scene plan used |
| `scene_results` | (Story only) Results for each scene |
| `dry_run` | (Dry run only) True if this was a plan-only run |

#### Accessing Generated Assets

All generated images and videos are also saved to the Key-Value Store with keys like:

- `generated-1-filename.png`
- `generated-2-filename.mp4`

This lets you access intermediate results if the final meme used multiple generation steps.

### FAQ

#### What models are used?

- **Images**: nano-banana-pro for generation, reve-remix for combining references
- **Videos**: Veo 3.1 (Google) for best quality with audio, ltxv-2 as fallback
- **TTS/Voiceover**: ElevenLabs with multiple voice options
- **Agent**: Claude for orchestration and decision-making

#### Why did my video fail?

Common reasons:

- **Content policy**: Veo 3.1 has content restrictions. The agent will retry with ltxv-2 automatically.
- **Max attempts reached**: Complex scenes may need more attempts. Increase `maxAttempts`.
- **Ambiguous prompt**: Be more specific about what you want.

#### How long does it take?

- **Image memes**: 1-3 minutes
- **Video memes**: 3-8 minutes (video generation takes ~5 minutes)
- **Video with voiceover**: 4-10 minutes (adds TTS and merge steps)
- **Story (3 scenes)**: 10-20 minutes
- **Story dry run**: 30 seconds - 1 minute (agent planning only)

#### When should I use voiceover vs character dialogue?

- **Character dialogue**: When a visible person/character should be speaking on screen. Veo 3.1 handles lip sync automatically.
- **Voiceover**: When you want narration over the video, documentary style, or when the speaker shouldn't be visible.

#### What's the point of story dry run mode?

Dry run lets you:

1. **Preview the plan** before spending money on generation
2. **Refine the plan** with feedback (pass `storyPlan` + `refineFeedback` + `dryRun: true`)
3. **Iterate multiple times** until the plan is perfect
4. **Approve execution** only when you're happy with the plan
5. **Save money** if the agent misunderstood your story

#### Can I use copyrighted characters?

The AI may struggle with specific copyrighted characters. For best results with fictional characters, describe their appearance rather than naming them.

#### Why are videos limited to 4-8 seconds?

This is a limitation of current video generation models. For longer content, use story mode which chains multiple scenes together (up to ~45 seconds total).

#### Can I disable captions?

Yes, set `addCaptions: false` in your input.

#### How do I save money on runs?

Provide your own fal.ai API key in the `falApiKey` input field. This eliminates image/video generation charges (typically 60-80% of the cost). You'll only pay agent overhead on Apify, and fal.ai bills you directly for generation.

### Support

Having issues or feature requests? Report them on the Apify actor page.

***

*AI-powered meme generation using Claude + fal.ai*

# Actor input Schema

## `prompt` (type: `string`):

Describe the meme you want to create. For stories, describe the narrative arc.

## `memeType` (type: `string`):

Generate a still image meme, animated video meme, or multi-scene story video

## `dryRun` (type: `boolean`):

If true, return only the story plan without generating any content. Use this to preview and approve the plan before execution. Only applies to 'story' meme type.

## `storyPlan` (type: `object`):

Optionally provide a pre-approved story plan (from a previous dry run) to skip planning and execute directly. Only applies to 'story' meme type.

## `refineFeedback` (type: `string`):

Feedback to refine a previous story plan. Use with storyPlan + dryRun to iterate on the plan before execution.

## `maxAttempts` (type: `integer`):

Maximum times the agent will retry if the generated result doesn't match intent

## `addCaptions` (type: `boolean`):

Add animated captions to the final video (video memes only)

## `captionPreset` (type: `string`):

Style preset for captions (only used if Add Captions is enabled)

## `falApiKey` (type: `string`):

Provide your own fal.ai API key to avoid image/video generation charges. Get one free at fal.ai

## `saveToStorage` (type: `boolean`):

Download and save all generated images and videos to Apify key-value storage. Useful for preserving assets since fal.ai URLs expire.

## `referenceImages` (type: `array`):

Provide your own reference images for subjects that can't be found via web search (e.g., your pet, a specific person). Each image needs a URL and description.

## Actor input object example

```json
{
  "prompt": "Elon Musk on Mars eating a burger while looking confused",
  "memeType": "image",
  "dryRun": false,
  "maxAttempts": 5,
  "addCaptions": true,
  "captionPreset": "bounce",
  "saveToStorage": true
}
```

# Actor output Schema

## `result` (type: `string`):

No description

## `results` (type: `string`):

No description

## `costs` (type: `string`):

No description

## `assets` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "prompt": "Elon Musk on Mars eating a burger while looking confused"
};

// Run the Actor and wait for it to finish
const run = await client.actor("prodmarkllc/ai-video-maker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "prompt": "Elon Musk on Mars eating a burger while looking confused" }

# Run the Actor and wait for it to finish
run = client.actor("prodmarkllc/ai-video-maker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "prompt": "Elon Musk on Mars eating a burger while looking confused"
}' |
apify call prodmarkllc/ai-video-maker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,prodmarkllc/ai-video-maker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ljhdFcDsQduYLa4DR/builds/aRcmvShdp69eogsvY/openapi.json