Compare Image Model Costs

Send prompts to five image models and rank their cost, speed, and text quality.

Introduction

30 Second Summary

A low price on a model page does not always mean a cheap finished picture. Different pricing units make the real cost hard to judge before you generate anything.

In this project, you will send the same prompt to five image models through the OpenRouter Image API. The finished comparison ranks cost, speed, and text legibility.

What You'll Build

You'll run your benchmark and see five saved images beside a ranked table that makes the best model for your next picture easier to choose.

By the end of this project, you'll have:

  • A repeatable five-model benchmark that sends one prompt to five models and saves every image for side-by-side viewing.
  • A measured cost and latency record that shows what each picture charged you and how long it took.
  • A text legibility test that reveals which models can place readable lettering inside an image.
  • Secret Mission: Extend the benchmark with one more image model and add its results to your rankings.

Do I need any experience before starting?

You'll need a terminal with curl available. The models run through a credited OpenRouter account, so your computer does not need a GPU.

Before We Start

Every comparison in this project starts with an API request to OpenRouter. Each response needs a predictable place to land.

Your terminal needs curl to send requests. It needs jq to read fields from each JSON response.

In this step, get ready to:
  • Confirm curl can send requests from your terminal.
  • Install jq for reading response data.
  • Create the local image-model-costs workspace.
Check curl

The curl command sends requests from your terminal. You will use it to make the first image request in the next step.

  • Press Cmd+Space on macOS or the Windows key on Windows to open system search.
  • Type Terminal on macOS or PowerShell on Windows.
  • Press Enter to open the terminal.
  • Check whether curl is available by running this command:
curl --version

What does this command do?

The --version option asks curl to print its installed version. It also lists the network features available in that build.

✔️ I see curl version details

Curl is ready. The first line starts with its name followed by a version number.

That confirms your terminal can run the request tool used throughout this project.

ⓧ Command not found

Curl needs to be installed before your terminal can send the project requests.

macOS

  • Install curl through Homebrew by running this command:
brew install curl
What does this command do?

Homebrew downloads curl and installs it as a terminal command. Its output shows the package location when installation finishes.

  • Close the current terminal window.
  • Open a new terminal window through system search.
  • Confirm curl is available by running this command:
curl --version
What should I see?

You should see curl version details. This confirms the new terminal can find the installed command.

Homebrew command unavailable?

Use the official curl download page to choose a macOS package for your computer. Follow the package instructions to make curl available in Terminal.

Help me install curl on macOS.

Windows

  • Visit the official curl for Windows page.
  • Choose the package that matches your Windows architecture.
  • Follow the package instructions to make curl available in PowerShell.
  • Close the current PowerShell window.
  • Open a new PowerShell window through system search.
  • Confirm curl is available by running this command:
curl --version
What should I see?

You should see curl version details. This confirms PowerShell can find the installed command.

Curl still unavailable?

Check that you downloaded the build for your processor architecture. Reopen PowerShell after completing the package instructions.

Help me install curl on Windows.

Check jq

OpenRouter responses contain nested data. The jq command lets you pull out fields such as cost without reading the entire response by hand.

  • Check whether jq is available by running this command:
jq --version

What does this command do?

The --version option prints the installed jq version. A version line confirms the command is available.

✔️ I see a jq version

Jq is ready to read the response files you create later. That removes the manual work from finding each cost field.

ⓧ Command not found

Jq needs to be installed before you can extract values from the saved responses.

macOS

  • Install jq through Homebrew by running this command:
brew install jq
What does this command do?

Homebrew downloads jq and adds the command to your terminal environment. The installation output ends after the package is linked.

  • Close the current terminal window.
  • Open a new terminal window through system search.
  • Confirm jq is available by running this command:
jq --version
What should I see?

You should see a line containing the jq name followed by its version. This confirms the installation worked.

Jq still unavailable on macOS?

Use the official jq download page if Homebrew is unavailable. Choose the macOS installation option shown there.

Help me install jq on macOS.

Windows

  • Install jq through WinGet by running this command:
winget install jqlang.jq
What does this command do?

WinGet downloads the jq package and runs its installer. You may be asked to accept source terms before the installation continues.

  • Accept the source terms if PowerShell asks for confirmation.
  • Close the current PowerShell window after installation finishes.
  • Open a new PowerShell window through system search.
  • Confirm jq is available by running this command:
jq --version
What should I see?

You should see a line containing the jq name followed by its version. This confirms the installation worked.

