DEV Community: Kushagra Mehrotra

Can image tokens cost less than text tokens - Explaining Gemini API Image Token Economics

Kushagra Mehrotra — Thu, 06 Aug 2026 04:06:44 +0000

When building multimodal applications with Google Gemini API, understanding how visual inputs are tokenized is crucial. Unlike simple text where 1 token ≈ 0.75 words, processing images involves Vision Transformers (ViTs), patch slicing, and dynamic grid tiling.

In this guide, we break down the exact math behind Gemini's image tokenization, explain why text legibility collapses at low resolutions, and share actionable image pre-processing strategies to reduce visual token consumption.

1. The Single-Patch Base Case (<= 384px)

Gemini treats any image where both dimensions are <= 384 pixels as a single patch, costing a flat 258 tokens.

The Math Behind 258 Tokens

Why 258 tokens? It stems from Gemini's underlying Vision Transformer architecture:

Native Base Resolution = 384 x 384 pixels.
Patch Size = 24 x 24 pixels per visual token.
Patches per side = 384px / 24px = 16 patches
Total Visual Patches = 16 x 16 = 256 patches

Gemini appends 2 structural tokens (used for spatial orientation and row framing) to the visual patch array:

256 visual patch tokens + 2 spatial tokens = 258 tokens

If your image is 128 x 128 or 300 x 200, it is padded/scaled into this single 384 x 384 pass and costs exactly 258 tokens.

2. Tiling Logic for High-Resolution Images (> 384px)

When either dimension exceeds 384 pixels, Gemini switches from a single-pass flat rate to a dynamic tiling grid.

The Tiling Algorithm

Tile Grid Calculation: Gemini breaks the image into a grid of 768 x 768 pixel tiles.
Cost Per Tile: Each full or partial 768 x 768 tile costs 258 tokens.
Mathematical Formula:

Horizontal Tiles = ceiling(Width / 768), Vertical Tiles = ceiling(Height / 768)

Total Tokens = (Horizontal Tiles x Vertical Tiles) x 258

Token Breakdown Across Resolutions

Resolution	Dimension Check	Tile Grid (H × V)	Total Tiles	Token Cost
500 x 500 px	Both > 384px	1 x 1	1 tile	258 tokens
1280 x 720 px	Width > 768px	2 x 1	2 tiles	516 tokens
1000 x 1000 px	Both > 768px	2 x 2	4 tiles	1,032 tokens
1920 x 1080 px (FHD)	1920 > 1536px	3 x 2	6 tiles	1,548 tokens
3840 x 2160 px (4K)	3840 > 3072px	5 x 3	15 tiles	3,870 tokens

Note: For a standard HD video frame (1280 x 720), ceiling(1280 / 768) = 2 horizontal tiles and ceiling(720 / 768) = 1 vertical tile, yielding 2 x 1 = 2 tiles (516 tokens).

3. Visualizing Token Budget: What Does 516 Tokens Equate To?

To put this into perspective, 516 tokens is roughly equivalent to 385–400 words of English text (about 2,000 characters).

In physical document terms, 516 tokens is equal to:

1 full single-spaced page of text (~500 words capacity).
3 to 4 dense paragraphs.
A 1.5-minute spoken script.

When you send a 1280×720 image to Gemini (costing 516 tokens), you are using roughly the same context window budget as sending a 400-word essay like this:

