canonical: https://jentic.com/apis/modelrush.ai/modelrush

# ModelRush Public API

The ModelRush API runs chat, image, video, audio, and prediction workloads across many models behind one unified contract. Discovery operations list callable models and available regions so a caller can pick a current model before running a job, and generation operations create chat completions, images, image edits, speech, transcriptions, and asynchronous video jobs. Private upload slots stage source media, predictions track unified job status, and signed webhook endpoints deliver results as they complete.

## For AI agents

Run chat, image, video, audio, and prediction jobs across many models through one API, with model and region discovery, uploads, and signed webhooks.

## Scope

Does not host datasets, fine-tune models, or manage billing accounts. Use for running chat, image, video, and audio inference across models only.

## Capabilities

- List callable models and available regions before selecting one
- Create chat completions against a chosen model
- Generate and edit images from prompts or source media
- Create asynchronous video generation jobs and poll their status
- Synthesize speech and transcribe audio
- Stage private media uploads and receive results through signed webhooks

## Use cases

### AI agent multi-model routing via Jentic

An AI agent connected through Jentic runs a generation job without hardcoding one provider. It searches by intent such as creating a chat completion, Jentic returns the matching ModelRush operation with its input schema, and the agent lists current models, selects one, and runs the job. The developer's own Jentic One instance injects the bearer token at call time.

Example prompt: Call GET /models to list callable models, then POST `/chat/completions` against the chosen model

### Image generation and editing

Design tools create and refine images from prompts. ModelRush generates images from a prompt and edits one or more source images, so an agent can produce a draft, upload a source, and request an edit through the same contract rather than integrating a separate image provider.

Example prompt: Call POST `/images/generations` with a prompt, then POST `/images/edits` with a staged source image

### Asynchronous video and audio jobs

Media pipelines handle long-running generation. ModelRush creates asynchronous video jobs that an agent polls by id, synthesizes WAV speech, and transcribes audio, so a workflow can submit a job, receive a signed webhook on completion, and fetch the unified prediction result.

Example prompt: Call POST `/videos/generations` to start a job, then GET `/videos/generations/{id}` to poll its status

### Region-aware model selection

Teams with data-residency needs pick an execution region before running billable work. The regions operation lists available API surfaces and regions, and the models operation reports what is currently callable, so an agent chooses a region and a current model rather than failing on a retired one.

Example prompt: Call GET /regions to list surfaces and regions, then GET /models to confirm the chosen model is callable

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/models` | List callable models |
| GET | `/regions` | List API surfaces and regions |
| POST | `/chat/completions` | Create a chat completion |
| POST | `/images/generations` | Generate images |
| POST | `/videos/generations` | Create an asynchronous video job |
| GET | `/videos/generations/{id}` | Get video job status |
| POST | `/audio/transcriptions` | Transcribe audio |
| POST | `/webhooks/endpoints` | Create a signed webhook endpoint |

## Key resources

- **Discovery** — List callable models and available API surfaces and regions
- **Chat** — Create chat completions against a chosen model
- **Images** — Generate images and edit source images
- **Video and Audio** — Asynchronous video jobs, speech synthesis, and transcription
- **Predictions and Webhooks** — Track unified job status and deliver results through signed webhooks

## 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:** 63 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 100 / 100
  - Developer Experience & Jentic Compatibility: 61 / 100
  - AI-Readiness & Agent Experience: 43 / 100
  - Agent Usability: 94 / 100
  - Security: 60 / 100
  - AI Discoverability: 64 / 100
- **View full report:** https://jentic.com/apis/modelrush.ai/modelrush/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 the ModelRush API by hand means learning its bearer scheme, listing current models and regions before each job, and polling asynchronous video and prediction status yourself. Through Jentic you install once, import ModelRush from the API Directory, store the token once, and your agent calls the discovery and generation operations.
- **Permission scoping:** ModelRush carries the chosen model in the request body, so Jentic rules bound which operations your agent may call rather than which model. A rule can allow only the discovery and chat completion operations, so billable image, video, and audio generation stay out unless you add them.
- **Credential handling:** Your ModelRush bearer token 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 'create a chat completion' or 'generate an image', and Jentic returns the matching ModelRush operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Replicate API** — Replicate also runs many models behind one API; ModelRush adds region discovery and a unified prediction surface across modalities.
- **fal Platform API** — fal specializes in fast media generation, where ModelRush spans chat, image, video, and audio in one contract.
- **OpenAI API** — OpenAI offers its own models directly; ModelRush routes across many providers behind a single call.
- **ElevenLabs API** — ElevenLabs provides specialist voice synthesis that can sit beside ModelRush's broader generation surface.

## FAQ

### What authentication does the ModelRush API use?

The ModelRush API authenticates with an HTTP bearer token in the Authorization header, per its OpenAPI spec, and the vendor advises keeping API keys server-side. The model and region discovery operations are open, while generation operations require the token. Through Jentic, your token is stored encrypted by your own Jentic One instance and injected at execution time, so it never enters the agent's context.

### Can I run chat, image, and video jobs through one ModelRush contract?

Yes. The chat completions, image generation and edit, video generation, speech, and transcription operations all share one contract, and the models operation lists what is callable, so an agent can route different workloads to different models without separate integrations.

### What are the rate limits for the ModelRush API?

The OpenAPI spec does not state numeric rate limits, and authenticated generation operations may create billable usage. Check the ModelRush documentation at https://modelrush.ai for current limits and pricing before running large jobs.

### How do I create a chat completion through Jentic?

Search Jentic by intent such as creating a chat completion, and it returns the ModelRush operation with its input schema. List current models, select one, and run the completion, with your token injected at call time. To run it on your own infrastructure, install Jentic One from its GitHub repo.

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

Yes. Write a rule that allows only the discovery and chat completion operations, so the agent can list models and converse but cannot start billable image, video, or audio generation jobs unless you add those operations, and every call it makes is logged by your self-hosted instance.

### Is there a ModelRush API MCP server?

You do not need an MCP server to give your agent the ModelRush API. Jentic connects it directly from the API Directory: import it, store your bearer token once, and your agent calls the discovery and generation operations on demand without loading another server's tool definitions into its context.