Jq still unavailable on Windows?

Use the official jq download page if WinGet is unavailable. Choose the Windows executable that matches your computer.

Help me install jq on Windows.

Create the project workspace

The generated images need to stay beside their response data. A dedicated image-model-costs directory keeps every cost record and comparison result together.

macOS

  • Create the image-model-costs workspace on your Desktop by running these commands:
cd ~/Desktop
mkdir image-model-costs
cd image-model-costs

What do these commands do?

  • The first command moves your terminal to the Desktop.
  • The second command creates the image-model-costs directory.
  • The final command moves your terminal into that directory.

Windows

  • Create the image-model-costs workspace on your Desktop by running these commands:
Set-Location -Path "$HOME\Desktop"
New-Item -Path "image-model-costs" -ItemType Directory
Set-Location -Path "image-model-costs"

What do these commands do?

  • The first command moves PowerShell to your Desktop.
  • The second command creates the image-model-costs directory.
  • The final command moves PowerShell into that directory.

Before you run the final check, do you expect to see both tool versions plus the workspace path? The result will test that prediction.

macOS

  • Verify both tools and your current directory by running these commands:
curl --version
jq --version
pwd

What should I see?

You should see curl version details followed by a jq version. The final line should end with /Desktop/image-model-costs.

Windows

  • Verify both tools and your current directory by running these commands:
curl --version
jq --version
Get-Location

What should I see?

You should see curl version details followed by a jq version. The final path should end with Desktop\image-model-costs.

Your terminal now has both tools available. Your local workspace is ready without sending anything to OpenRouter.

Workspace path look different?

Check that the final path ends with the exact directory name image-model-costs. Return to your Desktop before recreating the directory if the name is different.

Help me fix my project workspace.

✔️ Awesome, I've got everything!

Great work. Keep this terminal open inside image-model-costs for the first request.

ⓧ I'd like to double check the full code

Local workspace directory named image-model-costs, ready to store API responses, generated image files, cost records, latency records, and comparison tables.

Your command-line workspace is ready. Next up, you will create an OpenRouter key before sending the first image request.

Create an OpenRouter API Key

Your comparison needs permission to reach several image models. OpenRouter uses an API key to connect each request to your account.

Credits cover the images you generate. This step funds your account before placing the key in your terminal for secure access.

In this step, get ready to:
  • Add a small credit balance to your OpenRouter account.
  • Create an API key for your image comparison.
  • Load the key into your terminal as an environment variable.
Fund your OpenRouter account

Credits are deposits that OpenRouter deducts from as you use models. Your balance gives the upcoming image requests room to run.

Adding credit charges your selected payment method. You control the deposit size during checkout.

  • Visit the official OpenRouter Credits page in your browser.
  • Select the sign-in option if OpenRouter asks you to authenticate.
  • Complete the authentication flow shown in your browser.
  • Choose the purchase control on the Credits page.
  • Enter a small deposit that you are comfortable using for this project.
  • Complete the checkout flow using your own billing details.

You should see your available credit balance increase after the payment finishes. That balance now covers the image requests later in the project.

Balance Still Unchanged?

  • Refresh the Credits page after the checkout finishes.
  • Check the payment status if the purchase is still processing.
  • Confirm that you returned to the same OpenRouter account used during checkout.

Help me troubleshoot my missing OpenRouter credit balance.

Create your API key

An API key is a credential that can spend your account credits. OpenRouter shows the full key during creation because the secret value cannot be retrieved later.

Copying a credential can feel risky. You will place it directly in your terminal without saving it inside the project workspace.

  • Visit the official OpenRouter key settings page.
  • Use the key-creation control on the page.
  • Enter image-model-costs in the key name field.
  • Finish the key creation flow.
  • Copy the revealed key using the copy control beside it.
  • Close the reveal dialog after the key is safely on your clipboard.

Your keys list should now include a masked entry named image-model-costs. The full credential stays hidden after the reveal dialog closes.

Lost the Revealed Key?

  • Delete the unusable key from the key settings page.
  • Create a replacement key with the same name.
  • Copy the replacement before closing its reveal dialog.

Help me safely replace my OpenRouter API key.

Load the key into your terminal

An environment variable gives terminal commands access to the key without placing it in a project file. The variable for this project is OPENROUTER_API_KEY.

  • Switch back to the terminal from earlier.
  • Choose the tab that matches your operating system.