"Artificial intelligence models process text by breaking down human language into numerical chunks called tokens. A token isn't always a full word; short words like 'cat' or 'the' might be a single token, while longer or less common words like 'tokenization' get split into multiple sub-word tokens ('token', 'ization'). On average, 1,000 tokens of English text equals roughly 750 words.
When vision capabilities were added to models like Gemini, researchers needed a way to measure image input against the same context limits. Rather than inventing a new metric, images are divided into visual patches, and each patch is assigned a token equivalent. This allows the model's self-attention mechanism to process image features alongside text within the exact same transformer architecture.
Understanding this conversion helps developers optimize both API costs and context window efficiency. When working with multimodal inputs, knowing that a single high-definition image consumes a similar amount of capacity as a few paragraphs of text allows for smarter prompting strategies and better cost predictions when building applications at scale."
"Artificial intelligence models process text by breaking down human language into numerical chunks called tokens. A token isn't always a full word; short words like 'cat' or 'the' might be a single token, while longer or less common words like 'tokenization' get split into multiple sub-word tokens ('token', 'ization'). On average, 1,000 tokens of English text equals roughly 750 words.
When vision capabilities were added to models like Gemini, researchers needed a way to measure image input against the same context limits. Rather than inventing a new metric, images are divided into visual patches, and each patch is assigned a token equivalent. This allows the model's self-attention mechanism to process image features alongside text within the exact same transformer architecture.
Understanding this conversion helps developers optimize both API costs and context window efficiency. When working with multimodal inputs, knowing that a single high-definition image consumes a similar amount of capacity as a few paragraphs of text allows for smarter prompting strategies and better cost predictions when building applications at scale."
"Artificial intelligence models process text by breaking down human language into numerical chunks called tokens. A token isn't always a full word; short words like 'cat' or 'the' might be a single token, while longer or less common words like 'tokenization' get split into multiple sub-word tokens ('token', 'ization'). On average, 1,000 tokens of English text equals roughly 750 words."

The passage above is exactly 400 words, or ~525 tokens (Verified by pasting text in Google AI Studio)

4. The Resolution vs. OCR Accuracy Dilemma

Why not simply downscale every document image to 640 x 480 to cap cost at 258 tokens?

The Character Stroke Blur Threshold

Gemini requires characters to be at least 15 to 20 pixels tall in the input image for reliable Optical Character Recognition (OCR).

On a standard 1920 x 1080 document scan, a 12pt font yields letters ~18px tall. Gemini reads this easily across its 6-tile grid.
Downscaling that same document to 640 x 480 reduces character height to just 3 to 4 pixels.

At 3–4 pixels, anti-aliasing blurs lowercase letters like 'e', 'o', and 'c' into visually identical gray blobs. The Vision Transformer cannot distinguish character strokes, leading to severe OCR errors or hallucinated text.

5. Pre-Processing Strategies to Cut Vision Tokens

You don't have to sacrifice text legibility to save money. By tailoring your image pipeline to Gemini's 768px tiling logic, you can achieve maximum OCR accuracy at minimal token cost.

Strategy 1: Align to 768px Grid Boundaries

Because Gemini uses ceiling division, ceiling(Width / 768), crossing a boundary by even 10 pixels adds an entire extra tile row or column.

An 800 x 800px image costs 2 x 2 = 4 tiles (1,032 tokens).
Resizing or cropping it to 768 x 768px drops it to 1 x 1 = 1 tile (258 tokens)—saving 75% with virtually no quality loss.
For Full HD images (1920x1080) downscale them to HD resolution (1280x720). This is the sweet spot for saving token cost and retaining text quality.

Strategy 2: Crop Whitespace & Margins

Scanned documents, PDFs, and invoices contain wide blank margins. Because Gemini counts tokens based on total pixel dimensions rather than text density, margin pixels cost as much as text pixels.

Impact: Cropping margins off a 1920 x 1080 scan reduces dimensions to ~1200 x 700, dropping grid size from 3 x 2 (1,548 tokens) to 2 x 1 (516 tokens)—a 66% cost reduction with zero resolution loss.

Strategy 3: Region-of-Interest (ROI) Column Slicing

Instead of sending a complex two-column paper or multi-page invoice as one large 2000px image, crop individual columns into narrow 768px-wide vertical strips. Each strip processes cleanly in a 1 x N grid without wasting horizontal tile padding.

Strategy 4: High-Contrast Binarization & Deskewing

