# Meet the imageat API: How It Works and What You Get

> Explore the imageat API for image, video, text, and creative workflows. Compare available AI models, pricing, endpoints, billing, and setup.

- URL: https://imageat.com/blog/imageat-api-models-pricing-developer-guide
- Author: Yunus Emre Özdiyar (imageat)
- Published: 2026-09-25
- Category: Guides
- Tags: imageat API, AI models, AI image API, AI video API, LLM API, developer guide

Building generative features usually means stitching together different providers for text, images, video, and post-production. Each integration brings its own authentication, request format, billing system, and failure handling. The imageat API puts these capabilities behind one authenticated REST API so developers can move from model testing to production without rebuilding the same infrastructure for every modality.

The best place to start is the live [imageat model catalog](https://imageat.com/models). It shows the models currently available for language, image, and video workloads, with links to model-specific playgrounds and integration guides. You can compare capabilities first, test the right model, and then use the same imageat API key in your application.

This guide explains what the imageat API provides, which model categories are available, how billing works, and what a production integration looks like.

## What is the imageat API?

The imageat API is a developer interface for generating images, video, text, and multi-step creative workflows. Its base URL is `https://api.imageat.com/v1`, and requests are authenticated with a Bearer API key created from the imageat Projects area.

Instead of maintaining a separate integration for every model provider, applications can use imageat's model IDs, authentication, billing, and response patterns. Depending on the workload, developers can:

- Generate or edit images through a single image endpoint.
- Create text-to-video or image-to-video clips through an asynchronous video endpoint.
- Call language models through OpenAI-compatible Chat Completions and Responses API formats.
- Trigger published creative workflows that combine models and processing steps.
- Connect compatible AI clients through the imageat MCP server when a no-code or agent-oriented setup is more appropriate.

The API is designed for server-side use. Live keys begin with `iat_live_`, while sandbox keys begin with `iat_test_`. Keys should never be exposed in browser code, mobile applications, public repositories, or client-side environment variables.

## One catalog for text, image, and video models

The [AI model catalog on imageat](https://imageat.com/models) is more than a directory. It is the discovery layer for the API: developers can compare model capabilities, open live playgrounds, review model-specific controls, and identify the model ID required by an integration.

At the time of writing, the catalog lists:

- **14 language and chat models** for reasoning, coding, research, multimodal analysis, and agent workflows.
- **7 image models** for generation, editing, reference-guided creation, and background removal.
- **3 video models** for text-to-video, image-to-video, frame-controlled generation, styles, and optional audio.

The catalog is designed to expand as new text, image, video, and audio endpoints become available. Because availability and pricing can change, use the [live models page](https://imageat.com/models) rather than treating a static model list as permanent documentation.

### Language and chat models

The language catalog includes hosted models for general chat, coding, research, visual understanding, and long-context work. The API uses an OpenAI-compatible interface, making it easier to connect existing tools and SDKs by changing the base URL and model ID.

Current catalog examples include the Qwen 3.8 family, Gemini Flash variants, GPT models, Grok, GLM, GPT-OSS, and Claude models. Each catalog page describes the intended workload and links to a browser playground when available.

For example, [Qwen 3.8 27B Uncensored on imageat](https://imageat.com/models/qwen-3-8-27b-uncensored) is exposed through an OpenAI-compatible chat endpoint with a 262,144-token context window and optional thinking mode. Developers can test prompts in the playground before moving the same parameters into a backend integration.

### Image generation and editing models

The image API uses `POST /v1/images` for supported generation and editing models. Switching models usually means changing the `model` value while keeping the same authentication and core response flow.

Models currently represented in the catalog include:

- GPT Image 2.5 and its Sunburst variant for generation, scoped editing, multiple quality tiers, and transparent cut-outs.
- GPT Image 2 for instruction-following image generation and editing.
- Nano Banana Pro for high-fidelity generation and editing with up to 4K output.
- Nano Banana 2 for fast, cost-efficient creative iteration.
- Seedream 5 Pro and Lite for generation and reference-guided editing.
- Ideogram Remove Background for producing transparent PNG outputs while preserving difficult edges.

Supported controls vary by model. Common parameters include prompt, reference images, aspect ratio, resolution, quality, output format, transparent background, and number of outputs. The [imageat API documentation](https://imageat.com/docs/api) provides the current model IDs and accepted parameter combinations.

### Video generation models

Video generation uses `POST /v1/videos`. A request can return a task ID and generation ID immediately while rendering continues in the background. The application then polls the status endpoint or supplies a webhook URL to receive the completed result.

The current [imageat model catalog](https://imageat.com/models) highlights three video options:

- [MiniMax H3 Max](https://imageat.com/models/minimax-h3-max) for 5–15 second text-to-video, image-to-video, and first/last-frame generation at 480p or 768p.
- [Seedance 2.5](https://imageat.com/models/seedance-2-5) for 4–30 second text, image, reference, and frame-controlled video at 480p or 720p, with optional synchronized audio.
- [Pixverse V6](https://imageat.com/models/pixverse-v6) for 1–15 second text or image-driven video, up to 1080p, with optional audio and style controls.

A common integration pattern is to begin with a lower-cost or faster configuration for drafts, then move selected generations to a higher-resolution setting for final delivery.

## How to get started

A basic imageat API setup has four steps.

### 1. Choose a model

Open the [imageat models page](https://imageat.com/models) and choose the category that matches the product feature you are building. Review the model page for supported inputs, output formats, duration or resolution options, and current pricing.

Testing in the live playground first can prevent unnecessary integration work. It also helps establish realistic defaults before those controls are exposed to end users.

### 2. Create an API key

Create a key from the [imageat API keys area](https://imageat.com/projects/keys). Store it in a server-side secret manager or environment variable such as `IMAGEAT_API_KEY`.

Every request sends the key as a Bearer token:

`Authorization: Bearer iat_live_...`

If a key is exposed, revoke it and create a replacement. Production code should also separate sandbox and live credentials.

### 3. Call the appropriate endpoint

Choose the endpoint based on the workload:

- Images: `POST https://api.imageat.com/v1/images`
- Videos: `POST https://api.imageat.com/v1/videos`
- Video status: `GET https://api.imageat.com/v1/videos/status`
- Chat Completions: `POST https://api.imageat.com/v1/chat/completions`
- Responses API: `POST https://api.imageat.com/v1/responses`
- Published workflows: `POST https://api.imageat.com/v1/workflows/{workflow_id}/runs`

The image endpoint returns generated output URLs in its response. Video and workflow jobs are asynchronous, so applications should persist the returned identifiers and track the run until it completes.

### 4. Store completed outputs

Completed image and video responses include CDN-hosted output URLs. Copy production assets into your own long-term storage when your application requires permanent retention, custom access control, or a separate delivery policy.

## A practical image request

For a basic image generation, send a model ID, prompt, output size, format, and number of images. A request might use `nano-banana-pro` for a high-fidelity product visual or `gpt-image-2.5` when the workflow needs selectable quality tiers and transparent-background support.

A typical payload contains:

- `model`: the API model ID selected from the catalog.
- `prompt`: the generation or editing instruction.
- `images`: optional public URLs or base64 data URLs for reference-guided work.
- `aspectRatio`: values such as 1:1, 16:9, or 9:16.
- `resolution`: 1K, 2K, or 4K where supported.
- `outputFormat`: PNG, JPEG, or WebP.
- `numImages`: between one and four outputs.

Model-specific options remain important. GPT Image 2.5, for example, supports additional quality levels and transparent-background output, while other models expose different editing or resolution controls. Check the selected model's page before sending optional parameters.

## A practical video request

Video requests require a slightly different architecture because generation runs asynchronously.

A production flow normally looks like this:

1. Send the model, prompt, duration, resolution, aspect ratio, and optional image inputs to `POST /v1/videos`.
2. Save the returned `taskId` and `generationId` before doing anything else.
3. Poll the status endpoint every 5–10 seconds, or provide a webhook URL with the original request.
4. When the status becomes `completed`, save the returned CDN video URL.
5. If the task fails, record the error and allow the platform's refund flow to complete before retrying.

For image-to-video, send an `imageUrl`. For a directed transition, supported models can accept both `firstFrameUrl` and `lastFrameUrl`. Available durations, resolutions, audio controls, and frame modes depend on the selected model.

Webhook deliveries can be protected with a secret. imageat encrypts the supplied secret at rest and sends an HMAC-SHA256 `x-imageat-signature`, allowing your backend to verify that the callback is genuine.

## OpenAI-compatible language model access

The language API is designed to fit existing OpenAI-compatible clients. Set the base URL to `https://api.imageat.com/v1`, use an imageat API key, and select a supported model ID from `GET /v1/models`.

This makes it possible to use compatible OpenAI SDKs, Vercel AI SDK integrations, opencode, Cline, Continue, and similar clients without creating a separate request layer for every hosted language model.

Two interfaces are available:

- `POST /v1/chat/completions` for familiar role-based conversations and optional streaming.
- `POST /v1/responses` for Responses-style inputs, tools, structured function calls, stored responses, and compatible server-sent events.

Model support and controls differ. Rather than guessing an identifier, query `GET /v1/models` or copy the current value from the relevant page in the [imageat model catalog](https://imageat.com/models).

## Multi-step workflows through one API

Not every creative task should be reduced to one model call. A production pipeline may generate an image, edit it, remove its background, create a video, and prepare the final asset for another system.

The imageat Workflow API lets developers publish a visual workflow once and trigger it through an authenticated request. A typical run uses three stages:

1. Create a workflow run.
2. Track it through polling or server-sent events.
3. Read the CDN-hosted outputs from the completed response.

This approach separates the calling application from the internal creative pipeline. Teams can update models or processing steps inside the published workflow without rebuilding the entire product integration.

Developers who want a visual starting point can explore the [image generation API](https://imageat.com/ai-image-generation-api) and [video generation API](https://imageat.com/ai-video-generation-api) workflow pages before implementing a custom backend.

## How imageat API pricing works

API pricing depends on the selected model and configuration. The [imageat API pricing page](https://imageat.com/api-pricing) is the source of truth for current rates.

With an active imageat subscription, API and MCP requests first use subscription credits at the same model rates as the website. When those credits are exhausted—or when no subscription is active—requests use the prepaid USD API balance.

Current starting-price examples in the documentation include:

- GPT Image 2.5: from $0.02 per image at low quality and 1K.
- GPT Image 2: from $0.02 per image at low quality and 1K.
- Seedream 5 Lite: from $0.07 per image at 1K.
- Nano Banana 2 Lite: from $0.08 per image at 512px.
- Seedream 5 Pro: from $0.14 per image at 1K.
- Nano Banana 2: from $0.16 per image at 1K.
- Nano Banana Pro: from $0.40 per image at 1K.
- Ideogram Remove Background: $0.01 per image.
- MiniMax H3 Max: from $0.25 for a five-second 480p video.
- Seedance 2.5: from $0.83 for a four-second 480p video.
- Pixverse V6: from $0.09 per second at 720p with audio off.
- Qwen 3.8 family: $0.00117 per second of model execution.

These are minimum configurations, not universal prices. Image cost can change with quality, resolution, and output count. Video cost can change with duration, resolution, mode, and audio settings. Language-model pricing can depend on execution time or the usage data returned for that model.

Requests reserve the required balance before execution, return unused amounts where applicable, and expose the final USD charge in the billing response. Always check the live pricing and model pages before calculating margins for a production feature.

## Production reliability features

A working demo and a reliable production integration are different things. The imageat API includes several controls intended to make retries, monitoring, and asynchronous jobs easier to manage.

### Idempotency

Send a unique `Idempotency-Key` with non-streaming image, video, chat, and Responses requests. Keys are scoped to the credential and endpoint, retained for 24 hours, and replay the original response without charging twice.

### Request tracing

Responses include an `x-request-id`. Applications can also supply `x-client-request-id` to correlate imageat requests with internal jobs, users, or support logs.

### Rate-limit handling

Rate-limit responses include `Retry-After` and rate-limit headers. Respect those values and use exponential backoff instead of retrying in a tight loop.

### Asynchronous cancellation

Unfinished video tasks can be cancelled with `POST /v1/videos/cancel` using the task and generation identifiers. Ownership is checked before the provider task is cancelled, and unused balance is refunded according to the run state.

### Structured errors

New lifecycle and reliability paths use an OpenAI-style error envelope with message, type, parameter, and code fields. Store these details so product errors can be separated from authentication, validation, rate-limit, and provider failures.

## Where the imageat API fits

The API is intended for products and teams that want generative capabilities without operating model infrastructure directly. Common use cases include:

- Adding image generation or editing to a design application.
- Creating product visuals and advertising variants in bulk.
- Turning customer images into short videos.
- Building social content pipelines that produce multiple aspect ratios.
- Generating creative briefs with an LLM before starting image or video production.
- Running reusable creative workflows from internal tools or automation systems.
- Connecting agent clients through OpenAI-compatible endpoints or MCP.

The main advantage is not simply access to multiple models. It is the ability to test them through one catalog, keep one authentication layer, and choose between direct model calls and reusable multi-step workflows.

## Frequently asked questions

### Do I need a separate API key for every model?

No. The same imageat API key can authenticate supported image, video, language, and workflow requests. Your application selects the model by sending the appropriate model ID.

### Where can I see every available model?

Use the live [imageat AI model catalog](https://imageat.com/models). It groups models by language, image, and video capabilities and links to model-specific pages and playgrounds.

### Is the language API compatible with OpenAI clients?

Yes. Supported language models are available through OpenAI-compatible Chat Completions and Responses API formats. Set the base URL to `https://api.imageat.com/v1`, provide an imageat key, and choose an ID returned by `GET /v1/models`.

### Are image and video requests synchronous?

Image generation returns output information directly. Video and workflow generation are asynchronous: create the task, preserve its identifiers, and then use polling, server-sent events, or webhooks as supported by that API.

### Can I switch models without rewriting the integration?

Within the same modality, the shared endpoints and response patterns reduce the amount of provider-specific code. However, model-specific controls still vary, so validate parameters against the current documentation before switching.

### How am I charged?

Active subscription credits are used first at the website's model rates. After they run out—or without a subscription—requests use the prepaid USD API balance. The final cost depends on the model and configuration.

### Are failed generations charged?

The documentation states that failed provider generations are handled by the platform's refund workflow. Your application should still log failed runs and inspect the final billing state before initiating an automatic retry.

### Can I use generated content commercially?

Commercial use depends on imageat's terms and the terms attached to the selected model, source material, and workflow. Review the applicable terms before deploying user-facing or client production features.

## Start with the live model catalog

The fastest way to plan an integration is to compare the models before writing code. Open the [imageat model catalog](https://imageat.com/models), select the modality and capability you need, test the model in its playground, and then copy the current model ID into your backend.

From one-off image calls to asynchronous video jobs, OpenAI-compatible language models, and multi-step creative workflows, the imageat API provides a single production layer for building generative features.

→ [Explore all available AI models and APIs on imageat](https://imageat.com/models)

---

Source: [Meet the imageat API: How It Works and What You Get](https://imageat.com/blog/imageat-api-models-pricing-developer-guide) on the imageat blog. More guides: https://imageat.com/blog · Full site index: https://imageat.com/llms-full.txt