Google Gemini 4: Argon Access, Pricing and API (2026)

Google Gemini 4 is available now: the first model of the new generation is called Gemini 4 Argon, and you can use it in Google’s own apps or call it from code through an API. If you searched for the release date, the short answer is that the wait is over. If you came to build something, this guide shows the request, the cost per token and the trade-offs against cheaper models.

Below, we cover what the model is, when it shipped, the three ways to get access, exact pricing on Unicorn API, working code in curl and Python, and the mistakes people make when they switch an existing app over.

What is Google Gemini 4?

Gemini is Google DeepMind’s family of large language models (LLMs): neural networks trained on huge amounts of text, code and other data that generate text in reply to a prompt. The same name is used for Google’s consumer chatbot, the app that was originally called Bard. That double meaning causes a lot of confusion, so it helps to separate them:

• Gemini the app is the chat product you open in a browser or on a phone.
• Gemini the model is the engine underneath, which developers call through an API (an application programming interface, the endpoint your code sends requests to).

Google Gemini 4 is the fourth generation of the model family. The first release in that generation is Gemini 4 Argon. Google positions Argon for demanding, long-running work such as software engineering and enterprise knowledge tasks, where the model has to plan, call tools and keep track of many steps rather than answer a single question.

From a developer’s point of view, what matters is the request interface. On Unicorn API, Argon accepts the standard OpenAI-style chat fields: messages, tools and tool_choice for function calling, response_format for structured JSON output, stream for token-by-token replies, and reasoning_effort to control how much the model “thinks” before answering. If you have written code against any OpenAI-compatible chat API, you already know how to call it.

Is there a Gemini 4 Pro?

Earlier Gemini generations used names like Pro and Flash, so “Gemini 4 Pro” is a natural thing to search for. At the time of writing, the Google Gemini 4 model you can call on Unicorn API is Argon. The catalog lists two ids for it: gemini-4-argon and Gemini 4 Argon OpenAI (gemini-4-argon-openai), both at the same price with the same request fields. Check each model page for how the two variants differ, then pick one id per project and stick with it so your results stay comparable. If Google ships more tiers, they will appear in the model catalog.

Gemini 4 release date: when did it come out?

For months, “when is Gemini 4 coming out” was a rumour topic, complete with prediction-market bets. The timeline is now settled:

• Late September 2026: Google announced Gemini 4 Argon.
• Mid-October 2026: the public rollout began, with Google putting the new model in its paid consumer plans first.
• October 14, 2026: Gemini 4 Argon became available on Unicorn API under the ids above.

So if you are asking when Google Gemini 4 will be released, it already has been. The more useful question now is which access route suits you, because the consumer app and the API are priced and limited very differently.

One note on noisy search results: queries like “gemini slate 4” or “gemini lucky pick 4 numbers” refer to state lottery games, not to Google’s model. If you landed here from one of those, this page will not help with tonight’s draw.

How to get Google Gemini 4: app, Google’s API or a gateway

There are three practical routes, and the right one depends on whether you want to chat or to build.

1. The Gemini app

If you just want to talk to the model, use Google’s Gemini app or website. The newest model sits behind Google’s paid subscription tiers, and usage is subject to the app’s own caps. This is the simplest option for personal use, but you cannot call it from your own code, and a subscription only makes sense if you use it often.

2. Google’s own developer API

Google offers its models directly to developers. That works well if Google is the only provider you will ever use. The catch is that most real products end up mixing models: a cheap fast one for routine calls, a strong one for hard tasks, perhaps an Anthropic or DeepSeek model for comparison. Each direct provider means another account, another key, another bill and another SDK quirk.

3. A gateway such as Unicorn API

A gateway puts many providers behind one endpoint. With Unicorn API you get one API key and one credit balance that covers Google Gemini 4 alongside chat, image, video and audio models from other providers. Switching models means changing a single string in your request. You pay per token, with no separate subscription for each model.

