API and MCP

Put Covely inside your stack, and inside your agents.

Generate programmatically over REST, or expose Covely as a tool your agents can call over MCP. Both use the same scoped API keys and the same asynchronous model — and both let you hand over the brief or hand over the prompt.

Get an API key Talk to Sales

One key reaches every engine. No per-model integration to write, and no client library per vendor.

A Covely core wired out through API and MCP: on one side your system, AI agents, internal tools, databases and custom workflows; on the other a grid of third-party tool and channel marks and a row of agent types; and a panel showing a JSON request for a social video and the file it returns

Integrate once

One key, one call, and every engine behind it.

No per-model integration to write and no SDK to lock into: a scoped bearer key, one asynchronous call, and everything else follows.

01
Connect once
One key reaches every engine. Nothing to add on your side when a new one is wired in.
02
Send a job
One POST: hand over a brief, or name the model and send the prompt yourself.
03
Collect the result
Every format you asked for, on the brand kit you referenced.

Director or model

Hand over the brief, or address the model yourself.

The two ways of working in the app are both callable. The difference is the same one it is in the studio: how many of the decisions you hand over. Same key, same asynchronous model, same engine underneath.

Director mode

You send the brief and Covely's agent takes it from there: it reads the brand kit, works out what it can, writes the prompt, and reports the decisions it took alongside the assets. It can also come back with a question — the same conversation the app has, over the same endpoint — so a job that needs one more answer asks for it instead of guessing.

You send. The objective, the product, the brand kit — in one call or over a conversation.
It decides. Mode, aspect ratio, duration, style, light, camera grammar — and which engine the job goes to.
You get back. The assets, and what it chose to make them.

This is Autopilot, called from your code.

Model mode

You address the engines directly. Covely is already integrated with each of them, so you name the model, send your own prompt, and reach it through the same key — no per-vendor account, contract or client to maintain.

You send. The model, the prompt, the formats, and any lever you want fixed.
It decides. Nothing you have specified.
You get back. The assets, reproducible from the same request and the same seed.

This is PRO, called from your code.

the brief, in Director modejson

{
  "mode": "director",
  "type": "video",
  "brand_kit_id": "bk_7Qd2",
  "product_id": "prod_A19f",
  "brief": "spring refill promo, for Instagram",
  "formats": ["9:16", "1:1"]
}

the same job, in model modejson

{
  "mode": "model",
  "model": "seedance-2.5",
  "type": "video",
  "brand_kit_id": "bk_7Qd2",
  "prompt": "morning kitchen counter, slow push in",
  "formats": ["9:16"],
  "seed": 42841
}

One field decides which of the two you are in. Everything after that — scopes, queueing, polling, webhooks — is identical, and you can call the same key both ways. Confirm the exact field names in your dashboard: they are versioned per account.

The engines

Wired in today, and reachable with the same key.

Model mode names one of these. Director mode picks from them for you and says which it chose. Either way the integration is ours to keep working: no vendor account of your own, no second contract, no client library per model.

Video

A brief or a prompt in, a finished cut out — in the ratios and the lengths the placement wants.

Seedance 2.5ByteDance
Veo 3.1Google, on Vertex
KlingKuaishou
Wan 3.0Alibaba
Gemini Omni FlashGoogle, on Vertex
GrokxAI

Images

Stills, sets, variants, and 3D objects, from the same request as the video.

SeedreamByteDance
Nano BananaGoogle, on Vertex
FluxBlack Forest Labs
GPT Image 2OpenAI
Hunyuan3DTencent
GrokxAI

Audio

Voice, narration and dialogue, in the language the market speaks.

ElevenLabsElevenLabs

Models are infrastructure. The routing rules live in code, not in a prompt, so a better engine is a change to the rules and not to the way you work — and not a migration in yours.

Creative Automation

A production method, not a content type.

This is how the other six outcomes run at volume: the same brand rules and the same workflows, triggered by your data instead of by a person. Catalogs, spreadsheets and API calls in, finished creative out.

01
Approve one direction
Get a single creative right, with the brand rules attached.
02
Turn it into a template
Save the structure so it can run again without a rebuild.
03
Point it at the data
Feed a catalog, a sheet or an API payload with the rows to produce.
04
Run the batch
Generate across products, formats, languages and markets.
05
Collect the output
Pull finished assets back into your stack through the API.

Adapt and reuse

Reformat for other channels. One approved asset recomposed for every ratio and placement, not stretched.
Translate and localize. Copy, voice and on-screen text per market, from the same source.
Generate new variants. More executions from a direction that already works.
Update one detail. Change the price, the claim, the pack or the season without regenerating the asset.
Long video into short clips. One long cut broken into the short pieces the feed actually takes.

Clone a reference

Clone an ad. Take a structure that works and rebuild it with your product and your brand.
Clone a visual style. Match a look you have been given, then apply it across a set.
Recreate a shot. Rebuild a specific frame you cannot reshoot, with your own product in it.
Redo a winning asset. Your own best performer, produced again for a new product or market.

One call, three formats

A generation request references a brand kit and a product, so the output arrives on brand and in every ratio you asked for.

POST /v1/generationscurl

curl -X POST https://api.covely.ai/v1/generations \
  -H "Authorization: Bearer $COVELY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "model",
    "type": "image",
    "brand_kit_id": "bk_7Qd2",
    "product_id": "prod_A19f",
    "prompt": "morning kitchen counter, natural light",
    "formats": ["1:1", "4:5", "9:16"]
  }'

GET /v1/generations/gen_8kPz2mQjson

{
  "id": "gen_8kPz2mQ",
  "status": "succeeded",
  "assets": [
    { "format": "1:1",  "url": "https://cdn.covely.ai/..." },
    { "format": "4:5",  "url": "https://cdn.covely.ai/..." },
    { "format": "9:16", "url": "https://cdn.covely.ai/..." }
  ]
}

Confirm exact endpoint paths, field names and current limits in your dashboard when you create a key. Those are versioned per account.

MCP

Covely as a tool your agents can call.

MCP exposes the same capabilities to agent workflows rather than to code you wrote by hand. Point your MCP client at the server and authenticate with the same key.

Same scopes, same asynchronous model
Either mode: hand the agent's brief to the Director, or let it send its own prompt
Agents can generate, then collect assets
Useful when the trigger is a conversation, not a cron job

mcp client configjson

{
  "mcpServers": {
    "covely": {
      "url": "https://mcp.covely.ai",
      "headers": { "Authorization": "Bearer ${COVELY_API_KEY}" }
    }
  }
}

Where it plugs in

The integrations teams ask for first.

The connectors panel: API and MCP on one side, and on the other the agents, tools and channels they reach — Connect, integrate, create — the same capabilities the app has, reachable from your own code and from an agent.

Catalog and PIM

Trigger generation when a SKU appears or changes.

DAM

Push finished assets back where your team already looks for them.

Campaign tools

Produce the formats a placement needs as part of the campaign build.

Agents

Let an agent chain generation into a longer task over MCP.

Get a key and try one call.

Create an account, or talk to us about volume and dedicated environments.

Get an API key Talk to Sales

Put Covely inside your stack, and inside your agents.

Connect once

Send a job

Collect the result