APIMODELS review: price, reliability data and 30-day storage

This review is built from four kinds of evidence: APIMODELS' production records for the 30 UTC days from September 22 to October 21, 2026, read from its database on October 22; its own site, docs, terms and public model list, checked on October 21 and 22; the makers' price pages; and the other relay reviews in this series. APIMODELS is our own product: it is made by the team behind GenGrades, and GenGrades' own content backend is served from hub.apimodels.app. That is the only reason its production numbers can appear here, so each one says exactly how it was counted. No third-party benchmark or review of APIMODELS has been published; every reliability figure below is APIMODELS' own.

The short answer

APIMODELS is an AI API relay built around a trade-off: it does not try to be the cheapest seller of every model, and it spends part of its margin on keeping requests alive. It sells about 150 chat, image, video, audio and embedding models through one API key and one prepaid US-dollar balance, at its own prices. On most models compared here those prices sit 10% to about 90% below the makers' list prices; on a few, another relay is cheaper, and on a few, the maker is.

What the margin buys is redundancy. Popular models run on more than one upstream channel. A request that hits an error, a rate limit or a stalled job moves to the next channel without your code doing anything, and a request that fails on every channel costs nothing. Over the 30 days to October 21, 98.62% of 802,328 requests succeeded once requests blocked by content moderation are left out. Language models ran at 99.63% and embeddings at 99.97%. Video is the weak spot at 90.93%, and on one bad day, October 4, the whole platform fell to 85.90%.

The second thing small teams get is storage. Every generated image, video and audio file, and every file you upload, is served from APIMODELS' own storage for 30 days. That is long enough to hand a result link to your app, your client or a social-media scheduler without running a bucket of your own.

Choose APIMODELS if you want one bill for many models, payment by card, PayPal, Alipay or USDT, and an integration that keeps working when one upstream has a bad hour. Skip it if you need a contracting company with an address and governing law, zero data retention, batch pricing or a public status page.

What APIMODELS is, in one request

APIMODELS sits between your code and the companies that run the models. You hold one API key and one balance; APIMODELS holds the upstream accounts and decides which channel serves each request. Everything lives under one base URL, https://api.apimodels.app/v1:

Every request follows the same path. APIMODELS checks that the balance covers the price and sets that amount aside. It sends the request to the first upstream channel registered for the model. If that channel answers with an error, a rate limit or nothing at all within its time limit, the request goes to the next channel. When a result arrives, the amount set aside is charged; if every channel fails, the hold is released and nothing is charged. Media results are copied to APIMODELS' storage, so the link you get keeps working after the upstream's own link expires.

The model name you send decides the model you get. A handful of models also come as separately named lower-cost lines, marked Lite, budget or Dreamina, and each of those pages says how it differs from the standard version: resolution, speed, moderation or, in one case, a watermark that APIMODELS removes.

Price and stability: where APIMODELS sits

APIMODELS prices for the middle. Its homepage headline says prices are up to 95% below official pricing; the comparison table on the same page shows savings of 10% to 63%, and across the models compared in this review the deepest cut is about 90%. Prices below are in US dollars, from its pricing page and model pages, Anthropic, OpenAI, Google (updated October 19, 2026), DeepSeek, and the OpenRouter and Kie.ai reviews:

Three things follow from that table. First, the savings are real but uneven: 10% on DeepSeek V4.1 Flash, 40% on Claude Opus 5.5, about 50% on Nano Banana Pro, 69% to 90% on Veo. Second, APIMODELS is not the floor. Kie.ai lists Claude Opus 5.5 and 4K Nano Banana Pro for less, and Replicate charges $0.18 a second for Seedance 2.0 at 720p against APIMODELS' $0.197 (its Seedance page). Third, a few rates are above the maker: its standard Seedance 2.0 Mini costs $0.044 and $0.095 a second at 480p and 720p against the BytePlus prices of $0.040 and $0.080 its own Seedance page quotes, and Claude Sonnet 5.5 cache reads cost $0.12 per million against Anthropic's $0.10, a rate its Claude pricing page still gives as $0.20.

