TAG37

TAG39TAG41

Introduction

The most alarming aspect of automatically generating e-commerce images is not the image “quality.” It is the text for prices and brand names. If an image is delivered with $49.99 rendered as $4.99, that is not a matter of correction but an incident. Whether the text is accurate is a deciding factor in whether the solution can be adopted.

So, on November 11, 2026, we compared three scenarios × two models under identical prompts and conditions, using OpenAI’s GPT Image 2 and Google’s Nano Banana Pro (Gemini 3 Pro Image). We generated one image per model for each scenario, with no rerolls. Failed requests and all defects found are presented as-is.

Conclusion first.Both models reproduced all 14 specified strings exactly, character for character. There was no garbling and no arbitrary additions. Meanwhile, there were clear differences in speed, output format, and behavior upon failure, and these factors determine the practical choice.

Testing Environment

Item	Details
Execution date	November 11, 2026
Caller	Via an OpenAI-compatible API gateway (both models called with a single key)
GPT Image 2	/v1/images/generations, quality=medium, returned as PNG
Nano Banana Pro	Gemini-native generateContent, aspectRatio: 1:1, returned as JPEG
Resolution	1024×1024 for all scenarios
Number of generations	Once per model for each scenario (no rerolls)

Both models differ in vendor and protocol, but because they could be called through the same single Crazyrouter endpoint, the comparison conditions were effectively limited to “the difference between the models.” The model IDs are gpt-image-2 and nano-banana-pro, and the only entry point is this:

Available model IDs and tiers can be checked before running in the Crazyrouter model directory. The same lineup also includes gpt-image-2.5-flare, gpt-image-2.5-sunburst, and nano-banana-2.1, but to keep the article’s comparison conditions fixed, we limited the test to the two models above. Model-name mappings update quickly, so always check the current list when trying them.

Verification method: Add constraints that can be “read and judged”

I always include textual constraints in the prompt that make it possible to judge pass or fail by looking at the finished image. You cannot judge with text that merely “looks about right.” The three scenarios are as follows.

1. Sale hero image — A set of five: headline, discount badge, price, original price with a strikethrough, and promotional-period banner
2. Hot sauce package label — A set of three: brand name, flavor name, and volume, plus a prohibition clause stating that “only these words appear on the label”
3. Coffee product detail card — A set of six: headline + three feature descriptions + an extremely small specification line (NET WT 300ml / SERVINGS: 2)

Scenario 3 is the most difficult. Image models tend to struggle most with small text, and exact matching at this size was not something that could have been expected a year ago.

Results: All 14 sets were correct

Scenario 1 (Sale hero image)

All five strings—BLACK FRIDAY SALE, 50% OFF, $49.99, the strikethrough $99.99, and NOV 24 - NOV 30 ONLY—matched verbatim in both models. The strikethrough was also positioned correctly. The difference was in presentation. GPT Image 2 conveyed an “ad-like quality” through typography with strong contrast and texture, while Nano Banana Pro showed better product understanding by depicting not only the opened charging case but also the earbuds.

Scenario 2 (Package label)

FIRE DROP, SMOKY CHIPOTLE, and NET 250ml were all correct in both models,and there was no extraneous text on the labels whatsoever (so-called “decorative pseudo-text”). This is the most common failure pattern in AI-generated package images, meaning that both models adhered to the constraint clause this time.

Note that, in this scenario, the initial request to Nano Banana Pro was disconnected during forwarding (IncompleteRead—a connection-layer failure, not a rejection on the model side). It succeeded on retry. This is real-world data demonstrating that job management needs to distinguish between “request failure” and “image not generated.”

Scenario 3 (Product Detail Card)

Both models correctly rendered all six sets, including the extremely small specification text. Even the numbers, colons, and slashes matched. However, the only real defect is also found here: the Nano Banana Pro version has a dotted-noise artifact remaining in the bottom-right corner, requiring either trimming before delivery or regeneration. Conversely, the GPT Image 2 version has no artifacts, but its layout feels cramped, with the heading occupying nearly half the screen. As an information card, however, the Nano version is better organized.

Not Failing ≠ a Reason to Choose It

Since there was no difference in text accuracy, the practical decision-making criteria shift to the following four points.

• Speed: Among the requests for which timing could be measured, Nano Banana Pro took 18.4–21.0 seconds, while GPT Image 2 took 75.5–124.6 seconds. That is more than four times the time per image, and in batch generation, this difference translates directly into throughput.
• Output Format: GPT Image 2 produces PNG files (approximately 1.0–1.4 MB), while Nano Banana Pro produces JPEG files (approximately 0.4–0.6 MB). If transparency is required, only one option is available.
• Type of Failure: Connection-related disconnections can be resolved by retrying, but a rejection due to content policy will merely consume quota. It is worth handling these separately.
• Timeout: Because some cases take nearly two minutes per image, they will fail under the default HTTP timeout. It is safer to extend the timeout to 180 seconds or more, or to use Nano Banana Pro’s asynchronous mode (receive a task ID via asyncGenerateContent and poll for results).

The differences in functionality are also clear. GPT Image 2 supports partial editing with a mask (changing only a specific area while preserving the pixels) and supports up to 16 reference images. Nano Banana Pro excels at conversational editing, in which reference images are placed in parts and instructions are given in natural language.

Which One to Choose

• High-volume draft generation, speed prioritized → Nano Banana Pro (retries and state management are mandatory)
• High-quality typography, PNG, precision for individual images prioritized → GPT Image 2 (extend the timeout)
• Precise partial editing → GPT Image 2’s mask; broader semantic editing → Nano Banana Pro’s conversational editing
• In practice, using both together is the most promising approach: generate large volumes of drafts with Nano, then use GPT Image 2 to finish only the compositions that look good. Switching between them requires only changing the model name.

In the testing for this article, both models could be called with a single key through the same gateway, andthe only difference between the protocols was the shape of the request body.

Conclusion: What We Cannot Say This Time

These are results from a single generation, in English only, at 1024×1024, covering one day. CJK characters, including Japanese, even smaller text, editing using reference images, and 2K/4K output have not been tested, and the 14/14 result should not be extrapolated as-is. We will retest with Japanese strings in a separate verification article.

References

• Crazyrouter Model Directory(a page for confirming model IDs and tiers before execution)
• Crazyrouter API Documentation(endpoint definitions for the Images / Gemini protocols)