Uncensored AI image generator API: price per image

Price per image with the safety checker off

Every row is a price tier of an uncensored image model on this key, read from the live catalog on 2026-10-27 and sorted by price per image. A tier is the settings the price applies to; the first tier that matches a request is the one charged. The 100-image column is that price times 100, nothing added.

11 image models, 18 base tiers, 7 of the 11 with enable_safety_checker defaulting to false. The same catalog feeds the image and video models page, each model’s own page and the console, so the number you see here is the number the request is charged.

Prices are per output image. A request with n: 4 on a model that takes n is charged four times the tier price. Resolution picks the tier on the models that have more than one; the aspect ratio never changes the price.

Which uncensored AI image generator to pick

Pick an edit model (Qwen Edit Uncensored, Seedream 5.0 Lite Edit Uncensored) when the job starts from an image you already have. Pick a text-to-image model when it starts from a prompt, and among those choose by the settings you need, since the price gap between the base tiers is $0.0136 to $0.20 per image.

Lustify SDXL Uncensored and Qwen Image 2.1 Uncensored and Vision Image Uncensored take image_urls as an option, so one model id covers both a fresh render and a variation of a reference. Anime Image Uncensored, CyberRealistic XL Uncensored, Qwen Image 2.1 Uncensored, Vision Pro Image Uncensored, WAI Illustrious SDXL Uncensored price 1K and 2K output differently, so the resolution you send is the cost lever on those models.

By job, then. Product variations and background swaps go to an edit model, because the source image is the brief. Anime and illustration go to the anime model, where the negative prompt and the seed keep a character consistent across a set. Images with text in them, or cut-outs on a transparent background, go to Qwen Image, which lists both settings. Fast drafts at volume go to the Vision model with one tier for any setting, and the final render of the same brief goes to Vision Pro or Chroma at 2K. Every one of these answers the same endpoint with the same key, so switching is a change of model id and nothing else.

Video is the same key and the same catalog. LTX-2.3 Image-to-Video Uncensored, Wan 3.0 Image-to-Video Uncensored, Wan 3.0 Video Uncensored is priced per second of output, by resolution. The per-second table is in the uncensored video generator API post and on the LTX-2.3 Image-to-Video Uncensored page.

Settings that change the price, and settings that do not

On the image endpoint, size is OpenAI’s WIDTHxHEIGHT string. The API reads the two numbers, picks the nearest aspect ratio the model lists, and on a model with a resolution setting picks the resolution from the longer side. The ratio never changes the price; the resolution can. A model whose size parameter accepts free pixel values is sent the size as written.

resolution is the setting that moves the price. Anime Image Uncensored, CyberRealistic XL Uncensored, Qwen Image 2.1 Uncensored, Vision Pro Image Uncensored, WAI Illustrious SDXL Uncensored have a 1K tier and a 2K tier. Chroma Uncensored, Lustify SDXL Uncensored, Qwen Edit Uncensored, Qwen Image 3 Uncensored, Seedream 5.0 Lite Edit Uncensored, Vision Image Uncensored have one tier for any setting, so the largest size costs what the smallest does. When the tier matters, set resolution yourself under input instead of inferring it from size. An explicit setting wins over the mapped one, and the charge follows the setting the model receives.

n multiplies. CyberRealistic XL Uncensored (up to 4) and Lustify SDXL Uncensored (up to 15) and Qwen Edit Uncensored (up to 4) and Qwen Image 3 Uncensored (up to 4) and Seedream 5.0 Lite Edit Uncensored (up to 15) and WAI Illustrious SDXL Uncensored (up to 4) make several images in one request and charge the tier price for each. A model without n answers a request for two images with a 400 that says to send two requests, and charges nothing. Sending four requests of one image and one request of four cost the same; the single request is one connection and one generation id.

Free settings, where a model lists them: output_format (png, jpeg or webp), seed for a repeatable result, negative_prompt for what to keep out of the frame, background: "transparent" for cut-outs, and prompt_extend, on by default where it exists, which lets the model rewrite a short prompt into a fuller one before rendering. Turn prompt_extend off when the prompt must be followed to the letter, for a product shot or a layout with text. None of these changes the tier.

enable_safety_checker is listed on 7 of the 11 image models with a default of false. Leaving it out of the request is the same as sending false, and the price is the same either way; there is no separate charge and no separate model id for the unfiltered path.

What a batch costs

The catalog prices are small enough that the batch size is what moves the bill, so here is the same arithmetic at 100 and 1,000 images, each model at its base tier. Balance is prepaid: the minimum top-up is $10, and bonus credit is added at +5% at $200, +10% at $500, +15% at $1,000, so a $200 top-up settles 5% more images than the table shows. The bonus tiers come from the same constants the console uses.

Two workloads, costed from the same rows. A storefront with 250 products and four variations of each is 1,000 edits, which is $80.00 on Qwen Edit Uncensored. A 24-page comic at six panels a page is 144 panels, which is $4.32 at 1K on Anime Image Uncensored and $6.48 at 2K. Neither needs a plan: the balance is debited per image as each generation is accepted, and a re-roll of one panel costs one panel.

Two rules keep the arithmetic honest. The price is quoted from the request before anything runs and charged when the model accepts the task, so a batch never costs more than the tier times the count. A generation that fails is refunded in full, automatically, so a failed run is not in the bill.

For a per-token comparison of the chat side of the same key, the pricing page lists every chat model’s input and output rate from the same live catalog.

Where other image APIs win, and where this one does