macOS

  • Replace sk-or-v1-YOUR-API-KEY in the command below with the key on your clipboard.
  • Set the environment variable for your current terminal session by running:
export OPENROUTER_API_KEY="sk-or-v1-YOUR-API-KEY"

What Does This Command Do?

The export command makes OPENROUTER_API_KEY available to commands started from this terminal session. Your key stays outside the image-model-costs workspace.

  • Confirm that your terminal returns to its prompt without an error.

Windows

  • Replace sk-or-v1-YOUR-API-KEY in the command below with the key on your clipboard.
  • Set the environment variable for your current PowerShell session by running:
$env:OPENROUTER_API_KEY="sk-or-v1-YOUR-API-KEY"

What Does This Command Do?

The $env: assignment makes OPENROUTER_API_KEY available to commands started from this PowerShell session. Your key stays outside the image-model-costs workspace.

  • Confirm that PowerShell returns to its prompt without an error.

Linux

  • Replace sk-or-v1-YOUR-API-KEY in the command below with the key on your clipboard.
  • Set the environment variable for your current terminal session by running:
export OPENROUTER_API_KEY="sk-or-v1-YOUR-API-KEY"

What Does This Command Do?

The export command makes OPENROUTER_API_KEY available to commands started from this terminal session. Your key stays outside the image-model-costs workspace.

  • Confirm that your terminal returns to its prompt without an error.

Terminal Rejected the Command?

  • Use the macOS or Linux command in a Bash or Zsh terminal.
  • Use the Windows command in PowerShell.
  • Check that the opening quote has a matching closing quote after your key.

Help me set my OpenRouter environment variable.

Before you check, do you expect the keys page to show the full credential or a masked entry?

  • Return to the OpenRouter key settings page in your browser.
  • Confirm that the keys list contains the masked image-model-costs entry.
  • Confirm that your available credit balance is visible on the page.

You should see the named key as a masked entry beside your available balance. This confirms your funded account is ready without exposing the credential.

Your funded OpenRouter key is ready in the terminal. Next up, you will send one prompt to a single image model and open the image it returns.

Generate a Test Image

Your funded key is ready. You now need proof that it can turn a prompt into an actual image.

The OpenRouter Image API returns image bytes inside a JSON response. The response also carries usage information for the completed request.

In this step, you will send one prompt through a single image model. You will save the complete response before opening the returned image.

In this step, get ready to:
  • Send a test prompt to one image model.
  • Save the complete API response with its usage data.
  • Decode the returned image for visual inspection.
Send the first image request

A single request gives you a baseline before you compare more models. This request uses your paid OpenRouter balance.

The command sends one generation request. Your spend stays limited to that single request.

  • Switch back to the terminal from earlier.
  • Move into the existing image-model-costs workspace.
  • Send the test prompt and save the complete response as test-response.json by running:
curl --request POST \
  --url https://openrouter.ai/api/v1/images \
  --header "Authorization: Bearer $OPENROUTER_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "model": "bytedance-seed/seedream-4.5",
    "prompt": "a red panda astronaut floating in space, studio lighting"
  }' \
  --output test-response.json

What does this command do?

  • The POST request sends your prompt to the image generation endpoint.
  • The Authorization header reads your key from OPENROUTER_API_KEY without writing the secret into the command.
  • The model field selects bytedance-seed/seedream-4.5 for this first test.
  • The --output option preserves the complete response in test-response.json.

The terminal may stay busy while the model renders the picture. Once the request finishes, test-response.json sits inside your workspace.

Request finished without an image?

Check that OPENROUTER_API_KEY is still available in this terminal. Confirm that your key still has credit in the OpenRouter dashboard.

A response without image data may contain an error object instead. Keep test-response.json so you can inspect what the API returned.

Help me troubleshoot my OpenRouter image request.

Check and decode the response

OpenRouter stores the generated picture as base64 text in data[0].b64_json. The request charge is available separately in usage.cost.

  • Check that both fields are present by running:
jq '(.data[0].b64_json != null), (.usage.cost != null)' test-response.json

What does this response check show?

  • The first result checks whether the response contains image data.
  • The second result checks whether the response contains the completed request cost.
  • Two true values confirm that the response has both pieces.

You should see true twice. You now have a saved response that contains the picture plus the information needed for the cost check.

  • Decode the image data into test-image.png by running:
jq -r '.data[0].b64_json | @base64d' test-response.json > test-image.png

How does the image become a file?