Getting started takes three steps:

1. Create a key on the API keys page.
2. Pick a plan or top up credits on the pricing page.
3. Send a request (code below), or try prompts first in the browser playground with no code at all.

If you work inside Cursor, Claude Code or a similar coding agent, the agents setup lets those tools call the same models over MCP (Model Context Protocol, a standard way for agents to use external tools).

How much does Google Gemini 4 cost through the API?

LLM APIs charge per token. A token is a chunk of text, roughly three-quarters of an English word on average. You pay separately for input tokens (your prompt, system message and any conversation history) and output tokens (the model’s reply). Output is almost always the expensive part.

On Unicorn API, Gemini 4 Argon costs:

• 160 credits per 1 million input tokens
• 800 credits per 1 million output tokens

Credits on monthly plans cost $0.01 each (Starter $25, Creator $50, Studio $100, Pro $200 per month). Top-up credits cost $0.015 each and never expire. In dollar terms:

Billing	Per 1M input tokens	Per 1M output tokens
Monthly plan ($0.01/credit)	$1.60	$8.00
Top-up ($0.015/credit)	$2.40	$12.00

Worked example: a code-review assistant

Say each request sends 2,000 input tokens (a diff plus instructions) and gets back 800 output tokens of review comments.

• Input: 2,000 / 1,000,000 × 160 = 0.32 credits
• Output: 800 / 1,000,000 × 800 = 0.64 credits
• Total: 0.96 credits, just under one cent on a monthly plan

A thousand of those reviews cost 960 credits, about $9.60 on a plan. The Starter plan’s 2,500 credits would cover roughly 2,600 such requests. Notice that the reply cost twice as much as the prompt even though it was less than half the length: that is the 5x output multiplier at work.

The exact cost of each call is debited from the usage the model reports, so you never pay for an estimate. If you want the number before you run anything, the API exposes POST /v1/models/price; the request shape is in the API documentation.

Calling Google Gemini 4 from code

The chat endpoint is OpenAI-compatible, so you can use plain HTTP or any OpenAI SDK pointed at Unicorn API’s base URL.

curl

curl https://api.unicornapi.net/v1/chat/completions \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-4-argon",
    "messages": [
      {"role": "system", "content": "You are a concise senior code reviewer."},
      {"role": "user", "content": "Review this function for bugs:\n\ndef avg(xs):\n    return sum(xs) / len(xs)"}
    ],
    "max_tokens": 600,
    "reasoning_effort": "medium"
  }'

The response contains the reply in choices[0].message.content and a usage block with the input and output token counts, which is what your credit charge is based on.

Python with the OpenAI SDK

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.unicornapi.net/v1",
    api_key=os.environ["UNICORN_API_KEY"],
)

INPUT_CREDITS_PER_M = 160
OUTPUT_CREDITS_PER_M = 800

def ask_gemini4(prompt: str, effort: str = "medium") -> str:
    resp = client.chat.completions.create(
        model="gemini-4-argon",
        messages=[
            {"role": "system", "content": "Answer precisely. Say so when unsure."},
            {"role": "user", "content": prompt},
        ],
        max_tokens=800,
        reasoning_effort=effort,
    )
    usage = resp.usage
    credits = (
        usage.prompt_tokens / 1_000_000 * INPUT_CREDITS_PER_M
        + usage.completion_tokens / 1_000_000 * OUTPUT_CREDITS_PER_M
    )
    print(f"in={usage.prompt_tokens} out={usage.completion_tokens} ~{credits:.3f} credits")
    return resp.choices[0].message.content

if __name__ == "__main__":
    print(ask_gemini4("Explain the difference between a mutex and a semaphore in 5 bullet points."))

The cost line is a local estimate for logging; the billed amount comes from the usage the model reports.

Structured output and tools

