Free Vision APIs: Read Images and Screenshots for Free

A vision API takes an image and a question and answers in text: describe a photo, read a receipt, pull text from a screenshot (OCR), check a chart. Three providers say on their own pages that you can send images for free, within rate limits. Everything below was checked on the vendors' pages on 2026-10-21.

What you get

Gemini API free tier (Gemini Developer API free tier)

• Google's pricing page lists the free tier's input as "Free of charge" for Gemini 3.8 Flash, and for Gemini 2.5 Flash-Lite under "Input price (text, image, video)" (page updated 2026-10-19).
• Image cost in tokens: 258 tokens for an image up to 384 × 384 pixels; larger images are cut into 768 × 768 tiles of 258 tokens each. Up to 3,600 images per request; inline image data limits the whole request to 20 MB. PNG, JPEG, WEBP, HEIC and HEIF.
• Google does not publish a fixed free-tier rate table; your limits are shown in AI Studio.

Groq Free plan (Groq free tier)

• Groq's vision model qwen/qwen3.8-27b is in its Free plan limits table: 30 requests per minute, 1,000 per day, 8,000 tokens per minute and 200,000 tokens per day.
• Each image counts as 2,048 input tokens, at most 3 images per request, and a request with an image URL can be up to 20 MB. By our arithmetic, 8,000 tokens a minute is room for about 3 images a minute.

OpenRouter :free models (OpenRouter free models)

• Model pages list image input and "Price: Free" for free variants such as google/gemma-4-31b-it:free ("supporting text and image input"). On 2026-10-21 OpenRouter listed 9 free models with image input, among them Gemma 4 26B and 31B and nvidia/nemotron-3.5-super-vl:free.
• Free variants allow 20 requests per minute and 50 requests per day, or 1,000 per day once you have bought at least 10 credits.

Steps

Gemini (Python, from Google's image understanding docs)

1. Create a free key in Google AI Studio (see the Gemini API key guide) and set GEMINI_API_KEY.
2. pip install google-genai, then send an image inline:

import base64
from google import genai

with open('path/to/small-sample.jpg', 'rb') as f:
    image_bytes = f.read()

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input=[
        {"type": "text", "text": "Caption this image."},
        {
            "type": "image",
            "data": base64.b64encode(image_bytes).decode('utf-8'),
            "mime_type": "image/jpeg"
        }
    ]
)
print(interaction.output_text)

For files over 20 MB, upload them with the Files API first and pass the file's URI.

Groq (Python, from Groq's vision docs)

1. Create a key in the GroqCloud console (see the Groq API key guide) and set GROQ_API_KEY.
2. pip install groq, then send a local image as base64:

from groq import Groq
import base64
import os

# Function to encode the image
def encode_image(image_path):
  with open(image_path, "rb") as image_file:
    return base64.b64encode(image_file.read()).decode('utf-8')

# Path to your image
image_path = "sf.jpg"

# Getting the base64 string
base64_image = encode_image(image_path)

client = Groq(api_key=os.environ.get("GROQ_API_KEY"))

chat_completion = client.chat.completions.create(
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What's in this image?"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{base64_image}",
                    },
                },
            ],
        }
    ],
    model="qwen/qwen3.8-27b",
)

print(chat_completion.choices[0].message.content)

OpenRouter: the API is OpenAI-compatible, so the same image_url message works with https://openrouter.ai/api/v1 as the base URL, your OpenRouter key, and a free model ID such as google/gemma-4-31b-it:free. See the OpenRouter free models guide.

Spend fewer image tokens

Every vendor turns an image into tokens, and bigger images cost more until a size cap, after which they are shrunk and small text can blur. How AI reads a picture shows the patch and tile math in five minutes. In practice:

• Crop to what matters. A cropped label or table costs fewer tokens and is read more reliably than the same detail in a full photo.
• Resize before you send. On Gemini an image up to 384 × 384 pixels costs 258 tokens; on Groq every image costs 2,048 tokens whatever its size, so there the saving is in sending fewer images.
• One image per question when you can: on Groq's free plan, 3 images already fill a minute's token budget.

Limits and the catch

• Your data may be used. Google's pricing page marks free-tier content as "used to improve our products". Do not send IDs, contracts or other private documents to a free tier.
• Rate limits are low. About 3 images a minute on Groq's free plan and 50 requests a day on OpenRouter free models without credits; Gemini's limits depend on your account.
• Free lineups change. Free models come and go on OpenRouter, and Groq's Free plan table changes; check the vendor pages before you build on them.

If it doesn't work

• Groq returns 400: a request with an image URL must stay under 20 MB, and at most 3 images per request.
• Gemini rejects a large file: inline data limits the whole request to 20 MB; upload the file with the Files API instead.
• OpenRouter returns 429: you hit 20 requests per minute or the daily cap for free variants (50, or 1,000 after buying 10 credits).
• The model misreads small text: crop to that part of the image and send it again.