The jq filter extracts b64_json from the first result. The @base64d filter converts that encoded text back into image bytes.

The final redirect writes those bytes to test-image.png. Your original API response remains untouched in test-response.json.

Open and verify the image

Before you open the file, what details do you expect the model to include from the prompt?

macOS

  • Click Finder in the Dock.
  • Enter image-model-costs in the Finder search field.
  • Open the image-model-costs folder from the search results.
  • Double-click test-image.png.

Windows

  • Press Windows+E to open File Explorer.
  • Enter image-model-costs in the File Explorer search box.
  • Open the image-model-costs folder from the search results.
  • Double-click test-image.png.

You should see a red panda astronaut floating in space with studio lighting. That visible scene proves the prompt travelled through the API and returned as a local image.

Image file does not open?

  • Confirm that the first result from the response check was true.
  • Check that the saved response contains data[0].b64_json before decoding it again.
  • Confirm that the decoded file is named test-image.png.

Help me open my decoded image.

Your first image request works from prompt to local file. Next up, you will read the recorded cost and calculate what this picture charged you.

Record the Single-Image Cost

Your first image is already on disk. A listed model rate still does not show the exact charge for that completed request.

Image models can bill per token, per megapixel, or per image.

OpenRouter records the completed request's charge in usage.cost. You'll extract that number into a reusable cost record.

In this step, get ready to:
  • Identify the cost field in the saved response.
  • Extract its value into a cost record.
  • Confirm the saved record matches the terminal output.
Locate the charge in the response

The saved response is a JSON object. Its usage section contains the cost field for the completed request.

  • Switch back to the terminal in the image-model-costs workspace.
  • Enter the saved response filename here: your saved response filename.
Extract and save the cost

Before you run this, which single value do you expect jq to print from the usage object?

  • Save the extracted charge in single-image-cost.txt by running this command:
jq '.usage.cost' [[RESPONSE_FILE="your saved response filename"]] | tee single-image-cost.txt

What does this command do?

  • jq reads the saved JSON response.
  • The .usage.cost filter selects the cost value inside the usage object.
  • tee displays that value in the terminal.
  • tee also writes the value to single-image-cost.txt.
  • Check the terminal output for one decimal number.

You'll see one decimal number in the terminal. That's your first measured cost for a generated picture.

No cost value in the terminal?

  • Check that the filename you entered matches the complete response file in image-model-costs.
  • Return to the image-model-costs workspace if the terminal reports a missing file.
  • Use the response from the completed image request if another JSON file lacks the usage object.

Help me find the image cost in my saved response.

Confirm the saved cost record

Before you check, do you expect the saved record to match the number that just appeared in your terminal?

  • Read the saved cost record by running this command:
cat single-image-cost.txt

What does this check prove?

  • cat reads the contents of single-image-cost.txt.
  • A matching value confirms the extracted charge persisted in the cost record.
  • Compare the saved number with the value from the extraction command.

You'll see the same decimal number again. This confirms single-image-cost.txt contains the actual charge extracted from the saved response.

Saved record empty or different?

  • Rerun the extraction command if single-image-cost.txt is empty.
  • Use the first image response filename if the saved number belongs to another request.

Help me verify my saved image cost record.

Your first image now has a measured cost record. Next, you'll compare it with four more models.

Compare Five Image Models

Your first OpenRouter image proved one model can answer the prompt. A single result cannot show how its price or speed compares.

A fair test sends the identical prompt through the same API. Each result records the actual cost plus the request latency.

In This Step, Get Ready To:
  • Choose five current image models.
  • Send the initial prompt through every model.
  • Record each result's cost plus latency.
Choose Five Image Models

OpenRouter's live model list gives you identifiers that the Image API accepts today. Your first identifier plus four current choices creates the five-way set.

  • List the current image model identifiers in the terminal from earlier by running this command:
curl --request GET \
  --url https://openrouter.ai/api/v1/images/models \
  --header "Authorization: Bearer $OPENROUTER_API_KEY" \
| jq -r '.data[].id'

What Does This Command Do?

  • The request retrieves the current image-generation model catalog from OpenRouter.
  • The jq filter prints only the id value from each model.

You'll see one image model identifier per line. These are the exact values accepted by the image endpoint.

Don't See the Model List?

  • Switch back to the terminal session where your API key is already available.
  • Check your internet connection if the request cannot reach OpenRouter.
  • Ask for help with the response using this troubleshooting prompt.
  • Record the model identifier from your first test here: first tested model identifier.
  • Record exactly four additional identifiers as a space-separated list here: four additional model identifiers separated by spaces.