The makers' own Batch tiers also match or beat it for work that can wait: $2 / $10 for Opus 5.5 at Anthropic and $1 / $5 for GPT-6.1 Sol at OpenAI. APIMODELS has no batch API.

What does the middle price buy? For most buyers the answer is the next section: backup channels and the engineering around them. A reseller that runs one channel per model can undercut it on that model; when that one channel is overloaded, its customers wait or fail.

What a month costs. Three workloads at the prices above, against the maker's list price:

The arithmetic ignores prompt caching, which lowers both sides, and the 2% to 5% credit bonus on larger top-ups, which lowers APIMODELS' side.

How stable it is: 30 days of production records

How these numbers were counted. Every API call APIMODELS handles leaves a record with its model, its final state and, if it failed, a failure code. The figures here count every request that reached a final state, successful or failed, between September 22 and October 21, 2026, by UTC day. Requests that an upstream's content-safety system refused are left out, because they fail by design and would fail at the maker too; there were 20,723 of them. Everything else counts as a failure, including requests with invalid input, so the rate understates what a well-formed request sees.

The headline. 802,328 requests, 791,269 succeeded: 98.62%. The median day ran at 98.83%. 23 of the 30 days were at 98% or better and 12 at 99% or better. The last seven days ran at 99.48% and the last 14 at 99.36%. Daily volume ranged from 9,132 to 105,015 requests, 27,435 on an average day.

The bad days, and what caused them. Each dip traces back mainly to one model's upstream:

• October 4, 85.90%. GPT Image 2.5 Flare, one of the most-used image models, answered "busy" 1,567 times and GPT Image 2.5 Sunburst 230 times; another 495 Flare requests failed on invalid input.
• October 1, 93.39%. The Gemini 3.1 Flash Image preview upstream failed 913 requests.
• September 25, 95.47%. Veo 3.1 Fast at 1080p answered "busy" 312 times.
• October 15, 97.82%. Qwen3.8 Flash hit upstream rate limits 459 times.

The lesson for buyers is the same one the totals teach: language models and embeddings barely move, and the risk sits with new or popular media models whose upstream capacity runs out.

By kind of model. Same 30 days, with moderation rejections left out of both columns; time to a result is for successful requests in the seven days to October 22:

Image generation shows the largest number of moderation rejections, 19,161 in 30 days, so on image models the raw rate a user sees depends heavily on the prompts.

By model. The most-used models, with the same counting (moderation rejections left out):

Video and speech models run in far smaller numbers, so their rates move more from week to week:

Read the per-model table as a guide to which model to put in production. GPT Image 2, Nano Banana 2.1 and GPT Image 2 All held above 99%; GPT Image 2.5 Flare carried the October 4 overload. On video, MiniMax H3 Lite and Seedance 2.5 held near 97%, while Veo 3.1 Fast at 1080p succeeded only 83% of the time and is the model to wrap with a fallback in your own code.

What failover does in practice. Each failed leg is recorded with the error that ended it and the channel that took over. In the 48 hours to the morning of October 22 (UTC), 2,770 of 18,736 successful image generations, 90 of 2,473 successful speech requests and 13 of 1,262 successful videos were finished by a backup channel after the first one failed. The errors that most often triggered a switch were, in order, upstream 503 errors, "busy" responses, 429 rate limits and jobs that stalled past the serving channel's time limit. Without failover, each of those requests would have returned an error to the caller on the first try.

What a failed request costs. Nothing. The price is set aside when a request starts and charged only on success. In a random sample of APIMODELS' ledger, all 60 successful requests had a matching charge and none of 120 failed requests had one, including requests refused by moderation. A failed record keeps the price it would have cost in its own fields, but no charge is made against the balance.

