canonical: https://jentic.com/apis/beatapi.io/beatapi

# BeatAPI Developer API

The BeatAPI serves text, image, and video generation plus web search and realtime video behind one key. It creates text responses and chat completions through OpenAI-, Anthropic-, and Gemini-compatible endpoints, and runs image, video, Effects, and multi-shot video workflows as asynchronous tasks the caller polls. Web search, read, map, and research operations return hosted results, and short-lived Realtime Video sessions hand a client secret to the browser.

## For AI agents

Generate text, images, and video and search the web from one API: chat completions, image and video tasks you poll, Effects and video workflows, web research, and realtime video sessions.

## Scope

Does not handle model training, payment processing, or long-term media storage. Use for generating text, images, and video and searching the web only.

## Capabilities

- Generate text with chat completions or the Anthropic- and Gemini-compatible endpoints
- Create image and video generation tasks and poll them to completion
- Run Effects and multi-shot Music Video and Ecommerce Video workflows
- Search, read, and map the web and research a question
- Open short-lived Realtime Video sessions that return a client secret for the browser
- Register webhooks and read account usage and concurrency

## Use cases

### AI Agent Media Generation

An AI agent produces images and video from prompts without a developer wiring separate generation services. Through Jentic the agent creates an image or video task on BeatAPI, polls it by its task_id, and reads the hosted output URL, while the bearer token stays on the developer's own machine.

Example prompt: Create an image generation task from a prompt, poll it by its task_id until complete, and return the hosted output URL

### Asynchronous Task Workflow

Generation jobs take time, so BeatAPI returns a task the caller polls rather than blocking. An agent creates a task, polls the shared task endpoint by its task_id, and reads the result from the output once the job finishes, or subscribes to a webhook to be notified.

Example prompt: Create a video task, poll its status by task_id, and register a webhook to receive the completion event

### Web Research

Agents often need current information before generating content. BeatAPI exposes web search, read, map, and research operations, so an agent can gather sources on a topic and feed them into a text completion in the same workflow.

Example prompt: Run a web search on a topic, read the top results, and summarize them with a chat completion

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/v1/responses` | Create a text response |
| POST | `/v1/chat/completions` | Create a text chat completion |
| POST | `/v1/images/tasks` | Create an image generation task |
| POST | `/v1/videos/tasks` | Create a video generation task |
| GET | `/v1/tasks/{task_id}` | Poll task status |
| POST | `/v1/web/search` | Search the web |
| GET | `/v1/models` | List available text models |
| POST | `/v1/realtime/sessions` | Create a realtime browser session |

## Key resources

- **Text** — Create responses and chat completions through OpenAI-, Anthropic-, and Gemini-compatible endpoints
- **Generation** — Create image, video, and Effects tasks and run Music Video and Ecommerce Video workflows
- **Web** — Search, read, map, and research the web
- **Tasks** — Poll the shared task endpoint for asynchronous job status and output
- **Realtime** — Open, read, and close short-lived Realtime Video sessions
- **Webhooks** — Register endpoints and read account usage and concurrency

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 61 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 51 / 100
  - Developer Experience & Jentic Compatibility: 69 / 100
  - AI-Readiness & Agent Experience: 55 / 100
  - Agent Usability: 94 / 100
  - Security: 44 / 100
  - AI Discoverability: 67 / 100
- **View full report:** https://jentic.com/apis/beatapi.io/beatapi/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring BeatAPI by hand means choosing between its bearer and API-key auth, polling the shared task endpoint, and handling realtime session secrets yourself. Through Jentic you install once, import BeatAPI from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** A single key reaches every BeatAPI operation, so a rule bounds the agent to the operations it needs, such as creating image tasks and polling results. You choose which operations it may call, so webhook deletion and closing other sessions are not included unless you add them.
- **Credential handling:** Your BeatAPI 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 'generate an image' or 'search the web', and Jentic returns the matching BeatAPI operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **OpenAI** — OpenAI offers text, image, and audio models through its own managed API.
- **Replicate** — Replicate runs a broad catalog of image and video models as hosted jobs.
- **Anthropic Messages** — Anthropic Messages serves Claude text models through a dedicated endpoint.

## FAQ

### Is there a BeatAPI MCP server?

You don't need an MCP server to give your agent the BeatAPI. Jentic connects it directly from the API Directory: import it, store your credential once, and your agent calls it. Operations are discovered on demand, so no extra tool definitions load into the agent's context.

### Can I limit what my agent is allowed to do with the BeatAPI?

Yes. Write a rule that allows only the generation and task-poll operations the agent needs, so it can create image or video tasks and read their output but cannot delete your webhooks, and every call is logged.

### What authentication does the BeatAPI Developer API use?

The BeatAPI accepts a bearer token and also an API key in the `x-api-key` header, with Google-style key headers for its Gemini-compatible endpoint, as declared in its OpenAPI spec. Several endpoints, such as listing models and searching capabilities, are public and need no credential. Through Jentic your token or key is stored encrypted by your own Jentic One instance and injected at call time.

### Can I generate images and video with the BeatAPI?

Yes. Create an image or video generation task, then poll the shared task endpoint by its task_id until the job finishes and read the hosted output URL from the result, or register a webhook to be notified.

### How do I generate an image through Jentic?

Install Jentic One with `curl -fsSL https://raw.githubusercontent.com/jentic/jentic-one/main/tools/install.sh | sh`, then import the BeatAPI from the Jentic API Directory and store your token. Your agent searches for 'generate an image' and Jentic returns the image-task operation with its input schema. To run it on your own infrastructure, install Jentic One from its GitHub repo.

### What are the rate limits for the BeatAPI Developer API?

The BeatAPI OpenAPI spec reports account usage and concurrency through a usage operation but does not publish fixed per-second rate limits. Check your account usage endpoint and plan for the concurrency ceiling that applies.
