canonical: https://jentic.com/apis/idomoo.com/idomoo

# Idomoo Personalized Video API

Jentic publishes the only available OpenAPI specification for Idomoo Personalized Video API, keeping it validated and agent-ready. Idomoo is a personalised video generation platform - given a storyboard and per-recipient data, it renders unique videos at scale for marketing, sales outreach, and customer success workflows. The 8 endpoints cover storyboard-based generation, scene-level control, batch processing, video status polling, and metadata management for storyboards, scenes, and the account itself.

## For AI agents

Generate personalised videos at scale from storyboards, render individual scenes, run batch jobs, and poll video status through eight endpoints.

## Scope

Does not handle live streaming, audio podcasting, or generative video synthesis from text prompts - use for storyboard-driven personalised video rendering only.

## Capabilities

- Render a personalised video from a storyboard via POST `/storyboard/generate`
- Trigger batched video generation for many recipients at once via POST `/storyboard/batch`
- Render a single scene rather than a full video through POST `/scene/generate`
- Poll a video's render status via GET `/video/{video_id}/status`
- List storyboards and scenes registered to the account through /metadata endpoints
- Retrieve account-level metadata for billing and capacity planning via `/metadata/account`

## Use cases

### Personalised Marketing Outreach

Marketing teams generate unique videos for each recipient - for example a renewal reminder that includes the customer's name, plan, and renewal date. POST `/storyboard/batch` accepts a CSV-shaped payload of recipient data, queues a render per row, and the integrator polls `/video/{video_id}/status` to know when each is ready to send. Most integrations are live within a week because the storyboard work happens in the Idomoo studio rather than in code.

Example prompt: POST `/storyboard/batch` with a list of recipients including name and plan, then poll GET `/video/{video_id}/status` until each render completes

### Sales Outreach Video

Sales reps trigger a tailored video introduction for a prospect - featuring the prospect's company name and use case - by calling POST `/storyboard/generate` with the storyboard ID and a JSON of placeholders. The returned video ID is polled via `/video/{video_id}/status`, and the rendered URL is dropped into the outreach email when ready.

Example prompt: POST `/storyboard/generate` with the storyboard ID and prospect placeholders, then poll `/video/{video_id}/status` and embed the URL when status is ready

### Customer Success Welcome Video

On account activation, generate a personalised welcome video referencing the customer's plan and account manager. The agent calls POST `/storyboard/generate` with onboarding placeholders and surfaces the rendered video in the welcome email. This scales a high-touch onboarding moment without recording each video manually.

Example prompt: POST `/storyboard/generate` with onboarding placeholders for a new customer, poll status, and email the rendered URL

### AI Agent Personalised Video

A customer agent uses Jentic to find Idomoo operations matching 'generate a personalised video', loads the `/storyboard/generate` schema, and renders a tailored video as part of a conversational flow. The agent returns the rendered video URL once `/video/{video_id}/status` reports completion.

Example prompt: Use Jentic search 'generate a personalised video' to load the Idomoo `/storyboard/generate` schema, execute it with placeholders, then poll `/video/{video_id}/status`

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/storyboard/generate` | Render a personalised video from a storyboard |
| POST | `/storyboard/batch` | Batch-render videos for many recipients |
| POST | `/scene/generate` | Render a single scene |
| GET | `/video/{video_id}/status` | Poll the render status of a generated video |
| GET | `/metadata/storyboards` | List storyboards available to the account |
| GET | `/metadata/storyboards/{storyboard_id}` | Retrieve a specific storyboard's metadata |
| GET | `/metadata/scenes` | List scenes registered to the account |
| GET | `/metadata/account` | Retrieve account-level capacity and billing metadata |

## Key resources

- **Storyboard** — Generate full videos from a storyboard, including batch rendering
- **Scene** — Render a single scene rather than a full video
- **Videos** — Poll the render status of a generated video
- **Metadata** — List storyboards, scenes, and account-level metadata

## Why Jentic

- **Setup:** Wiring the Idomoo Personalized Video API by hand means passing your key in the Authorization header against its v3 host and mapping its storyboard, scene, and video status routes yourself. Through Jentic you install once, import the Idomoo Personalized Video API from the API Directory, store the API key once, and your agent calls it.
- **Permission scoping:** Idomoo puts the video and storyboard ids in the URL path (`/video/{video_id}/status`, `/metadata/storyboards/{storyboard_id}`), so a rule can pin your agent to reading the status and metadata of one video or storyboard. You choose the operations it may call, so generating a video or a batch is not included unless you add it.
- **Credential handling:** Your Idomoo API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'render a personalised video from a storyboard' or 'check a video's render status', and Jentic returns the matching Idomoo operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Creatomate API** — Template-based video and image rendering alternative for personalised content
- **Shotstack API** — Programmatic video editing API with JSON-driven timelines
- **HeyGen API** — AI avatar video generation that pairs with Idomoo for talking-head personalisation

## FAQ

### Why is there no official OpenAPI spec for Idomoo Personalized Video API?

Idomoo does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Idomoo Personalized Video API via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Idomoo Personalized Video API use?

The Idomoo API uses an API key passed in the Authorization header. Keys are issued from the Idomoo studio and scope all storyboard and render operations to the account. Through Jentic, the key is stored encrypted in your Jentic One instance and injected at execution time, so it never enters the agent's prompt context.

### Can I generate videos for many recipients in one call?

Yes. POST `/storyboard/batch` accepts a list of recipient payloads and queues a separate render per recipient. The response includes a video ID per recipient that you poll via GET `/video/{video_id}/status` until the render completes. Use this endpoint instead of looping over `/storyboard/generate` for any campaign above a handful of recipients.

### What are the rate limits for the Idomoo Personalized Video API?

Idomoo applies per-account rate limits and a render-minutes quota tied to your subscription tier. The OpenAPI spec does not encode hard thresholds. Build agents to handle 429 responses with backoff and to use `/storyboard/batch` for bulk renders rather than firing many `/storyboard/generate` calls in parallel.

### How do I generate a personalised video through Jentic?

Run pip install jentic and import the SDK, then await client.search('generate a personalised video') to find the Idomoo `/storyboard/generate` operation. Load the schema and execute it with the storyboard ID and placeholder values, then poll `/video/{video_id}/status.` Run Jentic One, the self-hosted execution layer, for an API key.

### How do I check my account's remaining render capacity?

Call GET `/metadata/account` to retrieve account-level metadata that includes the remaining render budget and billing context. This is useful for agents that want to short-circuit large batches when the account is approaching its monthly cap.

### Can I limit what my agent is allowed to do with the Idomoo Personalized Video API?

Yes. Because you run Jentic One yourself, your own rules decide which Idomoo operations and credentials the agent may use. Idomoo puts video and storyboard IDs in the URL path, such as GET `/video/{video_id}/status` and GET `/metadata/storyboards/{storyboard_id}`, so a rule can pin the agent to reading the status and metadata of a single video or storyboard. You pick the operations it can call, so rendering with POST `/storyboard/generate` or POST `/storyboard/batch` stays off unless you add it.