Run the Timed Comparison

A controlled comparison changes one input: the model identifier. The original prompt stays fixed across all five requests.

  • Load your five identifiers plus the original prompt into the terminal by running this setup:
FIRST_MODEL="[[FIRST_MODEL="first tested model identifier"]]"
ADDITIONAL_MODELS="[[ADDITIONAL_MODELS="four additional model identifiers separated by spaces"]]"
PROMPT="[[INITIAL_PROMPT="exact initial image prompt"]]"
printf 'model,cost_usd,latency_seconds\n' > comparison.csv
printf 'Models selected:\n%s\n' "$FIRST_MODEL"
printf '%s\n' $ADDITIONAL_MODELS

What Does This Setup Do?

  • The three shell variables hold the first model identifier, the four additional identifiers, plus the unchanged prompt.
  • The comparison.csv file starts with columns for model identifier, actual cost, plus latency in seconds.
  • The final two lines print your selected identifiers before any billable requests run.

You should see exactly five model identifiers below the selection heading. This check keeps the batch limited to the intended models.

Don't See Five Identifiers?

  • Check that the first model placeholder contains one identifier.
  • Check that the additional-models placeholder contains exactly four identifiers separated by spaces.
  • Ask for help checking the values using this model-list prompt.

This batch sends five billable image requests. The list stays fixed at five models, which prevents the loop from expanding across the entire catalog.

The first model runs again because your earlier request did not capture curl's total transfer time. Before you run the batch, which model do you expect to finish first?

  • Generate the five timed results by running this batch:
set -e
INDEX=0
for MODEL in "$FIRST_MODEL" $ADDITIONAL_MODELS
do
  INDEX=$((INDEX + 1))
  RESPONSE="response-$INDEX.json"
  LATENCY=$(curl --fail-with-body --request POST \
    --url https://openrouter.ai/api/v1/images \
    --header "Authorization: Bearer $OPENROUTER_API_KEY" \
    --header "Content-Type: application/json" \
    --data "$(jq -n --arg model "$MODEL" --arg prompt "$PROMPT" '{model: $model, prompt: $prompt}')" \
    --output "$RESPONSE" \
    --write-out '%{time_total}')
  COST=$(jq -r '.usage.cost' "$RESPONSE")
  MEDIA_TYPE=$(jq -r '.data[0].media_type // "application/octet-stream"' "$RESPONSE")
  case "$MEDIA_TYPE" in
    image/png) EXT="png" ;;
    image/jpeg) EXT="jpg" ;;
    image/webp) EXT="webp" ;;
    image/svg+xml) EXT="svg" ;;
    *) EXT="img" ;;
  esac
  jq -r '.data[0].b64_json' "$RESPONSE" | base64 --decode > "image-$INDEX.$EXT"
  printf '%s,%s,%s\n' "$MODEL" "$COST" "$LATENCY" >> comparison.csv
  printf 'Saved model %s in %s seconds.\n' "$INDEX" "$LATENCY"
done

How Does the Comparison Work?

  • The loop sends the same prompt to each selected model through the OpenRouter image endpoint.
  • The time_total value records the complete transfer time in seconds.
  • The usage.cost value records the actual charge reported for that response.
  • The media_type value gives each decoded image a matching file extension.

You'll see five saved-model lines as the requests complete. Each line includes the measured time for that model.

That's the core comparison captured. Every selected model now has a response file, a local image, plus one cost-and-latency row.

Did the Batch Stop Early?

  • Inspect the most recent response file for the API's error details.
  • Confirm that the failing identifier still appears in the current image model list.
  • Rerun the setup block after correcting the identifier.
  • Ask for help with the failed result using this batch troubleshooting prompt.
Verify the Five Results

The saved images show what each model produced. The CSV keeps the model identifier beside the cost and measured latency.

  • Open each image-1 through image-5 file using the same method you used for the first result.
  • Inspect every image for how it interpreted the unchanged prompt.

Before you check the files, how many response filenames, image filenames, plus comparison rows do you expect to see?

  • Display the saved result files plus the cumulative comparison record by running:
ls response-*.json image-* comparison.csv
cat comparison.csv

What Should You See?

You should see five response filenames plus five image filenames. The table should contain one header followed by five model rows.

Each model row should show its identifier, the actual response cost, plus the total request latency in seconds.