What these numbers do not show. They are APIMODELS' own records, read by the team that runs it. There is no public status page, no third party checks them, and no other relay in this series publishes daily figures in the same form, so they cannot be ranked against OpenRouter's or Kie.ai's. They also leave out moderation rejections by design. The homepage's "98.9% Uptime" is a success rate, not an uptime measure, and over these 30 days the platform as a whole ran slightly below it.

Planning around latency

The time table above is what to design for:

• Chat. Half of all language-model requests finished within 1.2 seconds and nine in ten within 24 seconds. Stream long answers; reasoning models such as GPT-6 Sol can run past two minutes on large prompts.
• Images. Half finished within 53 seconds and nine in ten within about two and a half minutes. Its GPT Image 2 FAQ suggests a client timeout of at least 180 seconds for blocking image calls. For anything user-facing, create a task, return to the user, and collect the image by callback.
• Video. Half finished within three minutes and nine in ten within six; on Wan 3.0 the slowest tenth took longer than 16 minutes. Never hold an HTTP request open for a video. Poll every 5 to 10 seconds or, better, pass a callback_url.
• Callbacks. When a task finishes, APIMODELS posts the result to your callback_url, up to three attempts in a round with a 10-second timeout each, and keeps retrying unsent callbacks with backoff for 30 minutes after completion. If your endpoint is down longer, the task can still be fetched by ID.
• Coding agents. The MCP server waits at most 50 seconds per call and then hands back a task ID, which keeps tools with a 60-second limit, such as Codex, from losing long renders.

Storage: 30 days of hosting included

APIMODELS stores what it generates and what you upload on Cloudflare R2 under r2.apimodels.app, and its privacy policy and docs say these files are deleted after 30 days. Media it fetches from a link you supply, only to pass it to a model, is deleted after three days. Result links sampled from its records on October 22, 2026 bear that out: files created 3, 8, 12, 20, 26 and 29 days earlier all loaded, and files created 32 and 40 days earlier returned 404.

For a small team that removes one piece of infrastructure. The usual pattern of generating a file, copying it to your own bucket, setting up a CDN and managing deletion is unnecessary for most short-lived work:

• Deliver straight to users. A web app can show the result link as is; it is served by Cloudflare.
• Hand results to other services. A social scheduler, a CMS, an n8n workflow or a messaging bot can fetch the link within the 30 days.
• Send drafts to clients. An agency can send links for review and keep only the approved files.
• Feed one model with another's output. A generated image can go straight into a video model as its first frame, since APIMODELS reads its own links.
• Upload inputs once. POST /v1/files returns an upload URL valid for 10 minutes and a public URL that stays for 30 days, so a reference image can be reused across many generations.

Two cautions. Anything that must outlive 30 days, such as a product catalogue, a published video or a compliance archive, should be copied to storage you control within the window. And the links are not access-controlled: they use long random IDs, but anyone who has a link can open the file, so do not rely on them for private material. Voices you clone and Seedance characters you save are separate: they stay with your account.

Storage is not billed separately; you pay only for the generation.

Billing in practice

APIMODELS is prepaid. You add US dollars to one balance and every model draws from it:

• Top-ups start at $10. The $50, $100, $500 and $1,000 packages add 2%, 3%, 4% and 5% in bonus credit (its fal comparison), and any whole-dollar amount between $10 and $1,000 is accepted at the bonus rate of the package below it.
• Payment by card through Stripe, PayPal, Alipay (charged in CNY at the day's rate) or USDT. Card payments are invoiced automatically.
• Auto top-up can recharge a saved card when the balance runs low.
• No subscriptions and no monthly minimum.
• Trial credit. New accounts get $0.10 once, if they sign up with Google using a personal mailbox such as Gmail or Outlook, or with Alipay, and only one new account per IP address in 48 hours receives it. That is enough for a few images or a short chat to check an integration, not for evaluation at scale.
• Per-call cost. Language-model responses carry x-apimodels-request-id and, when not streamed, x-apimodels-cost. Any request ID or task ID can be looked up with GET /v1/records/{id}, free (billing docs).
• Refunds. Its terms say consumed credits are non-refundable and purchased credits "generally non-refundable", with duplicate charges and billing errors reviewed by email at support@apimodels.app. The terms do not say whether credits expire.

Prompt caching: where savings compound

Coding agents and chat products resend the same long prefix on every turn: a system prompt, a codebase, a document. Prompt caching bills that repeated prefix at a fraction of the input price, and APIMODELS passes it through: Anthropic-format requests take cache_control blocks, OpenAI and Gemini models cache automatically upstream, and the cached share of every call shows up in its usage and in GET /v1/records/{id}. Cached-input prices per million tokens, from its llms.txt and the makers' pages, checked on October 22:

Two details matter more than the table. Anthropic charges more to write a cache that lasts an hour than one that lasts five minutes; APIMODELS bills both at the same cache-write rate, so asking for the one-hour cache costs nothing extra (its LLM docs). And the cached prefix must be byte-identical between calls: a timestamp or a reordered tool list at the top of a prompt misses the cache, so put whatever changes at the end.

A typical Claude Code turn shows the effect. With 50,000 input tokens, 40,000 of them cached, and 3,000 output tokens, Claude Opus 5.5 costs about $0.108 a turn at Anthropic's list prices and about $0.065 on APIMODELS. Over a working day of a few hundred turns, that difference is what pays for the backup channels.

Choosing models on APIMODELS

Its catalogue held 151 models on October 22, 2026: 50 language, 43 video, 33 image, 23 audio and 2 embedding. Its public model list returned 158 IDs on October 21 because it also counts aliases and channel variants. A few habits make the catalogue easier to use:

• Use the standard ID unless the line's page says otherwise. Lite, budget and Dreamina lines are cheaper because they run on different channels; read the differences before switching.
• Pick by the reliability table, not only by price. For production images, GPT Image 2 and Nano Banana 2.1 ran above 99.5%. For video, MiniMax H3 Lite and Seedance 2.5 ran near 97%.
• Keep a second model in your code for video. Failover inside APIMODELS covers channels of the same model; it does not switch your request to a different model.
• Check prices on the model page before scaling. Media prices depend on resolution, length and quality, and a few lines cost more than the maker.

Integrating it

Any OpenAI SDK works by changing the base URL:

from openai import OpenAI

client = OpenAI(base_url="https://api.apimodels.app/v1", api_key="YOUR_APIMODELS_KEY")
reply = client.chat.completions.create(
    model="claude-haiku-5-5",
    messages=[{"role": "user", "content": "Summarise this changelog in three bullets: ..."}],
)
print(reply.choices[0].message.content)

An image task with a callback:

curl -X POST https://api.apimodels.app/v1/images/generations \
  -H "Authorization: Bearer $APIMODELS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "gpt-image-2", "prompt": "Studio photo of a ceramic mug on oak", "aspect_ratio": "1:1",
       "callback_url": "https://your-app.example.com/hooks/apimodels"}'

The response carries {"code": 200, "msg": "success", "data": {"taskId": "...", "state": "pending"}}; the callback later posts the same task with state, credits and resultUrls.

Without a callback, poll the same endpoint with the task ID until state is completed, then read resultUrls:

curl "https://api.apimodels.app/v1/images/generations?task_id=TASK_ID" \
  -H "Authorization: Bearer $APIMODELS_API_KEY"

Video works the same way on /v1/video/generations; the Veo docs show a first frame passed as images. Errors follow plain HTTP codes: 401 for a bad key, 402 when the balance is too low, 400 for invalid parameters. A request refused by an upstream's content-safety system fails with a message saying so and is not charged.

When a request fails: codes and what to do