For extraction jobs, pass "response_format": {"type": "json_object"} and describe the JSON shape in your system message, so your code can parse the reply without regex. For agent-style work, pass a tools array of function definitions; the model returns tool_calls when it wants your code to run something, you execute it, and you send the result back as a tool message. That loop is where Google Gemini 4’s focus on long, multi-step work pays off.

Set "stream": true if you are building a chat UI, so users see text as it is generated instead of waiting for the whole reply.

Gemini 4 Argon vs cheaper models: when is it worth it?

Google Gemini 4 is a frontier model, and it is priced like one. For many requests a smaller model gives the same answer for a fraction of the cost. Here is how Argon compares with other chat models on Unicorn API, in credits per million tokens:

Model	Input (per 1M)	Output (per 1M)	Notes from the catalog
Gemini 4 Argon	160	800	Google’s Gemini 4 flagship
Wish 1.0	120	480	1M-token context, image input, tool calling, four reasoning levels
DeepSeek V4.1 Flash FP8	28	84	Fast general and coding model, 1M-token context, closer to full precision
DeepSeek V4.1 Flash FP4	12	24	Same model at FP4 precision, the lowest price of the two
Claude Haiku 5.5	12	60	Anthropic’s small model, with cached input pricing

On output tokens, Argon costs about 33x more than DeepSeek V4.1 Flash FP4 and about 13x more than Claude Haiku 5.5. That gap should drive your architecture.

A sensible routing pattern

• Use a cheap model by default for classification, summarising short texts, simple extraction and first drafts.
• Escalate to Gemini 4 Argon for hard reasoning, multi-file code changes, long tool-calling chains and anything where a wrong answer is expensive.
• Compare on your own data. Because every model sits behind the same endpoint, an evaluation script only needs a loop over model ids. Run 50 real prompts through two or three models and read the answers before deciding.

Wish 1.0 is worth knowing about as a middle option: its model behind the id is chosen and updated over time while the id, price and reasoning levels stay fixed. Be aware that the provider serving it may use prompts and replies to improve its models, so keep sensitive data off it.

If you are weighing gateways in general, our OpenRouter alternative guide covers how they differ on pricing and setup.

Common mistakes when switching to Google Gemini 4

Most problems people hit with Google Gemini 4 are not about the model at all. They come from carrying old habits over.

1. Not capping output. Output tokens cost 5x input on Argon. Always set max_tokens. A runaway reply on a frontier model is the most common surprise on a bill.
2. Using maximum reasoning everywhere. Higher reasoning_effort generally means the model spends more tokens thinking before it answers. Start at a lower setting and raise it only for tasks that fail.
3. Resending huge histories. Every message in messages is billed as input on every turn. Trim or summarise old turns in long chats instead of appending forever.
4. Mixing model ids mid-project. Switching between gemini-4-argon and gemini-4-argon-openai halfway through an evaluation makes results hard to compare. Pick one.
5. Trusting rumour posts for specs. Pre-release articles about Gemini 4 Pro, context sizes and benchmark scores often predate the actual launch. Check the model page for what the API really accepts today.
6. Assuming the app and the API behave identically. The Gemini app adds its own system instructions, tools and safety layers. The raw model through an API will not respond word for word the same, so write your own system prompt.
7. Skipping a price check on batch jobs. Before running thousands of requests, price a typical one with POST /v1/models/price and multiply. It takes a minute and prevents nasty surprises.

Is Google Gemini 4 the right choice for your project?

Pick Google Gemini 4 Argon when quality on hard, multi-step work matters more than cost per call: agentic coding, complex document analysis, planning tasks with many tool calls. Pick a cheaper model when the task is simple, high-volume or latency-sensitive. Most production apps end up using both, routing each request to the cheapest model that handles it well.

The quickest way to find out is to try it. Open the playground, run your hardest real prompt through Gemini 4 Argon and one cheaper model side by side, and look at both the answers and the usage numbers. Then wire up the Python snippet above with a key from the keys page, and you have Google Gemini 4 running in your own code with one bill for everything else you call.