Missing a File or Row?

  • Return to the batch output to find the model without a saved confirmation line.
  • Check the matching response file for an API error.
  • Ask for help reconciling the files using this result-check prompt.

Your five-way baseline is ready. Next, you'll test readable text inside the images and rank the models using cost plus visual quality.

Rank Costs and Text Legibility

Your first run gave you actual costs from five image models. The OpenRouter API also gave you latency for each result.

Pricing pages express charges per token, per megapixel, or per image. This step adds one shared quality test to your measured costs.

In this step, get ready to:
  • Generate a second set of five images with the same prompt.
  • Score each image using one text-legibility rule.
  • Rank the five models by actual cost beside their legibility scores.
Run the readable-text prompt

A fair quality comparison changes only one variable. Every model receives the exact same request for readable text.

  • Return to the five-model loop from earlier in your terminal history.
  • Configure the loop to save this run under separate text-prompt result names inside image-model-costs.
  • Replace the initial prompt with Create an image with readable text inside the image: IMAGE MODEL COSTS.
  • Before you run the loop, predict which model will render the exact wording most clearly.
  • Run the updated five-model loop.

You should see five completed requests. You should also have five new response files plus five new image files with distinct text-prompt names.

Missing one of the five results?

Check that OPENROUTER_API_KEY is still available in the terminal. Confirm that the loop still contains the same five model identifiers from your cumulative comparison record.

Keep the completed files from this run. Rerun only the model whose response or image is missing.

Help me troubleshoot a missing result from my five-model image loop.

Score text legibility

Text legibility needs one consistent scoring rule. A fixed rule keeps personal preference from changing the result between models.

Use One Legibility Rule

  • Mark Legible when you can read the entire phrase IMAGE MODEL COSTS without guessing.
  • Mark Not legible when a word is missing, malformed, or unreadable.
  • Press Cmd+Space on macOS or the Windows key on Windows to open system search.
  • Type Finder on macOS or File Explorer on Windows to open your file browser.
  • Navigate to the text-prompt results inside image-model-costs.

You should see five newly saved images. Each image corresponds to one of the same five model identifiers from your first comparison.

  • Open the first text-prompt image.
  • Compare its generated wording with IMAGE MODEL COSTS.
  • Add a Text legibility column to the cumulative comparison record.
  • Record Legible or Not legible for the first model.
  • Repeat the same inspection for the remaining four images.

Your comparison record should now contain one legibility score for every model. The five scores turn visual inspection into a reusable result.

Build the final ranking

The final table puts measured spend beside observed quality. This gives you a practical reference for choosing a model after the project.

  • Add a final table to the comparison output from earlier with these columns: Rank, Model, Actual cost, and Text legibility.
  • Populate one row per model using the cumulative comparison record.

You should now see five unsorted rows. Each row should combine one model identifier with its returned cost plus its observed legibility score.

  • Before you sort the table, predict which model will take the lowest-cost rank.
  • Sort the five rows from lowest actual cost to highest actual cost.

The first row should now contain the cheapest measured result. The fifth row should contain the most expensive measured result.

  • Number the sorted rows from 1 to 5 in the Rank column.
  • Save the updated comparison output inside image-model-costs.
  • Return to the text-prompt results in your file browser.
  • Open the text-prompt image produced by the rank-one model.

You should see exactly five ranked rows in the saved table. Every row should contain either Legible or Not legible.

The rank-one image shows whether your cheapest model also passed the text test. Your table now captures that trade-off without relying on pricing-page estimates.

Strong finish. You have turned five unrelated pricing schemes into one cost and quality benchmark you can reuse.

Secret mission

Turn Results Into a Model Playbook

Turn your benchmark into a reusable selection playbook. Project each model's observed cost across 100 images. Use your saved results to choose a model for a text-heavy campaign.

Clean Up Your Resources

Future requests using the active API key can consume your remaining OpenRouter credit. A spend limit or key deletion keeps later use under control.

Nice Work!

Nice Work!

You did it! You built a reusable comparison of five image models using the OpenRouter API.

What you learned:

  • Sent the same image prompt through five models. Saved every response beside its returned image.
  • Extracted each model's actual image cost. Measured the request latency for every result.
  • Tested readable text generation with a second prompt. Ranked all five models by cost. Recorded observed text legibility in a reusable table.
  • Secret Mission: Completed an optional challenge that pushed your image-model comparison skills further.

Ready to quiz yourself?