For images containing mostly text, straightening tilted text (deskewing) prevents lines from spanning multiple patch boundaries. Binarizing (converting image to stark black-and-white using Otsu's thresholding) increases stroke contrast, allowing characters as small as 15px to remain readable even after aggressive downscaling.

Strategy 5: Dynamic Height Scaling Based on Line Count

Use the golden formula for document scaling:

Target Height (px) = Total Lines of Text x 25 px

A 20-line invoice needs ~500px of height. Fitting this into a 768 x 768 canvas caps the cost at 1 tile (258 tokens) while guaranteeing 25 pixels per line for near-100% OCR accuracy.

In which scenarios will cost of image token be less than text token for the same context?

An image costs fewer tokens than raw text whenever the information density of the text payload exceeds Gemini's fixed visual tile cost (258 tokens for a single tile of <= 384px or 768 x 768px).

Since English averages roughly 1.33 tokens per word (and non-Latin scripts average 2 to 4 tokens per word), an image becomes cheaper than text in the following scenarios:

1. Non-Latin Scripts (Indic, Arabic, Hebrew, CJK)

Byte-Pair Encoding (BPE) tokenizers are far less efficient for non-Latin scripts, where a single word or character often splits into 2 to 4 tokens.

Text Cost: A 200-word paragraph in Hindi, Arabic, Chinese, or Japanese can easily consume 500 to 800 text tokens.
Image Cost: A screenshot of that same paragraph fitting inside 1 Gemini tile costs 258 tokens.
Savings: Up to 65% reduction in token consumption.

2. Complex Mathematical Formulas and LaTeX

Verbose LaTeX code requires extensive command syntax to express complex proofs and matrix equations.

Text Cost: Expressing a 4 x 4 matrix equation or multi-line partial differential proof in LaTeX string format can take 400 to 600 text tokens.
Image Cost: A clear rendered image of the equation formatted into a single tile costs 258 tokens.

3. High-Density Tables, Spreadsheets, and UI Layouts

Text Cost: Fully describing a complex 10-column, 20-row spreadsheet or UI wireframe layout in Markdown or text requires thousands of words (1,500+ text tokens) to capture all data values and spatial coordinates.
Image Cost: A single screenshot captures every visual data point and spatial relationship across 1 tile (258 tokens) or 2 tiles (516 tokens).

Quick Comparison Matrix

Payload Type	Text Token Cost	Image Token Cost (1 Tile)	Cheaper Medium
50-word Email	~65 tokens	258 tokens	Text
200-word English Article	~265 tokens	258 tokens	Tie / Image
500-word PDF Page	~670 tokens	258 tokens	Image
200-word CJK / Hindi Text	~600 tokens	258 tokens	Image
100-line JSON Payload	~1,100 tokens	258 tokens	Image

Conclusion

By aligning your vision processing pipeline with Gemini's patch size (24px) and tile size (768px), you can optimize cost without degrading accuracy. For document AI and OCR workflows, smart pre-processing always beats raw resolution downscaling.

Thinking in algorithms - A Different Way to Think About the Task Scheduler Problem

Kushagra Mehrotra — Tue, 30 Jun 2026 20:41:29 +0000

I recently came across the classic CPU Task Scheduler problem on HackerRank.

You are given an integer N representing the number of CPU tasks, an array of N uppercase characters where each character denotes a task, and an integer cooldown representing the cooldown period. Each task takes exactly one CPU interval to execute, and the same task cannot be executed again until at least cooldown intervals have passed.

During the cooldown, the CPU may execute a different task or remain idle if no valid task is available.

Your objective is to determine the minimum total number of CPU intervals (including idle intervals) required to complete all the tasks.

Example
Input:
tasks = AAABBB
cooldown = 2

Output:
8
One optimal schedule is:
A → B → idle → A → B → idle → A → B

If you've seen this problem before, you've probably also seen the elegant mathematical solution:

(f_{ma x} - 1) (coo l d o w n + 1) + k

where:

f_max = maximum frequency of any task
k = number of tasks having frequency f_max

It's short, optimal, and interview-friendly.

But instead of asking "What's the formula?", I found myself wondering:

Can we actually build the schedule itself using simple Python primitives?

That curiosity led to a surprisingly elegant solution built around Counter, zip_longest, and chain.

The Core Idea

Imagine grouping identical tasks together.

aaaa
bbbbbbbb
cc
d
ee
ff
g
hhh
iiiiiiiiii
j

Instead of processing one task at a time, what if we interleave these groups?

Reading them row by row naturally spreads identical tasks apart.

For the input

aaaabbbbbbbbccdeeffghhhiiiiiiiiiij

we get

abcdefghij
abcefhi
abhi
abi
bi
bi
bi
bi
i
i

Notice how every repeated task automatically falls into a different row.

If a cooldown requires additional spacing, we simply pad the shorter rows with idle slots (_).

For example, with cooldown = 3:

abcdefghij
abcefhi
abhi
abi
_bi
_bi
_bi
_bi
__i
__i

Flattening these rows produces a valid execution schedule, and its length is exactly the answer we're looking for.

Step 1 — Count Task Frequencies

Let's begin with Python's Counter.

from collections import Counter

Counter(input_data)

which gives

{
    'a': 4,
    'b': 8,
    'c': 2,
    'd': 1,
    'e': 2,
    'f': 2,
    'g': 1,
    'h': 3,
    'i': 10,
    'j': 1
}

Step 2 — Build Character Sequences

Next, create one sequence for every distinct task.

sorted([k * v for k, v in Counter(input_data).items()])

Result:

[
    'aaaa',
    'bbbbbbbb',
    'cc',
    'd',
    'ee',
    'ff',
    'g',
    'hhh',
    'iiiiiiiiii',
    'j'
]

Let's call this list sequences.

Step 3 — Interleave the Sequences

Now comes the interesting part.

Python's itertools.zip_longest() reads every sequence in parallel.

from itertools import zip_longest

list(zip_longest(*sequences))

Result:

[
 ('a','b','c','d','e','f','g','h','i','j'),
 ('a','b','c',None,'e','f',None,'h','i',None),
 ('a','b',None,None,None,None,None,'h','i',None),
 ('a','b',None,None,None,None,None,None,'i',None),
 (None,'b',None,None,None,None,None,None,'i',None),
 (None,'b',None,None,None,None,None,None,'i',None),
 (None,'b',None,None,None,None,None,None,'i',None),
 (None,'b',None,None,None,None,None,None,'i',None),
 (None,None,None,None,None,None,None,None,'i',None),
 (None,None,None,None,None,None,None,None,'i',None)
]

Since not every sequence has the same length, zip_longest() fills the missing positions with None.

Step 4 — Remove Empty Slots

A simple list comprehension cleans things up.

intertwined = [
    [value for value in row if value]
    for row in zip_longest(*sequences)
]

Now we have

[
 ['a','b','c','d','e','f','g','h','i','j'],
 ['a','b','c','e','f','h','i'],
 ['a','b','h','i'],
 ['a','b','i'],
 ['b','i'],
 ['b','i'],
 ['b','i'],
 ['b','i'],
 ['i'],
 ['i']
]

Each row now contains at most one occurrence of every task.

Step 5 — Pad for Cooldown

If a row is shorter than the required cooldown spacing, prepend idle slots.

padded = [
    ['_'] * max(0, cooldown - len(group)) + group
    for group in intertwined
]

For cooldown = 3:

[
 ['a','b','c','d','e','f','g','h','i','j'],
 ['a','b','c','e','f','h','i'],
 ['a','b','h','i'],
 ['a','b','i'],
 ['_','b','i'],
 ['_','b','i'],
 ['_','b','i'],
 ['_','b','i'],
 ['_','_','i'],
 ['_','_','i']
]

The inserted _ values represent idle CPU intervals.

Step 6 — Flatten Everything

Finally, flatten the rows into a single schedule.

from itertools import chain

output = list(chain.from_iterable(padded))

Result:

[
 'a','b','c','d','e','f','g','h','i','j',
 'a','b','c','e','f','h','i',
 'a','b','h','i',
 'a','b','i',
 '_','b','i',
 '_','b','i',
 '_','b','i',
 '_','b','i',
 '_','_','i',
 '_','_','i'
]

The answer is simply

len(output)

🎉 Done!

Complexity

Time Complexity: O(n)
Space Complexity: O(n)

where n is the total number of tasks.

Final Thoughts

Would I use this in a coding interview?

Probably not.

The mathematical formula is shorter, more elegant, and easier to justify under interview pressure.

But I enjoyed exploring the problem from a different angle. Rather than deriving the answer directly, this approach constructs the schedule itself using a handful of Python's built-in tools.

Sometimes the most enjoyable part of algorithmic problems isn't finding the shortest solution—it's discovering an unexpected perspective that makes the problem feel completely different.

If nothing else, this little experiment gave me a new appreciation for just how versatile zip_longest() can be.

A love letter to CAPS lock

Kushagra Mehrotra — Tue, 12 Mar 2024 01:23:48 +0000

In my childhood my favourite keys were Caps Lock, along with Num lock and Scroll Lock. It was because I could see a real-time impact by pressing them, that was the LED that lit in my keyboard indicating that the respective key was on. I used to pretend I was sitting in a control room preparing for a launch mission: "Num Lock On! Scroll Lock On!... Boosters starting!... Hatch closed!... Controls Online!... Heads-up display booted!... and Caps Lock On! ... Launching Satellite! (proceeds to press enter)". Those were fun times. (is it just me? or anyone else relates?)

Apart from imagining wild sci-fi fantasies, Caps-Lock also had a utility. I was no touch-typist back then, so it was pretty useful to turn on Caps-Lock AND GO FULL BURST MODE IN CAPITAL LETTERS WHEN WRITING HEADINGS IN MS-WORD.
One day I was at my friends house, I saw him touch-typing, and it was so cool... I was determined to learn it as well. There was one speciality in his way of touch-typing, that he didn't utilize Shift for capitalizing even a single letter. The way he did was when he had to capitalize a letter he tapped Caps Lock ON and then proceeded to type a letter and then instantly he would turn Caps Lock OFF. It was fascinating to watch him move his fingers so fluidly! Even though the way I was taught¹ to touch-type was using Shift key to capitalize--the normal way--I remained fascinated with his way of using Caps Lock, and this fascination led me to keep exploring new ways of moving my fingers over keyboard.

In the journey, I explored Dvorak keyboard layout, Colemak keyboard layout, and Qarg² keyboard layout--albeit on Android phone not on physical keyboard--~~and not only that but I also learnt to use mouse with left hand~~ but anyways... along the way I discovered the use of Sticky keys in Windows!
Yes! those pesky pop-ups that appear when you tap Shift key five times in succession. The way you use them is like a auto-turning-off Caps Lock, or like the Android keyboard's shift press, where you press Shift and then you can lift your finger-off the key and press another key. If the key is an alphabet key then the letter will be capitalized and proceeding keystrokes would be registered normally; if the key is any other key it would act like you hit hotkey combination: Shift + <key>.

Whether Sticky keys settings is On or Off, you can still use your Shift key as usual by pressing and holding it with other key in combination; but enabling Sticky keys unlocked a new power!
The mechanism of Sticky key is: if you press a modifier key once, it turns it on, if you press it twice it locks it in On mode, and when you press it third time it turns off the modifier.

Personally I find this useful when writing full PowerShell commands like: Get-ChildItem, Get-ItemProperty, Expand-Archive, Measure-Command, etc. With Sticky keys ON--these Pascal-case names don't break my typing flow now.

Be careful though! Sticky keys can lead to annoyance when you are not careful or it can even permanently delete an item which you wanted to trash it to your Recycle bin³.
If you proceed to try Sticky keys setting, then there will be many such annoyances in the beginning where you press Shift or even Ctrl key (Oh beware that Sticky keys settings are for all modifier keys: Shift, Ctrl, and Alt) and lift-off your finger thinking you are registering a simple keystroke and not a hotkey combination but you end-up with a mishit.

With Sticky keys I've attained a level of satisfaction with my fascination with typing. I wanted to run over my keyboard one finger at a time and I've found a way, now I don't need to stretch my little fingers to hit a hotkey, I simply type the hotkey without pressing-and-holding.

Wrapping up, this might not exactly be a "love letter" to CAPS Lock but it all started with it.

I learned it from Typing Trainer Online - 100% Free Online Typing Web Tutor! though at the time it was https://my.typingtrainer.com/ (which now redirects to the former link). ↩
Reference : Typewise - QWERTY Killer: How Typewise’s Novel Hexagon Keyboard App Is Replacing Legacy Smartphone Keyboards; and the app Typewise Custom Keyboard - Apps on Google Play ↩
Since pressing Shift+Del would permanently delete an item on windows, sometimes without even confirmation. ↩