A failed request returns one of a small set of codes in its failCode, and its API docs say which ones are worth retrying:

Rate limits come from the upstream providers; APIMODELS publishes no per-key limit of its own. A 429 from one channel is handled like any other channel error: the request moves to the next channel before it ever reaches you.

Content moderation deserves its own note because it is the most common failure on image and video models. In the 30 days to October 21, upstream safety systems refused 19,161 image requests, 7.2% of all image requests, and 1,502 video requests, 8.5% of all video requests. None of those were charged. Product shots, landscapes and illustrations rarely trip them; real people, minors, brands and anything suggestive often do, and the rules differ from one model maker to the next.

Moving over from OpenRouter or a maker's API

• From any OpenAI SDK. Change the base URL to https://api.apimodels.app/v1 and the key. Model IDs are APIMODELS' own, such as gpt-6.1-sol, claude-opus-5-5 or gemini-3-flash-preview; the full list is at GET /v1/models.
• From the Anthropic SDK or Claude Code. Point the base URL at https://api.apimodels.app with no path, because the client appends /v1/messages itself (its clients guide), and use a claude- model ID.
• From OpenRouter. Base URL and key change as above, and model names lose their vendor prefix. OpenRouter's provider-routing preferences, zero-data-retention flag and bring-your-own-key have no equivalent; APIMODELS chooses the channel itself.
• From a media host such as fal, Replicate or Kie.ai. Image, video and audio models use one task pattern: create with POST, then poll with task_id or receive a callback. Parameter names follow each model's page, so port one model at a time.
• Balance. Credits do not move between services, so start with a small top-up and run your own traffic for a few days before moving everything.

A production checklist

1. Store the request ID or task ID of every call, and reconcile your own usage against GET /v1/records/{id}.
2. Use callbacks for media. Put a secret token in the callback URL, and confirm a task by fetching it with your key before acting on the callback.
3. Set client timeouts from the latency table: seconds for chat, minutes for images, up to ten minutes for video.
4. Retry only the codes marked retryable, with backoff; the channel-level retries have already happened.
5. Give every video feature a second model, and every critical image feature a second image model.
6. Copy any file you need beyond 30 days, and anything private, to storage you control.
7. Watch the balance: turn on auto top-up for unattended work, and treat a 402 as an alert, not a crash.
8. Use separate API keys per app or environment, so one leaked key can be revoked without stopping the rest.
9. Check cache hits in the usage of long-prompt workloads; a sudden drop in cached tokens usually means a changed prefix, not a price change.

MCP, Agent Skills and coding agents

• MCP server. apimodels-mcp (MIT) runs locally with npx or hosted at https://api.apimodels.app/mcp, where an OAuth sign-in creates a dedicated key. Nine tools cover balance, models, chat, image generation and review, video, speech, uploads and tasks. It is in the official MCP Registry at version 0.7.0, and npm counted 1,919 downloads in the 30 days to October 18, 2026. The API docs do not mention passing MCP servers through to models.
• Agent Skills. The apimodels-image skill installs with npx skills add stimQQ/apimodels-skill@apimodels-image; its catalogue and docs list 33 image models, and video and audio skills are planned. The apimodels plugin for Claude Code and Codex bundles the MCP server with a generation skill.
• Coding agents. Guides for Claude Code (defaulting to Opus 5.5), Codex, Gemini CLI, Cursor, OpenClaw, n8n and Cherry Studio. Claude Code needs only three environment variables: the base URL, the key and the model.
• API formats. Chat Completions, Responses, Anthropic Messages with prompt caching, Gemini generateContent, embeddings and async media tasks. Structured outputs on Claude return a 400, there is no batch API and no SDK of its own, only examples and an llms.txt.

What to watch out for