Venice sells its image, text, video and audio models behind one API dashboard with zero data retention, and its consumer app comes with the same account; that is one place to read everything. Its API and plan prices change and are not on record here, so read them on venice.ai/pricing rather than from a number in this post (description read from Google’s results page on 2026-10-19).

The first organic result for “uncensored ai image generator api” is a post that names the exact models behind its endpoint (Seedream 5.0 Lite and Seedream 4.5 builds, per its page title on 2026-10-19). Naming the model is the right way to sell an image API, and this post does the same.

Self-hosting wins on marginal cost and on control. The Reddit threads on this query and the local studios on GitHub run checkpoints on the user’s own GPU, where an image costs electricity and the checkpoint, the LoRA and the sampler are all yours to pick (results page read 2026-10-19). What it costs is the card, the setup and the hours a batch takes on one machine. An API with a per-image price wins when there is no GPU in the loop, when the batch has to run from a server, a phone or an agent, and when the number on the bill has to be known before the job starts.

The consumer tools on the same results page, Perchance and Mage among them, win for a person who wants a web page and no key at all. This post is for the other case: a script, an app or an agent that calls an endpoint and needs the price per call.

Where this key wins is the arithmetic above. The price per image is on the model page, in the catalog endpoint and in this table before the first call, and it is the same number in all three. The request is OpenAI’s image format, so the SDK you already use needs a base URL and a key, nothing else. The image models and the chat models share one prepaid balance and one key, there is no subscription, and a failed generation is refunded without a ticket. Each image model page, such as Anime Image Uncensored, carries its own tier table and a first request to copy.

The request: generate, edit, or submit and poll

One image, the OpenAI way. size is width by height in pixels; the API maps it onto the model’s own aspect ratio and resolution settings, and n maps onto the model’s image count where it has one.

The call waits for the image, up to about 100 seconds, and answers with a URL on this API. Generated files are kept for 30 days.

The same request through the OpenAI Python SDK. Anything a model takes beyond the OpenAI fields goes under input in extra_body; here the resolution is set outright and a negative prompt is added, both settings the anime model lists in the catalog.

An edit starts from an image you send. The edit models require image_urls; the text-to-image models that list it take it as an option.

For a batch that should not hold a connection open, submit to /v1/generations with the model’s own settings under input. The API answers 202 Accepted at once with the generation id and its price, and you fetch the result when it is done.

Ask for response_format: "b64_json" on the image endpoint to get the bytes inline instead of a URL, exactly as OpenAI’s image reference describes it. The base URL, key and model id are the three settings every client needs; the docs page shows them for the OpenAI SDK.

No safety checker runs on the prompt or the output of these builds; enable_safety_checker is a plain parameter that defaults to off. The one rule the API itself enforces on every uncensored model: no prompt may depict a minor, and such a request is refused with content_not_allowed before anything is charged.

The URL in the answer is on this API and stays valid for 30 days; copy the file to your own storage inside that window. Request bodies are not stored by default, so the prompt is not kept once the image is made, unless the key opts in to the 7-day replay in the console.

What each error costs

The image endpoint answers every failure in the same error shape, and the charge rule is short: nothing is charged before the model accepts the task, and a task the model fails is refunded. The codes, from the API reference:

• 400 invalid_request: a setting is out of range, the model makes video rather than images, or n went to a model that makes one image per request. Nothing charged.
• 401 invalid_api_key and 403 scope_denied: the key is wrong, or the key is scoped to other model ids. Nothing charged.
• 402 insufficient_balance, spend_cap_reached or monthly_limit_reached: the balance, or a limit you set on the key in the console, would not cover the quoted price. Nothing charged; top up or raise the limit and resend.
• 404 model_not_found: the id is not in GET /v1/catalog/media. Nothing charged.
• 413: the body is over 1 MB. Send image URLs rather than inline data.
• 429 rate_limited, or its busy-model variant: retry with backoff. Nothing charged.
• 502 generation_failed: the model could not complete the image. Nothing is charged, and a charge already taken comes back to the balance.
• 504 generation_pending: the image endpoint waited its full window and the model is still working. This one is charged, because the task continues; the generation id is in the response, and the file arrives at GET /v1/generations/{id}.

For a batch, the practical reading is that only two outcomes cost money: a finished image at its tier price, and a pending one that finishes later at the same price. Every other answer leaves the balance where it was.

How the per-image price is set

Each model carries a list of tiers in GET /v1/catalog/media. A tier has a when object naming the settings it covers, a price_usd per unit to four decimals, and list_usd, the developer’s own price when the developer publishes one. The tiers are checked in order and the first match is charged, so a model with one tier and an empty when costs the same at every size.

• Resolution is the only setting that changes the price on the models with more than one tier; the aspect ratio, the output format and the seed do not.
• n multiplies the tier price by the image count. A model without an n parameter makes one image per request, and the API says so instead of charging twice.
• An add-on tier, when a model has one, is added to the base tier for the settings it names; the table above lists add-ons separately.
• A failed generation is refunded in full. A generation still running after the image endpoint’s wait is charged and continues; its id is in the 504 answer and the file arrives at the generations endpoint.

A script can read the tiers the same way this page does, without a key, and decide the resolution per job from the live number:

The answer is the list of tiers for that id, each with its when and price_usd. Cache it for a few minutes; the catalog changes when a model is added or re-priced, and the page you are reading is rebuilt from it on the same schedule.

The console shows the same tiers next to a panel that runs the model with one of your keys, so a price can be checked against a real charge before a batch is scripted. The media page is the list; this post is the per-image arithmetic on top of it, refreshed from the catalog each time it is rendered.

Questions