Topaz sells upscaling by the credit, but one credit buys 24 megapixels on one model family and only 2 on another. This breakdown prices the Topaz API plans, image megapixels and video seconds, then runs real budgets for catalogs, archives and weekly video.
Topaz sells upscaling through an API, and the bill hinges on a detail most people skip: credits are not equal. One credit can pay for 24 megapixels of output on one model family and only 2 megapixels on another. That is a twelve times gap hiding behind a single price per credit. This article turns the published numbers into real dollar amounts for photos and for video, so you can budget before you write a line of integration code.
Every figure below comes from Topaz's public pricing pages or from the listings of resellers that run the same models. Prices move, so treat the numbers as a snapshot from October 2026 and check the live pages before you commit money.
💡 Quick answer: a Topaz credit costs $0.12 on the pay as you go Starter plan, $0.10 on Developer and $0.08 on Scale. Images are billed by output megapixels. Video is billed by clip length, resolution and model family.
Topaz bills in credits, and credits are the only currency you ever deal with. You buy them at a plan rate, then every request burns some of them. The cost of a request depends on the model family you call and on the size of the file that comes out, never on the size that goes in.
Topaz lists four tiers on its API page. The first three have public numbers:
| Plan | Monthly fee | Included credits | Price per credit |
|---|---|---|---|
| Starter | $0 | None, pay as you go | $0.12 |
| Developer | $50 | 500 per month | $0.10 |
| Scale | $240 | 3,000 per month | $0.08 |
| Enterprise | Custom | Custom | Volume pricing |
Enterprise adds on premise deployment and dedicated engineering support, so it only matters if procurement is already involved. Everyone else picks from the first three rows.
The arithmetic is short. Developer gives you 500 credits for $50. The same 500 credits on Starter would cost $60, so you save $10 a month. Starter at $0.12 per credit costs $50 for about 417 credits, which makes 417 the break even point for Developer.
Scale is a bigger jump. 3,000 credits on Starter would cost $360, against $240 on Scale, a saving of $120 or one third. The break even against Starter sits at 2,000 credits a month. Below that, Scale wastes money. Above it, Scale is the cheapest way to buy.
💡 Check the expiry terms. Topaz's model pricing page describes credits as pay as you go with no minimums, while the plans page lists carry over for Developer. Confirm how unused credits behave before you buy a large block.
Image models are billed per output megapixel. Topaz states that one credit processes up to 24 megapixels of output on its precision models, and its own example puts a 32 megapixel result at 2 credits. Partial credits therefore appear to round up to the next whole one.
Scale factors grow faster than people expect, because they apply to width and height. A 2x upscale quadruples the pixel count. A 4x upscale multiplies it by 16. A 6x upscale multiplies it by 36. Since the price follows output pixels, a 6x job costs nine times what a 2x job costs on any per megapixel model.
Topaz splits its image models into families, and the families price very differently:
| Family | Style of result | Megapixels per credit | Starter | Developer | Scale |
|---|---|---|---|---|---|
| Gigapixel | Precision upscale | 24 | $0.0050 | $0.0042 | $0.0033 |
| Wonder | Generative upscale | 4 | $0.0300 | $0.0250 | $0.0200 |
| Bloom | Creative upscale | 2 | $0.0600 | $0.0500 | $0.0400 |
The prices in the last three columns are dollars per output megapixel. Denoise, removal and cleanup, and color and lighting tools also run at 24 megapixels per credit, and the sharpen family runs at 24 or 20 depending on the variant. The expensive tier is the generative one, where the model invents plausible detail instead of sharpening what exists.
Take a 4000 by 3000 pixel photo, which is 12 megapixels. Upscale it 2x and you get 8000 by 6000, which is 48 megapixels. That is roughly a 26 by 20 inch print at 300 dpi.
| Family | Credits for 48 MP | Starter | Developer | Scale |
|---|---|---|---|---|
| Gigapixel | 2 | $0.24 | $0.20 | $0.16 |
| Wonder | 12 | $1.44 | $1.20 | $0.96 |
| Bloom | 24 | $2.88 | $2.40 | $1.92 |
The same photo costs between 16 cents and $2.88 depending on two choices: the family and the plan. Neither choice is about image quality alone, which is why picking the family on purpose matters more than shopping for the cheapest plan.
Video pricing is harder to eyeball. Topaz publishes estimates based on a 10 second clip at 1080p and 30 fps, and tells you to use its credit calculator for anything else. Here is what those estimates cost in dollars:
| Model family | Credits per 10 s | Starter | Developer | Scale |
|---|---|---|---|---|
| Proteus (precision) | 4 | $0.48 | $0.40 | $0.32 |
| Starlight Fast (generative) | 6 | $0.72 | $0.60 | $0.48 |
| Starlight Quality (generative) | 12 | $1.44 | $1.20 | $0.96 |
| Astra (creative) | 40 | $4.80 | $4.00 | $3.20 |
Support tools are far cheaper. Video denoise costs 2 credits on the fast setting and 4 on quality. Frame interpolation costs 1 credit fast and 2 credits on quality. General video utilities cost 2.
Astra is ten times the price of Proteus for the same ten seconds. It is built for AI generated footage that needs a creative rebuild, and it makes little sense for a clean phone clip that only needs sharpening.
If duration scales in a straight line, as it does on per second providers, a 60 second clip at 1080p with Proteus lands near 24 credits, or about $2.40 at the Developer rate. The same minute on Starlight Quality is roughly 72 credits, and on Astra roughly 240 credits, which is $24 at the Developer rate.
Treat those as planning numbers, not quotes. Resolution and frame rate both push the total up, and 4K output is where resellers charge the most, as the next section shows.
Topaz models also show up on third party platforms, usually priced per second or per run instead of per credit. These listings were visible at the time of writing:
| Provider | Listed price | What it applies to |
|---|---|---|
| fal | $0.10, $0.20 or $0.60 per 10 s | Video, 720p, 1080p or 4K at 30 fps |
| Apiframe | $0.02 per second | Video, 1080p at 30 fps |
| Unifically | $0.06 per output second | Video, up to 4K |
| Segmind | $0.375 per generation | Image upscale |
Two things stand out. First, the fal and Apiframe listings for 1080p both work out to $0.02 per second. Topaz's own Proteus estimate at the Developer rate is $0.04 per second, so a reseller can be cheaper, although it may not run identical settings. Second, a flat $0.375 per image is about three times the $0.12 that a 12 megapixel Gigapixel job costs on Starter. Flat fees are simple, but they punish small outputs.
Numbers differ because platforms pick different default models, assume different frame rates, and absorb or add margin in different places. Compare like for like: same model family, same output resolution, same frame rate.
Plan tables only help once they meet a real workload. Three jobs follow, each priced on the three plans.
Say you hold 1,000 product photos at 1 megapixel each, and you want a 4x upscale for a zoomable store page. Each output is 4000 by 4000, so 16 megapixels.
Most catalog work is clean studio photography, where the precision family is enough. The generative family earns its price when the source is truly broken.
A box of 300 scanned prints at 2 megapixels each, upscaled 4x, produces 32 megapixel files. That matches Topaz's own 2 credit example, so the precision run needs 600 credits: $72 at Starter, $60 at $0.10 and $48 at $0.08.
Faded prints often need invented detail, though. On the generative family each file costs 8 credits, so the archive needs 2,400 credits, or $288 at the Starter rate. That is the real decision with old photos: do you want faithful sharpening or plausible reconstruction, and are you willing to pay four times more for it?
Imagine 12 minutes of footage a month, which is 72 blocks of ten seconds, at 1080p and 30 fps. Assuming straight line scaling:
Volume is what makes Scale work. A creator who only runs a few hundred credits a month never gets there, while a studio pushing heavy creative passes crosses the line quickly.
Not everyone wants to build an integration, hold a credit balance and calculate megapixels. Picasso IA runs the Topaz models in the browser: Topaz Image Upscale for stills and Topaz Video Upscale for clips. You upload a file, pick settings and download the result.
Open Topaz Image Upscale and work through the settings in this order:
Most example runs on the model page finished in roughly 13 seconds for a 4x job, with one slower 2x run taking close to 95 seconds.
💡 Tip: match the model to the source. Low Resolution V2 on a tiny thumbnail beats Standard V2 every time, and Text Refine is the only sensible choice for a scanned page.
Topaz Video Upscale has just three inputs: the video file, a target resolution of 720p, 1080p or 4K (the default is 4K), and a target frame rate from 15 to 120 fps (the default is 30).
Choose 1080p when the clip ends up on social media, because most viewers watch on phones. Pick 4K only when you know it will play on a large screen. Leave the frame rate at the source value unless the footage looks choppy, since interpolation changes how motion feels.
Topaz is not the only route. These models on the platform handle different jobs:
Reading price tables only gets you so far. The fastest way to know what an upscale is worth to you is to run one. Take a photo that is too small for print, or a clip that looks soft on a big screen, and put it through Topaz Image Upscale or Topaz Video Upscale on Picasso IA.
Try the same source at 2x and 4x, switch between Standard V2 and High Fidelity V2, and compare the files side by side. Once you know which setting you actually need, the credit math in this article tells you what that choice costs at API scale. Open Picasso IA, upload your first file and see what a sharper version of your own work looks like.
