OpenAI's gpt-image-2 is the next generation of the gpt-image series — a token-billed image model accessed through the standard OpenAI Images API. It's a drop-in upgrade from gpt-image-1: same SDK, same call shape, same parameters. Point your existing OpenAI client at OrcaRouter's base URL and set the model to `openai/gpt-image-2`. Pricing is $5.00 input / $30.00 output per 1M tokens, billed at cost — zero markup, zero migration.
OpenAI GPT-Image-2 is a multimodal model from OpenAI that specializes in generating and editing images. It accepts text prompts and optional image inputs to produce modified or entirely new visual…
GPT-Image-2 is designed to generate images from text descriptions and to edit existing images based on textual instructions. It can modify attributes like color, texture, shape, and composition, as well as add or remove objects. The model supports inpainting (replacing parts of an image) and outpainting (extending the canvas) implicitly through prompt design. It also allows style transfer, enabling users to apply a given aesthetic to a source image. These capabilities make it suitable for tasks ranging from simple corrections to creative visual experimentation.
Yes, GPT-Image-2 can generate entirely new images from text prompts without requiring any input image. The model uses the provided description to create a visual representation, including details about scene composition, lighting, colors, and objects. The quality and fidelity of the generated image depend on prompt specificity and the constraints of the underlying architecture. For best results, prompts should be clear and avoid ambiguous references. This capability is useful for ideation, prototyping, and generating unique illustrations from concept descriptions.
GPT-Image-2 accepts text prompts as the primary input. When editing images, it requires an existing image to be provided either as a URL or as raw base64-encoded data within the API request. The image should be in a standard format such as PNG or JPEG, with resolution and size limits determined by OpenAI's API specifications. The model does not support video or multi-image inputs natively; each request operates on a single prompt-image pair. Output images are generated in common formats, typically PNG, and can be delivered as URLs or base64 data depending on client preference.
GPT-Image-2 does not maintain state across requests; each API call is independent. Multi-step editing—where an image is progressively refined through a series of prompts—must be managed by the calling application. Developers can implement a workflow where each step passes the previous output as input to the next request. This approach enables iterative editing, such as adjusting colors first, then adding a background, then resizing. While functional, the lack of built-in state means that the application must handle context, such as storing intermediate images and constructing the appropriate prompts for each step.
The LM Arena Image Edit Elo score of 1467.0 is a benchmark that measures the quality of image editing outputs. Elo scores in this context are calculated based on pairwise comparisons of model outputs by human evaluators. A score of 1467 indicates that GPT-Image-2 significantly outperforms baseline models and is competitive with other leading image editing models. It reflects strong performance in tasks like object insertion, background replacement, color changes, and compositional edits. This score is one of the highest on the LM Arena leaderboard for the image editing category, suggesting the model produces edits that are coherent, faithful to prompts, and visually appealing.
Latency for GPT-Image-2 varies depending on the complexity of the prompt, the size of the input (if any), and the desired output resolution. OpenAI does not publish fixed latency guarantees for this model; typical response times range from a few seconds to tens of seconds for large images or intricate edits. Since OrcaRouter is a relay that adds zero overhead to provider processing time, the actual wait time is the same as calling OpenAI directly. For production applications, users should implement timeouts and retry logic, and consider batch processing to manage throughput.
GPT-Image-2 excels at image editing tasks that require precise modifications based on natural language instructions. Its high LM Arena Elo score reflects its ability to produce edits that are both accurate and aesthetically pleasing. The model handles complex compositional changes well, such as replacing objects while maintaining proper lighting and shadows. It also generates high-quality images from scratch with good photorealism and prompt adherence. Users commonly report that it handles creative instructions (e.g., "make this scene look like an oil painting") with plausible style transfer.
Despite its strong benchmark performance, GPT-Image-2 has limitations. It may struggle with very long or multi-part instructions, especially when multiple objects require simultaneous modification. The model can produce occasional artifacts, such as distorted faces or unrealistic textures, particularly in complex scenes. It also has safety restrictions that prevent generating certain types of content, which may limit some creative uses. Additionally, since the model is accessed through OpenAI's infrastructure, users are subject to OpenAI's content policy and rate limits, which can affect bulk editing workflows.
GPT-Image-2 is priced per token: $8.00 per million input tokens and $30.00 per million output tokens. Input tokens include the text prompt and any image data encoded as base64 (since images are tokenized). Output tokens are the generated image representation. The total cost for a request depends on the length of the prompt and the resolution of both input and output images. OrcaRouter passes through this pricing with zero markup, meaning the cost is exactly what OpenAI charges. No additional fees are added by the OrcaRouter platform.
No. OrcaRouter explicitly states that it bills GPT-Image-2 at the provider rate with zero markup. This means the price per token is exactly $8.00 input and $30.00 output. There are no monthly subscription fees, base costs, or markup percentages added by OrcaRouter. The only charges are the token costs consumed by OpenAI. Users should ensure they have a valid billing method set up with OrcaRouter to avoid service interruption, but the pricing formula is transparent and predictable.
OpenAI does not publicly offer caching for image generation or editing prompts; each request is processed independently. Therefore, repeating identical prompts with the same input image will typically incur full token costs on each invocation. However, if your application frequently uses the same input image, you might reduce input token usage by storing the image externally and referencing it via a URL (if supported) rather than re-encoding it as base64. OrcaRouter does not provide any additional caching layer that would reduce token consumption for this model.
GPT-Image-2 pricing is set by OpenAI and is among the higher-cost options for image models due to its specialized editing capabilities. Cheaper alternatives, such as Stability AI models available on OrcaRouter, may offer lower per-token rates but may not match the editing precision measured by the LM Arena benchmark. The trade-off is between cost and output quality. For simple edits or low-stakes applications, a less expensive model could be sufficient, while GPT-Image-2 is preferable when high fidelity and prompt compliance are critical.
To use GPT-Image-2 through OrcaRouter, send an HTTP POST request to the OpenAI-compatible endpoint at https://api.orcarouter.ai/v1/images/generations (or a similar endpoint depending on the operation). Set the model parameter to "openai/gpt-image-2". Include a prompt string and optionally an image (as base64 or URL) for editing tasks. OrcaRouter authenticates requests using your API key (typically passed in the Authorization header as "Bearer <key>"). The response will contain generated image data in the format specified by the request, usually as a URL or base64 string.
The API parameters largely follow OpenAI's image generation schema. Key parameters include "model" (set to "openai/gpt-image-2"), "prompt" (the text instruction), "n" (number of images to generate, default 1), "size" (output dimensions like "1024x1024"), "response_format" ("url" or "b64_json"), and "user" (for rate limit tracking). For editing tasks, you may also include "image" (the input image as base64) and "mask" (for inpainting, specifying which areas to modify). Refer to OpenAI's official documentation for the complete list of supported parameters and their constraints.
Migration is straightforward because OrcaRouter provides a fully OpenAI-compatible API. The only changes required are updating the base URL from https://api.openai.com to https://api.orcarouter.ai/v1 and modifying the model string from something like "gpt-image-2" to "openai/gpt-image-2". Your existing code for authentication, request serialization, and response handling should work without modification. No changes to parameter names or data structures are needed. After updating the endpoint and model ID, test with a single request to confirm connectivity and billing behavior.
OrcaRouter uses API key authentication. You must include your OrcaRouter API key in the request header. Rate limits are determined by both OrcaRouter and OpenAI. OrcaRouter may impose limits to prevent abuse, but these are typically generous. OpenAI applies its own rate limits based on tier and billing, which apply regardless of whether you access the model through OrcaRouter or directly. Users should monitor usage via the OrcaRouter dashboard and adjust request pacing accordingly. There is no additional authentication required beyond the API key.
GPT-Image-2 and DALL-E 3 are both image generation models from OpenAI, but they target different use cases. DALL-E 3 is a general-purpose text-to-image model focused on generating creative and photorealistic images from scratch. GPT-Image-2 is optimized for editing existing images, as evidenced by its high LM Arena Image Edit Elo score. While DALL-E 3 can also perform some edits, its strength lies in original generation. GPT-Image-2 tends to produce more accurate modifications to input images, especially when the prompt involves preserving elements of the original composition.
Stability AI models like SD3.5 are open-source image generators that offer lower per-token costs but may require more prompt engineering to achieve similar quality. GPT-Image-2, as a proprietary model, benefits from extensive training data and fine-tuning for editing tasks, reflected in its LM Arena score. The choice between them depends on budget and quality requirements. For high-stakes editing where precision matters, GPT-Image-2 is preferable. For bulk generation or when cost is the primary concern, Stability AI models available on OrcaRouter may be a viable alternative, though you must assess quality differences for your specific application.
Choose a cheaper model when your task is simple image generation without editing requirements, or when the tolerance for imperfect edits is high. For example, generating placeholder images, simple icons, or low-resolution graphics may not require the sophistication of GPT-Image-2. Similarly, if your prompt involves only minor adjustments (e.g., changing brightness or cropping), a less specialized model may suffice. OrcaRouter offers a range of image models with varying price points. Evaluate your specific use case—if the editing task is complex and requires high fidelity, GPT-Image-2 is justified; otherwise, consider cost savings from alternative models.
OpenAI-compatible — keep the SDK you already use
https://api.orcarouter.ai/v1| Input / 1M tokens | $8.00 |
|---|---|
| Output / 1M tokens | $30.00 |
| Cache read / 1M | $1.25 |
| Currency | USD |
Estimate based on list price
Estimate only — actual token counts depend on the provider's tokenizer.
What developers are saying this week
GET /api/public/models/openai/gpt-image-2Open @misc{orcarouter_gpt_image_2,
title = {openai/gpt-image-2 API},
author = {openai},
year = {n.d.},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/openai/gpt-image-2}
}openai. (n.d.). openai/gpt-image-2 API. OrcaRouter. https://www.orcarouter.ai/models/openai/gpt-image-2