• The 95% headline. The comparison table on its own homepage tops out at 63%; across the models in this review, the deepest cut is about 90%, on Veo 3.1 Fast.
• Video reliability. 90.93% over 30 days, and 83% on Veo 3.1 Fast at 1080p. Build retries and a second model into video features.
• Channels that change the output. Its Omni Flash (Lite) page says that channel stamps a watermark on every clip, which APIMODELS strips, leaving a faint patch. Nano Banana Pro is also sold on a "budget channel". An August 29, 2026 blog post by the person who runs APIMODELS describes an early upstream that returned lower-quality video while reporting success, and says every channel is now checked against the official output.
• Safety rules against the catalogue. Its terms say the service follows the upstream providers' rules and "does not bypass their safety restrictions", yet it sells "Spicy" variants labelled "Relaxed Moderation", and its Seedance page says a real-person photo the upstream rejects "is registered and retried automatically".
• Regions. It says its API is reachable from mainland China without a proxy. Mainland China is on neither Anthropic's supported regions nor OpenAI's supported countries, and OpenAI warns that offering access outside its list may get accounts blocked.
• Unexplained prices. Its Veo 3.1 Fast HD page calls the result "720p VEO-style 8s output" and does not explain a price 90% below Google's.

Privacy, terms and who runs it

Its terms and privacy policy, effective October 22, 2026, name PIXLUME LLC, a US company, as the operator, but give no address or governing law. The homepage's business contact is a personal Gmail address; the Contact page lists support@ and business@apimodels.app. Its MCP and skill code sits on a personal GitHub account. The August post says the person who runs it cannot code and has an AI coding agent write all of it.

The privacy policy lists what it keeps: sign-in details from Google or Alipay, the IP addresses used to register and sign in, where a visitor first arrived from, and a record of every call, including prompts. Results and uploads are deleted after 30 days; call records are kept with the account with no automatic deletion, and records older than 30 days are also archived for a year. There is no zero-data-retention option and no choice of upstream host. Purchased credits are "generally non-refundable", and there is no status page.

What users report

No user discussion of APIMODELS was found: Hacker News has no submission of apimodels.app, and its Product Hunt listing has no reviews, one upvote and three model counts (200+, 110+ and 60+). One open-source project, infOS, has added APIMODELS as an image and video provider; its notes say no real API calls had been run yet. Its own records show 97% of calls arriving through API keys rather than the website's playground, so the figures on this page describe API use, not casual tries on the site.

How it compares with OpenRouter, Kie.ai and the media hosts

• OpenRouter charges list price plus 5.5% on top-ups but names its company, lets you choose hosts, offers zero data retention and publishes a status page. Pick it for language models when governance matters more than price.
• Kie.ai is cheaper on Claude Opus 5.5, dearer on Veo, and names two Denver LLCs as operators. Pick it when the lowest media price is the only goal.
• fal, Replicate and WaveSpeedAI charge Google's price or more for Veo and Nano Banana Pro but publish status pages. Pick them for media when a named host and published uptime matter.
• APIMODELS sits between: below the makers on most models, not the lowest on every one, with failover, per-call costs and 30-day file hosting built in.

Getting started in ten minutes

1. Sign in at apimodels.app with Google or Alipay; personal Google accounts and Alipay sign-ups get $0.10 to try.
2. Create an API key in the console.
3. Make one chat call with any OpenAI SDK pointed at https://api.apimodels.app/v1, and look the request up with GET /v1/records/{id} to see what it cost.
4. Create one image task with a callback_url, or poll it, and open the result link.
5. Top up $10 or more, and set an auto top-up if the integration runs unattended.
6. For production, pick models from the reliability table, add your own retry and second model for video, and copy any file you need beyond 30 days.

Who should skip it

Skip APIMODELS if you need a contracting company with an address and governing law, a DPA, zero data retention or a status page; if you send confidential data; if you need batch pricing or structured outputs on Claude; or if your use would fall outside the makers' supported regions. For product teams that want many models on one balance, accept a middle price for backup channels, and can live with 30-day file links, it is built for exactly that.