DEV Community: Hassann

How to Run DeepSeek V4 Locally ?

Hassann — Fri, 24 Apr 2026 04:22:00 +0000

DeepSeek V4 dropped on April 23, 2026 with MIT-licensed weights on Hugging Face. That single license choice opens up frontier AI for any team wanting to run models on their own hardware. V4-Flash (284B total, 13B active) fits on two H100s at FP8. V4-Pro (1.6T total, 49B active) requires a cluster but matches GPT-5.5 and Claude Opus 4.6 on code and reasoning workloads.

Try Apidog today

This guide walks through local deployment: hardware requirements, quantization, vLLM and SGLang setup, tool-use configuration, and a validation workflow in Apidog to confirm your local server before sending production traffic.

For product overview, see what is DeepSeek V4. For hosted API usage, see how to use the DeepSeek V4 API. For cost details, see DeepSeek V4 API pricing.

TL;DR

V4-Flash: Runs on 2 × H100 80GB at FP8, or 1 × H100 at INT4. Weights ≈ 500GB (FP8).
V4-Pro: Needs 16+ H100s at FP8 for production throughput.
vLLM: Fastest path to OpenAI-compatible server. vllm>=0.9.0 adds V4 support.
SGLang: Alternative for better tool-use and structured-output features.
Quantization: AWQ INT4 or GPTQ INT4 fits V4-Flash on a single 80GB card (~5% quality loss).
Use Apidog to test http://localhost:8000/v1 and reuse your hosted API collections.

Who should self-host

Self-hosting V4 is right for:

Compliance-bound teams: Health, finance, legal, or defense use-cases where data cannot leave the network. MIT-licensed open weights means no usage agreement or cross-border data flows.
Large stable workloads: Above ~200B tokens/month, dedicated hardware beats API costs. Example: V4-Pro API = $1.74/M input + $3.48/M output.
Fine-tuning and research: Base checkpoints are for further pre-training/domain adaptation. MIT license allows redistribution of tuned models.

Not for: Prototypers, teams without GPU ops experience, or workloads < $200/month on the hosted API—operational overhead will outweigh cost savings at small scale.

Hardware requirements

DeepSeek V4 uses FP4 + FP8 mixed precision, so VRAM needs are lower than raw parameter counts suggest.

Variant	Total params	Active params	FP8 VRAM	INT4 VRAM	Minimum cards
V4-Flash	284B	13B	~500GB	~140GB	2 × H100 80GB (FP8) or 1 × H100 (INT4)
V4-Pro	1.6T	49B	~2.4TB	~700GB	16 × H100 80GB (FP8) or 8 × H100 (INT4)

Notes:

MoE memory is total, not active: All experts must fit in VRAM, not just the active subset.
H200 and MI300X: 141GB/192GB cards need fewer GPUs.
Consumer GPUs: Not supported (V4-Flash at INT4 won't run on RTX 5090 24GB).
Apple Silicon: M3/M4 Max with 128GB unified memory can run V4-Flash at high quantization, but only for dev, not deployment.

Step 1: Download the weights

Official Hugging Face repos:

deepseek-ai/DeepSeek-V4-Flash
deepseek-ai/DeepSeek-V4-Pro
Use deepseek-ai/DeepSeek-V4-Flash-Base and DeepSeek-V4-Pro-Base for fine-tuning.

Download example:

pip install -U "huggingface_hub[cli]"
huggingface-cli login

huggingface-cli download deepseek-ai/DeepSeek-V4-Flash \
  --local-dir ./models/deepseek-v4-flash \
  --local-dir-use-symlinks False

Reserve ~500GB disk for V4-Flash, several TBs for V4-Pro.
ModelScope is faster for users in China.

Step 2: Pick a serving engine

Two main options:

vLLM: High throughput, OpenAI-compatible, largest community—recommended for most teams.
SGLang: Better for tool-use, structured output, and long context. Use if you need advanced function calling.

Both support V4 as of their April 2026 releases.

Step 3: Serve V4-Flash with vLLM

pip install "vllm>=0.9.0"

vllm serve deepseek-ai/DeepSeek-V4-Flash \
  --tensor-parallel-size 2 \
  --max-model-len 1048576 \
  --dtype auto \
  --enable-prefix-caching \
  --port 8000

Flags:

--tensor-parallel-size 2: Splits model across 2 H100s. Raise for more GPUs.
--max-model-len 1048576: Full 1M-token context window. Reduce to save VRAM.
--enable-prefix-caching: Enables fast repeated prefixes (mirrors hosted API cache).
--dtype auto: Uses FP8 mixed precision.

Server runs OpenAI-compatible endpoints at http://localhost:8000/v1.

Step 4: Serve V4-Pro with vLLM

Requires a cluster:

vllm serve deepseek-ai/DeepSeek-V4-Pro \
  --tensor-parallel-size 8 \
  --pipeline-parallel-size 2 \
  --max-model-len 524288 \
  --enable-prefix-caching \
  --port 8000

--max-model-len 524288 (512K) fits on a 16-H100 box; increase if VRAM allows.
Use both pipeline and tensor parallelism for multi-node setups.

Step 5: Serve with SGLang (the tool-use alternative)

pip install "sglang[all]>=0.4.0"

python -m sglang.launch_server \
  --model-path deepseek-ai/DeepSeek-V4-Flash \
  --tp 2 \
  --context-length 1048576 \
  --port 30000

OpenAI-compatible endpoint at http://localhost:30000/v1
SGLang's lang DSL enables better function calling and structured output.

Step 6: Quantize for a single-GPU box

INT4 quantization allows V4-Flash on a single 80GB GPU with minimal quality drop.

AWQ (recommended)

pip install autoawq

python -c "
from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

model_path = './models/deepseek-v4-flash'
out_path = './models/deepseek-v4-flash-awq'
model = AutoAWQForCausalLM.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.quantize(tokenizer, quant_config={'w_bit': 4, 'q_group_size': 128})
model.save_quantized(out_path)
tokenizer.save_pretrained(out_path)
"

GPTQ

pip install auto-gptq
# Follow the GPTQ quantization recipe; similar pattern to AWQ.

Serve quantized checkpoints with vLLM using --quantization awq or --quantization gptq.

Step 7: Test with Apidog

Always validate your local server before sending production traffic.

Download Apidog.
Create a collection targeting http://localhost:8000/v1/chat/completions.
Paste in your standard test prompt (same as hosted API).
Run a 500K-token context test to confirm KV cache stability.
Run a tool-calling flow end-to-end before connecting agent loops.

Your hosted DeepSeek V4 API collections work locally—just change the base URL.

Observability and monitoring

Track these from day one:

Tokens per second: Both prompt and generation. vLLM exposes /metrics in Prometheus format.
GPU utilization: Use nvidia-smi or DCGM. Sustained <70% means batch size is likely too small.
KV cache hit rate: With --enable-prefix-caching, vLLM reports this. Falling rates signal prompt churn.
Request latency (p50/p95/p99): Use tracing. High p99 with stable p50 means some requests are stalling the queue.

Send all four to Grafana or your existing observability stack.

Fine-tuning V4 Base checkpoints

Base checkpoints are for continued pre-training and SFT. Standard SFT (with LoRA):

pip install "torch>=2.6" transformers accelerate peft trl

# Standard SFT with LoRA on V4-Flash-Base
python -m trl sft \
  --model_name_or_path deepseek-ai/DeepSeek-V4-Flash-Base \
  --dataset_name your-org/your-sft-set \
  --output_dir ./models/v4-flash-custom \
  --per_device_train_batch_size 1 \
  --gradient_accumulation_steps 16 \
  --learning_rate 2e-5 \
  --bf16 true \
  --use_peft true \
  --lora_r 64 \
  --lora_alpha 128

Full-parameter tuning on V4-Pro is for research labs. LoRA adapters on V4-Flash-Base provide substantial quality gain for practical compute.

Common pitfalls

OOM at startup: Usually --max-model-len is too high or --tensor-parallel-size too low. Lower context or increase parallelism.
Slow first request: vLLM compiles kernels lazily. Warm up with a dummy request.
Tool-use parsing errors: DeepSeek encoding differs from OpenAI's. Use SDK versions with explicit V4 support.
FP8 errors on old GPUs: A100s lack FP8 support. Use BF16 and expect 2x VRAM needs.

When self-hosting pays off

Break-even vs. hosted DeepSeek V4 pricing:

V4-Flash at 200B input + 20B output/month: ~$33.6K on API. 8 × H100 box rents ≈ $20K/month. Self-hosting saves ~40%.
V4-Pro at 500B input + 50B output/month: ~$1.04M on API. 16 × H100 cluster rents ≈ $35K/month. Self-hosting saves >95%.

Break-even for V4-Flash: ≈ 100B tokens/month. Below that, hosted API is cheaper and simpler.

FAQ

Can I run V4-Flash on a single A100?

Heavy quantization and reduced context will run (INT4 on 80GB A100 = 5–15 tok/s), but H100 is much faster.

Does V4 support LoRA fine-tuning?

Yes. Use Base checkpoints with TRL or Axolotl pipelines. MoE routing doesn't impact LoRA.

Is the local server OpenAI-compatible?

Yes. Both vLLM and SGLang expose /v1/chat/completions and /v1/completions with OpenAI request shape. The hosted API guide applies to localhost.

How do I enable thinking mode locally?

Pass thinking_mode: "thinking" or "thinking_max" in the request body. vLLM and SGLang forward the flag.

Can I stream from a local V4 server?

Yes. Set stream: true as you would for OpenAI or hosted DeepSeek API.

Cheapest way to experiment before buying hardware?

Rent a single H100 on RunPod or Lambda, run V4-Flash at INT4, and benchmark with your prompts. $10–$30 is enough for a real-world throughput check.

DeepSeek V4 API Pricing

Hassann — Fri, 24 Apr 2026 04:19:13 +0000

DeepSeek released V4 pricing on April 23, 2026, resetting expectations for frontier AI costs. V4-Flash starts at $0.14 per million input tokens and $0.28 per million output tokens. V4-Pro is priced at $1.74 input and $3.48 output per million tokens. Both support a 1M-token context window and up to 384K output tokens, with a cache-hit discount that cuts input costs by 80–90% on repeated prompts.

Try Apidog today

This guide covers the full rate card, how context caching affects real per-call costs, a comparison with GPT-5.5 and Claude Opus, and four actionable methods to keep your spend predictable in Apidog.

For additional details, see what is DeepSeek V4, the DeepSeek V4 API walkthrough, and how to use DeepSeek V4 for free.

TL;DR

V4-Flash: $0.14 / M input (cache miss), $0.028 / M input (cache hit), $0.28 / M output
V4-Pro: $1.74 / M input (cache miss), $0.145 / M input (cache hit), $3.48 / M output
Context window: 1M tokens input, 384K tokens output on both
Cache-hit discount: ~80% off Flash, ~92% off Pro on repeated prefixes
deepseek-chat and deepseek-reasoner deprecated July 24, 2026; billing maps to V4-Flash
At cache-miss rates, V4-Pro is ~2.9x cheaper than GPT-5.5 on input and ~8.6x cheaper on output

The Full Rate Card

Model	Input (cache miss)	Input (cache hit)	Output	Context
`deepseek-v4-flash`	$0.14 / M	$0.028 / M	$0.28 / M	1M / 384K
`deepseek-v4-pro`	$1.74 / M	$0.145 / M	$3.48 / M	1M / 384K
`deepseek-chat` (deprecated)	maps to V4-Flash non-thinking	—	—	—
`deepseek-reasoner` (deprecated)	maps to V4-Flash thinking	—	—	—

Key implementation details:

Pricing is set by model ID—thinking/non-thinking mode only affects how many tokens you consume, not the rate.
Cache-hit pricing is automatic—any repeated prefix ≥1,024 tokens (byte-for-byte match) within the same account gets discounted input pricing. No setup required.
Old model IDs (deepseek-chat, deepseek-reasoner) are now V4-Flash aliases. If you haven’t migrated, you’re already billed at V4-Flash rates. The deprecation deadline is July 24, 2026.

Context Caching Explained

Context caching is the biggest lever to reduce DeepSeek V4 costs. Any repeated content across calls—such as long system prompts, agent schemas, or RAG context—is billed at a heavily discounted input rate after the first call.

Example: Agent with Static System Prompt

Suppose you run an agent with a 20,000-token system prompt and 100 user questions (200 tokens each).

Without caching:

Input: 100 × 20,200 × $1.74 / M = $3.52
Output: 100 × 500 × $3.48 / M = $0.17
Total: $3.69

With caching (1 miss, 99 hits):

First input: 20,200 × $1.74 / M = $0.035
99 cache-hit prefixes: 99 × 20,000 × $0.145 / M = $0.287
99 user turns: 99 × 200 × $1.74 / M = $0.034
Output: 100 × 500 × $3.48 / M = $0.174
Total: $0.53 (over 7x cheaper)

On V4-Flash, the effect is even more pronounced due to the already low base rate.

Comparing DeepSeek V4 to GPT-5.5 and Claude

Model	Input (std)	Input (cached)	Output	Context
DeepSeek V4-Flash	$0.14 / M	$0.028 / M	$0.28 / M	1M
DeepSeek V4-Pro	$1.74 / M	$0.145 / M	$3.48 / M	1M
GPT-5.5	$5 / M	$1.25 / M	$30 / M	1M
GPT-5.5 Pro	$30 / M	—	$180 / M	1M
Claude Opus 4.6	$15 / M	$1.50 / M	$75 / M	200K

Takeaways:

V4-Pro is ~8.6x cheaper than GPT-5.5 and ~21x cheaper than Claude Opus 4.6 on output tokens.
Cached input: V4-Pro is ~10x cheaper than both GPT-5.5 and Claude.
Benchmarking: V4-Pro matches or beats GPT-5.5 on LiveCodeBench (93.5 vs top tier) and Codeforces (3206 vs 3168). For full benchmarks, see what is DeepSeek V4.

Caveats: Claude outperforms V4-Pro on long-context retrieval, and Gemini 3.1 Pro leads on MMLU-Pro. If your workload depends on long-context retrieval, weigh quality vs. price savings.

Cost Modeling for Common Workloads

Here’s what typical workloads cost on V4-Pro (cache-miss baseline):

1. Agentic Coding Loop (50K context, 2K output, 20 calls)

Input: 50,000 × 20 × $1.74 / M = $1.74
Output: 2,000 × 20 × $3.48 / M = $0.14
Per-task cost: ~$1.88

GPT-5.5: ~$6.20 per task.

2. Long-Document Q&A (500K context, 1K output)

Input: 500,000 × $1.74 / M = $0.87
Output: 1,000 × $3.48 / M = $0.003
Per-call cost: ~$0.87

GPT-5.5: ~$2.53 per call.

3. High-Volume Classification (2K context, 200 output, 10,000 calls)

Use V4-Flash; V4-Pro is overkill.

Input: 2,000 × 10,000 × $0.14 / M = $2.80
Output: 200 × 10,000 × $0.28 / M = $0.56
Run cost: ~$3.36

GPT-5.5: ~$110 per run.

4. Repeated-Prompt Chatbot (10K system, 500 user, 1K output, 1,000 sessions)

First input: 10,500 × $1.74 / M = $0.018
Cache-hit input: 999 × 10,000 × $0.145 / M = $1.45
Cache-miss user: 999 × 500 × $1.74 / M = $0.87
Output: 1,000 × 1,000 × $3.48 / M = $3.48
Session run cost: ~$5.82

GPT-5.5 (with caching): ~$26.35.

Hidden Costs to Watch

Be aware of these cost traps:

Thinking-mode token inflation: thinking_max burns 3–10x more output tokens. Only use Think Max for critical tasks.
Silent context growth: Agent loops that feed entire conversations back into each turn can balloon costs. Truncate or summarize aggressively.
Retry storms: Uncapped retries (e.g., on every HTTP 500) can quickly double your bill. Implement exponential backoff and set a hard retry cap.
Development churn: Iterating with raw curl replays the full context each time. Use Apidog for variable substitution and to avoid unnecessary prompt replays.

Track Cost in Apidog

Optimize workflow and avoid surprises:

Download Apidog and store your DEEPSEEK_API_KEY as a secret per environment.
Save a POST request to https://api.deepseek.com/v1/chat/completions.
In the response panel, pin usage.prompt_tokens, usage.completion_tokens, and usage.reasoning_tokens—you’ll see cost metrics with every call.
Parameterize model and thinking_mode so you can A/B V4-Flash vs V4-Pro, and Non-Think vs Think Max, without duplicating requests.
Mirror the collection for GPT-5.5 using the GPT-5.5 API guide. One window, both providers, full cost transparency.

This setup catches ~80% of surprises that show up on invoices.

Four Rules to Keep Spend Predictable

Default to V4-Flash. Use V4-Pro only if a measurable quality gap impacts revenue.
Default to Non-Think. Escalate to Think High as needed; reserve Think Max for correctness-critical work.
Cap max_tokens. The 384K output ceiling is a safety net, not a target. Production answers usually fit in 2K.
Ship usage telemetry. Log prompt_tokens, completion_tokens, and reasoning_tokens on every call. Alert on reasoning-token spikes—they often signal prompt drift into Think Max.

FAQ

Is there a free tier?

No usage-free API tier, but new accounts may get a trial credit. For zero-cost options, see how to use DeepSeek V4 for free.

How does cache-hit pricing work?

Prefixes ≥1,024 tokens that repeat across requests in the same account are billed at the cache-hit rate. First call is full rate; subsequent identical-prefix calls are discounted. Caching is automatic.

Do thinking modes cost more?

Per-token rates are unchanged. Thinking modes generate more tokens (reasoning traces). Monitor reasoning_tokens in the usage object to assess real cost.

Is pricing stable?

DeepSeek updates pricing periodically. V3.2 rates lasted most of 2025; V4 pricing has no published end-date. Always check the live pricing page before budgeting.

Are V4-Pro and V4-Flash output rates the same?

No. V4-Pro output is $3.48 / M; V4-Flash is $0.28 / M. The 12.4x difference is the main reason to default to V4-Flash.

Does the Anthropic-format endpoint change pricing?

No. https://api.deepseek.com/anthropic uses the same pricing as the OpenAI-format endpoint. Format does not affect cost.

How to Use DeepSeek V4 for Free ?

Hassann — Fri, 24 Apr 2026 04:16:30 +0000

DeepSeek V4 launched on April 23, 2026, with real free access options. The official web chat runs V4-Pro—no credit card needed—and the weights are MIT-licensed and downloadable. Aggregators like OpenRouter and Chutes enable free tiers within days of a DeepSeek launch. With these methods, you can run substantial V4 workloads for free before considering paid plans.

Try Apidog today

This guide outlines all verified no-cost paths, how they fit different use cases, and how to set up a production-ready collection in Apidog for a smooth transition to paid billing as your needs grow.

For a product overview, see what is DeepSeek V4. For API details, see how to use the DeepSeek V4 API.

TL;DR

chat.deepseek.com — Free web chat on V4-Pro with Think High and Think Max toggles. No card needed. Available now.
Hugging Face weights + your own GPU — MIT license. V4-Flash runs on 2–4 H100s; V4-Pro requires a cluster.
OpenRouter and Chutes free tiers — Third-party gateways typically open free quota on DeepSeek models within a week of launch.
Hugging Face Inference Providers — Shared, rate-limited endpoint for early experimentation with V4.
Kaggle, Colab, and RunPod trial credits — Free compute for one-off self-hosting tests.
All free paths have usage caps. For production workloads, switch to paid billing before hitting limits.

Path 1: chat.deepseek.com (the default free path)

The quickest, most reliable free option is the official chat interface. V4-Pro is the default model; use the top toggle to switch between Non-Think, Think High, and Think Max reasoning modes.

Setup

Go to chat.deepseek.com.
Sign in with email, Google, or WeChat.
Ensure the active model is V4-Pro.
Start chatting.

What you get

Full 1M-token context window.
File upload (PDFs, images, code bundles).
On-demand web search.
All three reasoning modes, including Think Max.
Conversation history and folder organization.

Usage caps

There’s no published hard daily message cap; free usage is soft-throttled under load. Heavy use may slow responses or queue requests, but hard blocks are rare. If you see persistent rate limits, slow down or switch to the API.

Best for: Testing prompts, reviewing large codebases or documents, running Think Max on complex inputs.

Not for: Automation or reproducible workflows.

Path 2: Self-host V4-Flash on your own GPU

V4-Flash is MIT-licensed and practical for self-hosting. At 284B total, 13B active, a multi-H100 machine runs it in FP8; with INT4 quantization, it fits on a single 80GB card.

Note: The main cost is hardware. If you have GPUs, this is the most robust free path.

Pull the weights

pip install -U "huggingface_hub[cli]"
huggingface-cli login
huggingface-cli download deepseek-ai/DeepSeek-V4-Flash \
  --local-dir ./models/deepseek-v4-flash

Reserve about 500GB disk for FP8 weights.

Serve with vLLM

pip install "vllm>=0.9.0"

vllm serve deepseek-ai/DeepSeek-V4-Flash \
  --tensor-parallel-size 4 \
  --max-model-len 1048576 \
  --dtype auto \
  --port 8000

Once running, use any OpenAI-compatible client with http://localhost:8000/v1. The API shape matches the paid DeepSeek API; Apidog can treat this as a new base URL with your saved collections.

Hardware requirements

Variant	Minimum cards (FP8)	Minimum cards (INT4)	Realistic throughput
V4-Flash	2 × H100 80GB	1 × H100 80GB	50 to 150 tok/s
V4-Pro	16 × H100 80GB	8 × H100 80GB	cluster-dependent

If you don’t own GPU capacity, paid APIs are cheaper than renting. Self-hosting suits teams with existing hardware or strict compliance needs.

Path 3: OpenRouter free tier

OpenRouter aggregates open and closed models behind a single API. Free tiers are typically available for new DeepSeek releases (V3, V3.1, V3.2).

Setup

Sign up at openrouter.ai.
Create an API key.
Check the model catalog for deepseek/deepseek-v4-pro or deepseek/deepseek-v4-flash; free variants are usually suffixed with :free.
Use the OpenAI-compatible SDK:

from openai import OpenAI

client = OpenAI(
    api_key=OPENROUTER_KEY,
    base_url="https://openrouter.ai/api/v1",
)

response = client.chat.completions.create(
    model="deepseek/deepseek-v4-flash:free",
    messages=[{"role": "user", "content": "Write a Python CLI for semver bumping."}],
)

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

Usage caps

OpenRouter free tiers typically allow a few hundred requests per day per key and lower priority under load. Good for prototyping, not for production.

Path 4: Hugging Face Inference Providers

Hugging Face offers hosted inference endpoints for V4 checkpoints soon after release. These are rate-limited and may have variable latency, but are free to use.

from huggingface_hub import InferenceClient

client = InferenceClient(model="deepseek-ai/DeepSeek-V4-Flash")

response = client.chat_completion(
    messages=[{"role": "user", "content": "Summarize the V4 technical report in 5 bullets."}],
    max_tokens=512,
)

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

HF tokens are free. For heavier use, a Pro account offers higher limits, still at a lower cost than the official API.

Path 5: Trial credits on Colab, Kaggle, RunPod, and Lambda

Major GPU-rental providers offer trial credits for short-term use.

Google Colab: Free T4 is too small; Colab Pro+ gives 500 units/month—enough for V4-Flash experiments on A100.
Kaggle: Free weekly T4/P100 hours; usually too small for V4-Pro but can handle quantized V4-Flash.
RunPod: $10 trial covers a few hours on H100—enough for vLLM benchmarking.
Lambda: Occasionally offers free hours on H100/H200; check signup for current promos.

These options support bounded experiments, not ongoing free usage.

Build a provider-agnostic Apidog collection

You can test the same prompt across all providers without duplicating work. Recommended workflow:

Download Apidog.
Create a collection with four environments: chat (placeholder), deepseek (https://api.deepseek.com/v1), openrouter (https://openrouter.ai/api/v1), self-hosted (http://localhost:8000/v1).
Save a POST request to {{BASE_URL}}/chat/completions.
Store each provider’s key as a secret variable for consistent requests across environments.
Switch environments to A/B test prompts on every backend.

This matches the pattern from the GPT-5.5 free-tier collection: one tool, every provider, no duplicate setup.

Which free path should you pick?

Use these heuristics:

Want a quick opinion? Use chat.deepseek.com.
Prototyping a product? Use OpenRouter’s free tier until capped, then switch to paid DeepSeek.
Have GPUs & compliance needs? Self-host V4-Flash with vLLM.
Need long-term free usage? No sustainable option—combine chat.deepseek.com for manual work and paid API for automation.

When to move off free

Move to paid billing if:

Rate-limited more than once daily—your workload justifies a budget.
Need SLAs—free tiers don’t provide them; the official API does.
Need logging, auditing, or compliance—paid API delivers billing records; most free tiers don’t.

When these apply, use the official API. Minimum top-up is $2, and per-token pricing is among the lowest.

FAQ

Is chat.deepseek.com really free?

Yes. No credit card or trial period. Service is soft-throttled, not paywalled.

Do I need a Hugging Face account to download weights?

Not strictly, but a logged-in account gets better download rate limits.

Which free path runs real V4-Pro?

chat.deepseek.com provides full V4-Pro. OpenRouter’s free tier is usually V4-Flash. For V4-Pro output without paying, use the web chat.

Can I put a free tier behind a product?

No. Free tiers can rate-limit, change terms, or disappear. For customer-facing products, use the paid API or self-host.

Is self-hosting actually free?

License is free; hardware is not. If you own GPUs, marginal cost is electricity. Renting usually costs more than the paid API.

Will there be an Apidog free tier for testing?

Apidog is free for API design and testing; credits are only needed for paid APIs. You can use a free Apidog workspace with chat.deepseek.com or OpenRouter for a fully free workflow.

How to Use DeepSeek V4: Web Chat, API, and Self-Hosted Paths

Hassann — Fri, 24 Apr 2026 04:11:47 +0000

DeepSeek V4 launched on April 23, 2026, offering four checkpoints, a live API, and open weights (MIT license) on Hugging Face. You can access it instantly, make production API calls, or self-host for on-premise deployment. This guide covers all three options with actionable steps, tradeoffs, and a production-ready prompt workflow.

Try Apidog today

If you need an overview, start with what is DeepSeek V4. For API integration, read the DeepSeek V4 API guide. For zero-cost usage, see how to use DeepSeek V4 for free. When you’re ready to test, download Apidog to pre-build your API collection.

TL;DR

Fastest: chat.deepseek.com — Free chat UI, V4-Pro by default, three reasoning modes.
Production: Use https://api.deepseek.com/v1/chat/completions with deepseek-v4-pro or deepseek-v4-flash.
Self-hosted: Pull weights from Hugging Face, run the /inference code.
Choose Non-Think for fast routing/classification, Think High for code/analysis, Think Max for accuracy-critical tasks.
Recommended sampling: temperature=1.0, top_p=1.0.
Use Apidog as your API client. The OpenAI-compatible format allows easy replay across DeepSeek, OpenAI, and Anthropic.

Pick the right path for your workload

Choose the integration that fits your needs:

Path	Cost	Setup time	Best for
chat.deepseek.com	Free	30 seconds	Quick tests, ad-hoc work
DeepSeek API	Per-token billing	5 minutes	Production, agents, batch jobs
Self-hosted V4-Flash	Hardware cost only	A few hours	On-prem compliance, offline inference
Self-hosted V4-Pro	Cluster cost only	A day	Research, custom fine-tunes
OpenRouter / aggregator	Per-token billing	2 minutes	Multi-provider fallback

Path 1: Use V4 in the web chat

For the quickest evaluation, use the official chat interface:

Go to chat.deepseek.com.
Sign in (email, Google, or WeChat).
V4-Pro is the default. Toggle between Non-Think, Think High, and Think Max at the top.
Enter your prompt and send.

Web chat supports file uploads, web search, and full 1M-token context. Rate limits are per account; heavy use may slow responses.

Best for: error trace diagnosis, summarizing large PDFs, quick benchmark tests. Not suitable for automation or repeatable workflows.

Path 2: Use the DeepSeek API

The API is OpenAI-compatible and ready for production. Model IDs (deepseek-v4-pro, deepseek-v4-flash) are stable.

Get an API key

Sign up at platform.deepseek.com.
Add a payment method (top-ups from $2).
Create an API key under API Keys and copy it (you won’t see it again).

Set the key in your environment:

export DEEPSEEK_API_KEY="sk-..."

Minimum viable request (curl)

curl https://api.deepseek.com/v1/chat/completions \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro",
    "messages": [
      {"role": "user", "content": "Refactor this Python function to async. Reply with code only."}
    ],
    "thinking_mode": "thinking"
  }'

Switch deepseek-v4-pro to deepseek-v4-flash for lower cost. Use non-thinking mode for faster outputs.

Python client (OpenAI SDK)

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com/v1",
)

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "system", "content": "You are a concise senior engineer."},
        {"role": "user", "content": "Explain the CSA+HCA hybrid attention stack."},
    ],
    extra_body={"thinking_mode": "thinking_max"},
    temperature=1.0,
    top_p=1.0,
)

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

Any OpenAI-compatible library (LangChain, LlamaIndex, DSPy) works by just changing the base URL.

Node client (OpenAI SDK)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.DEEPSEEK_API_KEY,
  baseURL: "https://api.deepseek.com/v1",
});

const response = await client.chat.completions.create({
  model: "deepseek-v4-flash",
  messages: [{ role: "user", content: "Write a fizzbuzz in Rust." }],
  temperature: 1.0,
  top_p: 1.0,
});

console.log(response.choices[0].message.content);

See the DeepSeek V4 API guide for endpoint details, parameters, and error handling.

Path 3: Iterate with Apidog

For repeated API calls, Apidog streamlines your workflow and helps manage credits.

Download Apidog for your OS: Mac, Windows, Linux.
Create a new API project. Add a POST request to https://api.deepseek.com/v1/chat/completions.
Add Authorization: Bearer {{DEEPSEEK_API_KEY}} as a header. Store the key in environment variables.
Paste your JSON request body and save. Replay or tweak with a click.
Use the response viewer to compare outputs (e.g., Non-Think vs Think Max modes).

You can store multiple requests (OpenAI, Claude, DeepSeek) side by side for easy A/B testing and billing visibility. To migrate, simply change the base URL in your existing GPT-5.5 API collection.

Path 4: Self-host V4-Flash

The MIT license allows full self-hosting. This is ideal for compliance, air-gapped environments, or custom economics.

Hardware requirements

V4-Flash (13B active, 284B total): 2–4 H100/H200/MI300X GPUs (FP8). Quantized INT4 fits on a single 80GB card for small batches.
V4-Pro (49B active, 1.6T total): Requires 16–32 H100s for production inference.

Download model weights

# Install Hugging Face CLI
pip install -U "huggingface_hub[cli]"

# (Optional) Log in to reduce rate limits
huggingface-cli login

# Download V4-Flash weights
huggingface-cli download deepseek-ai/DeepSeek-V4-Flash \
  --local-dir ./models/deepseek-v4-flash \
  --local-dir-use-symlinks False

V4-Flash is ~500GB at FP8; V4-Pro is several TB.

Run inference (vLLM)

pip install "vllm>=0.9.0"

vllm serve deepseek-ai/DeepSeek-V4-Flash \
  --tensor-parallel-size 4 \
  --max-model-len 1048576 \
  --dtype auto

Once running, point OpenAI-compatible clients to http://localhost:8000/v1. You can use the same Apidog collection with the new base URL.

Prompting V4 effectively

DeepSeek V4’s prompt handling differs from GPT-5.5 or Claude. For best results:

Set thinking_mode explicitly for each task.
Use system prompts for persona only, not task instructions. Place the main task in the user message.
For code tasks, provide a test harness or failing test case to increase solution accuracy.

For long-context prompts, keep the most relevant info at the beginning and end. V4’s attention is optimized, but recency and primacy effects remain.

Cost control

To prevent overspending, apply these safeguards:

Default to V4-Flash. Use V4-Pro only for proven quality needs.
Default to Non-Think. Use Think High or Think Max as required.
Set max_tokens. The 1M context is a limit, not a target. Most responses fit in 2,000 tokens.

In Apidog, use environment variables for DEEPSEEK_API_KEY to separate test and production billing. Apidog also records token counts per response to help spot runaway prompts.

Migrating from DeepSeek V3 or other models

From deepseek-chat / deepseek-reasoner: Change model ID to deepseek-v4-pro or deepseek-v4-flash. Old IDs deprecate July 24, 2026.
From OpenAI GPT-5.x: Change base URL to https://api.deepseek.com/v1 and model ID. Request shape is otherwise unchanged. See the GPT-5.5 API guide for reference.
From Anthropic Claude: Use https://api.deepseek.com/anthropic for Anthropic message format, or convert to OpenAI format for main endpoint.

FAQ

Do I need a paid account? Web chat is free. API access requires a minimum $2 top-up. See how to use DeepSeek V4 for free for no-cost options.

Which variant should I use? Start with V4-Flash in Non-Think mode, measure quality, and only upgrade if necessary.

Can I run V4 on a MacBook? V4-Flash runs on M3/M4 Max with 128GB RAM (INT4, slow). V4-Pro requires much more. For laptops, use the API or web chat.

Does V4 support function calling? Yes. The OpenAI-compatible endpoint accepts the standard tools array. Responses return tool_calls. Anthropic endpoint uses its native schema.

How do I stream responses? Set stream: true in your request body. Responses are OpenAI-compatible SSE streams; any compatible library works out of the box.

Are there rate limits? Hosted API has per-tier limits (api-docs.deepseek.com). Self-hosted: limited only by hardware.

What Is DeepSeek V4?

Hassann — Fri, 24 Apr 2026 04:09:03 +0000

DeepSeek V4: The Dev-Focused Guide to the 1.6T Open Model

DeepSeek released V4 on April 23, 2026—a major Mixture-of-Experts (MoE) family upgrade. Four checkpoints dropped, led by DeepSeek-V4-Pro (1.6T parameters, MIT license, 1M-token context). V4-Flash is the smaller sibling (284B parameters, same context, open weights). Benchmarks put V4-Pro ahead of Claude Opus 4.6 for code, close behind GPT-5.4 xHigh on MMLU-Pro.

If you’re choosing between Claude, GPT-5.5, Qwen, or DeepSeek V4, this guide covers what’s new, architectural changes from V3.2, implementation details, and how to run it right now.

Try Apidog today

For hands-on integration, see the DeepSeek V4 API guide, free-access guide, and the full usage walkthrough. The API mirrors OpenAI’s request shape, so you can pre-build collections in Apidog before you have an API key.

TL;DR

DeepSeek V4: Mixture-of-Experts, released April 23, 2026, MIT license.
Four checkpoints: V4-Pro, V4-Pro-Base, V4-Flash, V4-Flash-Base.
V4-Pro: 1.6T total, 49B active params; V4-Flash: 284B total, 13B active.
Both: 1M-token context, three reasoning modes (Non-Think, Think High, Think Max).
Headline scores (Pro): LiveCodeBench 93.5, Codeforces 3206, MMLU-Pro 87.5.
API live at api.deepseek.com (model IDs: deepseek-v4-pro, deepseek-v4-flash). Weights on Hugging Face and ModelScope.

What DeepSeek V4 Actually Is

V4 succeeds the V3 and V3.2 lines, keeping the MoE architecture but changing model shape. V4-Pro activates 49B of 1.6T parameters per token—so inference is closer to a 50B dense model. Full technical details: DeepSeek V4 model card.

Checkpoints

DeepSeek-V4-Pro: 1.6T total, 49B active, 1M context. This is the main production API model.
DeepSeek-V4-Pro-Base: Pre-trained only, for custom fine-tunes.
DeepSeek-V4-Flash: 284B total, 13B active, 1M context. For latency/local deploy on 2–3 H100s.
DeepSeek-V4-Flash-Base: Pre-trained, for research/fine-tune.

All checkpoints: MIT license. You can download, mirror, fine-tune, and deploy with no license fee.

What Changed from V3.2

V4 improves on code and reasoning benchmarks by rewriting the attention stack and training pipeline.

Capability	V3.2	V4-Pro
Total parameters	685B	1.6T
Active parameters	37B	49B
Context window	128K	1M
Inference FLOPs (1M context)	baseline	27% of V3.2
KV cache (1M context)	baseline	10% of V3.2
Precision	FP8	FP4 + FP8 mixed
License	DeepSeek License	MIT
Reasoning modes	single	three

Key drivers:

Hybrid attention stack: Combines Compressed Sparse Attention and Heavily Compressed Attention for efficient, long-context inference, shrinking KV cache to 10% and FLOPs to 27% of V3.2 at 1M tokens.
Manifold-Constrained Hyper-Connections: Stabilizes gradients for deep stacking.
Muon optimizer: Faster convergence and better handling of large gradient norms.

Training corpus: 32T+ tokens; post-training: two-stage pipeline (domain experts, then on-policy distillation).

Benchmarks That Matter

V4-Pro is top-tier on code and knowledge tasks, with some gaps in long-context retrieval.

V4-Flash delivers:

MMLU-Pro: 86.2
GPQA Diamond: 88.1
LiveCodeBench: 91.6
Codeforces: 3052
SWE Verified: 79.0

See DeepSeek V4-Flash card for full tables.

Summary:

V4-Pro leads on code and factual recall, but Gemini 3.1 Pro leads MMLU-Pro; Claude Opus is stronger for 1M-token retrieval.
For coding, agentic tasks, and complex analysis, V4-Pro is competitive. For “needle-in-a-haystack” retrieval, Claude is better.

Three Reasoning Modes

Each V4 checkpoint exposes three modes, controlled by the thinking_mode parameter (API) or a script flag:

Non-Think: Fast, no reasoning tokens. Use for classification, routing, or summaries.
Think High: Default for complex tasks. The model generates reasoning traces and plans actions.
Think Max: Longer reasoning, self-critique, recommended for 384K+ context. Highest accuracy, highest token cost.

Sampling settings:

temperature=1.0, top_p=1.0 across all modes.

Architecture in Plain English

Three architectural choices drive V4's efficiency:

Hybrid attention: Most layers use Compressed Sparse Attention (full attention on "important" tokens, compression elsewhere); some use Heavily Compressed Attention (close to linear cost). This enables efficient scaling to 1M tokens.
Manifold-Constrained Hyper-Connections: Residuals are constrained to stable manifolds, enabling deeper stacking without gradient instability.
Muon optimizer: Replaces AdamW, better for MoE gradients and faster convergence.

Availability Today

All four checkpoints and the API are live as of April 24, 2026.

Surface	Access
chat.deepseek.com	Free web chat, V4-Pro default, login required
DeepSeek API	Live at `api.deepseek.com`; model IDs `deepseek-v4-pro`, `deepseek-v4-flash`
Hugging Face weights	V4-Pro, V4-Flash, both MIT
ModelScope	Mirrored weights for users in China
OpenRouter and aggregators	Expected within days; typical DeepSeek launch pattern
`deepseek-chat` / `deepseek-reasoner`	Deprecated July 24, 2026

Migration note:

If using deepseek-chat in production, migrate to deepseek-v4-pro or deepseek-v4-flash within three months.

How It Compares to GPT-5.5 and Claude

Cost: V4-Pro/Flash are open weights (MIT). GPT-5.5 and Claude Opus are closed. Self-hosting V4 is cheaper at scale.
Coding: V4-Pro (LiveCodeBench 93.5, Codeforces 3206) beats GPT-5.5 and Claude on code.
Knowledge: Gemini 3.1 Pro leads MMLU-Pro. V4-Pro/GPT-5.5 tie at 87.5.
Long-context retrieval: Claude Opus leads MRCR 1M. For deep retrieval, Claude is safer.
License: MIT lets you embed V4-Pro in your product freely.

What to Build With It

Good fits for DeepSeek V4:

Agentic coding loops: Multi-file debugging, repo refactoring, test fixes. Use with Apidog for API inspection and prompt tuning.
Long-document reasoning: 1M tokens handles large repos, contracts, research corpora. Use Think High mode.
Self-hosted AI products: V4-Flash is the first open-weights model with frontier quality for on-prem.
Research/fine-tuning: Base checkpoints let you train specialist models with your own data.

Not ideal for: high-volume classification, embedding retrieval, or short-prompt chat (older DeepSeek models are cheaper for those).

Pricing in One Line

As of writing, V4 API pricing is not final. V3.2 was ~$0.28/million input tokens, $0.42/million output tokens. Expect V4-Flash at a similar rate, V4-Pro at a premium. Closed competitors charge $5–$15/million input tokens. For updates, see the DeepSeek pricing page.

How to Test V4 Today

Three ways to get started (fastest first):

Web chat: Go to chat.deepseek.com, sign in. V4-Pro is default. Toggle to Think High in UI. Free, no card.
API: Get an API key, point your client at https://api.deepseek.com, set "model": "deepseek-v4-pro". Request shape is OpenAI-compatible—swap the base URL in any OpenAI client. Full guide: DeepSeek V4 API guide.
Local weights: Download from Hugging Face or ModelScope. V4-Flash runs on 2–4 H100s, V4-Pro requires a cluster. Inference code is in /inference of the repo.

For a prompt-iteration workflow using Apidog, see how to use DeepSeek V4. For zero-cost usage, see how to use DeepSeek V4 for free. Download Apidog and pre-build your collection; the OpenAI-compatible format supports DeepSeek, OpenAI, and other APIs with one request.

FAQ

Is DeepSeek V4 really open source?

Yes. All checkpoints are MIT licensed for commercial use, modification, and redistribution.

Do I need a GPU cluster to run V4-Flash?

For full precision: 2–4 H100s/H200s for V4-Flash. Less if quantized. V4-Pro needs a full cluster. To test without hardware, use the API or chat.deepseek.com.

When does V4 hit the DeepSeek API?

Live as of April 23, 2026. Model IDs: deepseek-v4-pro, deepseek-v4-flash. Old IDs (deepseek-chat, deepseek-reasoner) deprecated July 24, 2026.

How does V4 compare to Kimi and Qwen?

V4-Pro posts higher LiveCodeBench and Codeforces numbers than Kimi K2 and Qwen 3 Max. All are open-weights MoE models. Choose based on the best benchmark for your use case.

Can I fine-tune V4 on my data?

Yes, use the Base checkpoints and a standard SFT pipeline. MIT license permits commercial redistribution.

Will V4 work with my existing OpenAI-compatible tooling?

Yes, the API accepts OpenAI and Anthropic formats:

https://api.deepseek.com (OpenAI)
https://api.deepseek.com/anthropic (Anthropic) Most OpenAI clients work with a base-URL change. For a parallel pattern, see the GPT-5.5 API walkthrough.

GPT-5.5 Pricing: Full Breakdown of API, Codex, and ChatGPT Costs (April 2026)

Hassann — Fri, 24 Apr 2026 02:26:01 +0000

OpenAI’s April 23, 2026 release of GPT-5.5 doubled the per-token price compared to GPT-5.4: input tokens now cost $5.00/M, output tokens $30.00/M. Pro API pricing remains at $30/$180. Knowing the detailed pricing surfaces—API, Batch, Flex, Priority, and Codex limits—is essential to avoid surprise bills and optimize your workload before upgrading to GPT-5.5.

Try Apidog today

For a high-level overview, see What is GPT-5.5. For API integration steps, check How to use the GPT-5.5 API.

TL;DR

Surface	Input / M	Output / M
GPT-5.5 standard API	$5.00	$30.00
GPT-5.5 Pro API	$30.00	$180.00
GPT-5.5 Batch (50% off)	$2.50	$15.00
GPT-5.5 Flex (50% off)	$2.50	$15.00
GPT-5.5 Priority (2.5×)	$12.50	$75.00
GPT-5.4 standard API	$2.50	$15.00
GPT-5.4-mini API	$0.25	$2.00

GPT-5.5 costs 2× GPT-5.4 per token, but OpenAI claims ~20% higher net intelligence when factoring in token efficiency.

The Headline Numbers

OpenAI’s API pricing page lists current rates:

GPT-5.5: $5.00/M input, $30.00/M output tokens.
GPT-5.5 Pro: $30.00/M input, $180.00/M output tokens.
Context window: 1M tokens for both variants. Reasoning tokens count toward both context and output billing.

Batch, Flex, and Priority

OpenAI provides alternative pricing tiers for specific workload needs:

Batch API

Use the Batch endpoint for queued requests at 50% standard pricing. Turnaround is <24 hours. Ideal for:

Overnight dataset evaluations.
Historical re-processing.
Any workflow with latency tolerance measured in hours.

Batch pricing: GPT-5.5 at $2.50 / $15.00 per million tokens—same as GPT-5.4 standard. Use Batch for offline workloads to avoid the price hike.

Flex Processing

Flex offers 50% off standard rates with variable latency, from seconds to several minutes depending on demand. Choose Flex for unpredictable latency tolerance with Batch-level savings and near-synchronous responses.

Priority Processing

Priority tier charges 2.5× standard rates ($12.50/$75.00 per million tokens for GPT-5.5) in exchange for faster throughput, higher rate limits, and minimal queue time. Reserve for latency-critical, user-facing production scenarios.

Thinking Mode Cost Math

reasoning.effort increases the number of tokens used per request, not the per-token price. Adjust your math based on effort:

Effort	Output-token multiplier	When to use
`low`	1×	Routine calls
`medium`	1.3–2×	Multi-step coding, structured generation
`high`	2–4×	Deep research, correctness-critical review
`xhigh`	3–8×	Agent loops, dense planning

A single xhigh call on a long prompt may use 20K reasoning tokens—$0.60 just for reasoning at standard output rates. Budget by workload, not per request.

Codex Pricing

Codex access ties to your ChatGPT plan, not token billing. As of April 2026:

Plan	Codex access	GPT-5.5	Notes
Free	Yes (limited time)	Yes	Tight weekly caps
Go	Yes (limited time)	Yes	2× Free caps
Plus ($20/mo)	Yes	Yes	Standard caps
Pro ($200/mo)	Yes	Yes + Thinking + Pro (in ChatGPT)	Highest per-user caps
Business	Yes	Yes	Seat-based
Enterprise/Edu	Yes	Yes	Contract-based

For CLI-based terminal workflows, Plus or Pro is the most cost-effective way to access GPT-5.5 after a few hundred thousand tokens/day. See the free path guide for no-cost entry.

Comparison: GPT-5.5 vs Other Models

Choose based on your workload’s output and risk profile:

Model	Input / M	Output / M	Cost per 1K output tokens
GPT-5.4-mini	$0.25	$2.00	$0.0020
GPT-5.4	$2.50	$15.00	$0.0150
GPT-5.5	$5.00	$30.00	$0.0300
GPT-5.5 Pro	$30.00	$180.00	$0.1800

High-volume, low-risk output (classification, summarization): GPT-5.4-mini
General workloads where GPT-5.4 is sufficient: GPT-5.4
Complex coding, agentic tasks, research: GPT-5.5
Correctness-critical output: GPT-5.5 Pro

Worked Example: Coding Agent Cost per Task

Typical agentic coding session on GPT-5.5 (reasoning.effort: "medium"):

Input tokens: ~15,000
Output tokens: ~3,000
Reasoning tokens: ~6,000 (medium effort)

Cost per task (standard pricing):

Input: 15K × $5.00/M = $0.075
Output: (3K + 6K) × $30.00/M = $0.27
Total: $0.345 per coding task

Same workload on GPT-5.4:

Input: 15K × $2.50/M = $0.0375
Output: 9K × $15.00/M = $0.135
Total: $0.1725 per task

GPT-5.5 is 2× the cost per task at equal reasoning. If GPT-5.5 closes more tasks successfully (higher quality), the upgrade may pay for itself by reducing retries.

Day 1 Cost Controls to Implement

To manage GPT-5.5 costs, build these controls into your stack:

Enforce max_output_tokens caps: Default to 2,000 unless longer output is necessary.
Strict JSON schemas: Prevents malformed output and expensive retries.
Route by difficulty: Use GPT-5.4-mini for easy requests; escalate hard ones to GPT-5.5.
Use Batch for offline jobs: Evaluations, reports, etc. get 50% off.
Monitor usage.reasoning_tokens: High-effort reasoning tokens are the most common source of bill spikes.

Per-Plan Monthly Cost Estimate

If you’re choosing a ChatGPT plan for GPT-5.5, see the breakdown:

Plan	Monthly Price	Best Fit
Free	$0	Trying GPT-5.5 via Codex
Go	$4/mo	Students, light users
Plus	$20/mo	Devs using Codex + ChatGPT daily
Pro	$200/mo	Power users needing Thinking/Pro modes
Business	$25/seat/mo	Teams needing shared workspaces
Enterprise/Edu	Custom	Contracted, SLA-based use

If your API usage exceeds ~4M output tokens/month, Pro plus Codex CLI is usually cheaper—as long as your context fits in the 400K CLI window.

Price Change Signals to Watch

Track these if budgeting long-term:

GPT-5.5 API general availability: Pricing may drop in response to competition (Claude Mythos, Gemini 3.5, open weights).
Pro model democratization: OpenAI has historically lowered Pro-tier prices 3–6 months post-launch. Don’t assume $30/$180 is permanent.

FAQ

Does caching reduce input cost?

Yes. Cached input tokens are billed at a fraction of standard rate. Check the OpenAI pricing page for details. Cache reusable system prompts and repo contexts.

Is there a volume discount?

Not officially. Enterprise contracts may have custom rates. For sustained, large-scale use, talk to sales.

Does thinking mode cost extra?

No. It increases token usage, not the per-token rate.

Is Codex CLI usage billed separately?

Only if you sign in with an API key. ChatGPT sign-ins use the plan fee; API keys use usage-based billing.

What’s the cheapest way to try GPT-5.5?

Free or Go plan plus Codex CLI. See our free path guide for details.

How to Use GPT-5.5 for Free with Codex?

Hassann — Fri, 24 Apr 2026 02:25:23 +0000

OpenAI released GPT-5.5 on April 23, 2026, and introduced Codex access to every ChatGPT plan—including Free and Go—for a limited time. The fastest way to try GPT-5.5 for free is to install the Codex CLI, sign in with your ChatGPT account, and start using GPT-5.5 from your terminal—no API key or credit card required.

Try Apidog today

This actionable guide covers Codex CLI installation, authentication, model selection, usage limits, and how to integrate Codex into your dev workflow. For a deeper dive into the model, see What is GPT-5.5. For more free usage options, check the GPT-5.5 for free guide.

TL;DR

Codex CLI lets you run GPT-5.5 on your local repo with a 400K context window.
All ChatGPT plans (Free, Go, Plus, Pro, Business, Enterprise, Edu) get Codex; Free and Go are limited time.
Install:

  npm install -g @openai/codex
  # or
  brew install codex

Authenticate: Use ChatGPT OAuth in a browser, or device-code flow on headless servers.
Switch models:

  /model gpt-5.5

Check quota with /status.

Integrate with Apidog: Prototype and test API calls before production.

Why Codex is the Easiest Free Path

OpenAI’s API is paid-only by default—GPT-5.5 on the Responses endpoint is $5/million input tokens and $30/million output tokens after general release. Codex sidesteps this: it wraps the same model in a CLI that authenticates via your ChatGPT account, not an API key. Your ChatGPT plan controls rate limits, but you get the real GPT-5.5 model.

Install Codex CLI

Codex CLI supports two install methods:

# npm (cross-platform)
npm install -g @openai/codex

# or Homebrew (macOS / Linux)
brew install codex

Verify installation:

codex --version

You should see version 0.28.0 or newer—older versions won’t include GPT-5.5.

Authenticate with a ChatGPT Account

On first run, Codex prompts for authentication.

Browser OAuth (Local Machines)

codex

A browser window opens; log in with your ChatGPT account. The CLI caches your session for future use.

Device Code Flow (Headless Servers)

codex login --device-auth

You’ll get a code and URL—open the URL on any device, paste the code, and approve. The CLI on your server completes sign-in automatically.

API Key Fallback

If you prefer to use a paid OpenAI API key:

printenv OPENAI_API_KEY | codex login --with-api-key

This charges your API billing account instead of ChatGPT. Useful for team billing.

Pick GPT-5.5 as the Model

Codex defaults to the “recommended” model for your plan. On paid plans, that’s usually gpt-5.5. Free and Go users may need to switch manually.

During a Session

/model gpt-5.5

The CLI displays the active model and your rate limits.

Launch Flag

codex --model gpt-5.5

Check Remaining Quota

/status

Displays your weekly message budget, context window, and trial expiration for Free/Go plans.

First Session: Practical Example

Codex provides a full-screen terminal UI that reads your repo, runs commands, and edits files. Example workflow:

cd ~/Projects/my-app
codex --model gpt-5.5

Inside Codex, try:

> Read README.md, then open scripts/deploy.sh and summarize what it does in five bullets.

Codex will summarize the script. Next:

> Refactor deploy.sh so it exits on any failed step, and add a dry-run flag. Keep backwards compatibility.

GPT-5.5 proposes a diff; approve to apply changes.

Then run tests:

> Run the deploy test suite and show me the failing case.

Test output streams into the session. If anything fails, ask Codex to fix and loop until tests pass.

This workflow matches the model’s strengths. See OpenAI’s launch post for benchmarks and scores.

What Codex Adds Beyond Raw API Calls

The Codex CLI layers these features over the model:

Repo context: Reads your file tree and indexes relevant files without pasting raw content.
Command execution with approval: You approve all CLI-suggested commands before execution.
Diff previews: All file edits show as unified diffs—accept, reject, or edit before committing.
Session persistence: Project sessions persist; pick up where you left off.

Building these features over the API alone is non-trivial; the GPT-5.5 API guide explains the DIY approach.

Rate Limits and Caps per Plan

Caps as of April 23, 2026:

Plan	GPT-5.5 access in Codex	Weekly cap
Free	Yes (limited time)	Tight; prototype
Go	Yes (limited time, 2× Free)	Small
Plus	Yes	Mid
Pro	Yes, highest solo caps	High
Business	Yes, seat-based	High per seat
Enterprise / Edu	Yes, contract-based	Custom

If you hit your cap, Codex returns a clear error—no silent degradation. Use /status to check usage.

Editor and IDE Integration

Codex authentication is shared across the CLI, VS Code extension, JetBrains plugin, and Codex cloud app. Sign in once via CLI; IDE extensions reuse your credentials.

For Apidog users, a practical workflow:

Prototype a request in Codex CLI (run the GPT-5.5 prompt against this file).
Export the prompt and output into an Apidog collection for team sharing.
Switch from Codex to direct API calls as your contract stabilizes and you move to paid keys.

See Apidog in VS Code for integration details.

Keeping the Workflow Safe on Free and Go

Set these guardrails on day one:

Require approval for file writes: In ~/.codex/config.json, set "autoApproveWrites": false. Defaults are safe for Free, but Go plans may auto-apply trivial diffs.
Limit workspace scope: Run codex from your project directory. Codex reads from the current directory down—avoid running from ~ or other broad scopes.

OpenAI performed third-party safety reviews and cyber red-teaming for GPT-5.5, but always review diffs before applying.

When to Move Off the Free Path

Free and Go access is time-limited. Plan to upgrade if:

You consistently hit quotas: Upgrade to Plus or Pro for more capacity.
You need direct API access: See the GPT-5.5 API guide.
Team billing is needed: Business or Enterprise plans—see the pricing breakdown.

Underlying model remains the same; only billing and access method change.

FAQ

Does Codex run GPT-5.5 Pro too?

No—Pro isn’t currently exposed in Codex. CLI uses standard GPT-5.5; Pro is available in ChatGPT web/app and (eventually) direct API.

Can I use Codex without a ChatGPT account?

No. You need either a ChatGPT login or an OpenAI API key. Free access requires ChatGPT authentication.

How long will Free and Go access last?

OpenAI says “limited time.” Expect weeks to a few months—upgrade as usage grows.

Does Codex work offline?

No. Every GPT-5.5 operation requires a connection to OpenAI’s servers.

How is Codex different from the ChatGPT web app?

Codex runs in your terminal with local filesystem and repo context, plus shell access. The web app doesn’t have these capabilities.

How to Use the GPT-5.5 API for Free

Hassann — Fri, 24 Apr 2026 02:12:57 +0000

GPT-5.5 launched on April 23, 2026, behind a paywall for most users—Plus, Pro, Business, and Enterprise plans in ChatGPT, and paid API tokens for programmatic use. However, there are three current, verifiable ways to access GPT-5.5 for free. If you can work within rate limits and accept temporary access, you can make actual GPT-5.5 calls without adding payment details.

Try Apidog today

This guide covers all free options, maps them to use cases, and shows how to set up a production-ready request collection in Apidog to ensure a smooth transition when you need to move off the free tier.

TL;DR

Codex CLI on ChatGPT Free or Go — Use the Codex command-line tool for free, temporary GPT-5.5 access. No credit card required.
OpenAI trial credit for new API accounts — New accounts get a small starter balance, usable for GPT-5.5 calls once the Responses API is available.
OpenRouter and aggregator free tiers — Some third-party gateways offer free quota for new models shortly after launch.
All paths have usage caps. For any production workload, switch to paid billing before free access runs out.

Path 1: Codex CLI (the most practical free route)

OpenAI includes Codex with every ChatGPT plan (Free and Go, limited time). Codex exposes GPT-5.5 using ChatGPT sign-in, not an API key. Sign in with a free account, run the CLI, and interact with GPT-5.5 using a 400K-token window.

Install

npm install -g @openai/codex
# or
brew install codex

Verify the installation:

codex --version

Authenticate

First run of codex opens a browser for ChatGPT OAuth. For headless environments:

codex login --device-auth

This uses device code authentication—copy the URL and code to another machine to authorize. No API key is needed.

Pick the model

Within Codex:

/model gpt-5.5

Or start Codex directly with the model flag:

codex --model gpt-5.5

Check your remaining quota with /status. Free and Go plans have tighter limits than paid, but enough for prototyping.

What is available (and what is not)

You get: Actual GPT-5.5 model, 400K context, file reads, terminal command execution, repo editing within the CLI.
You do not get: Direct API access. GPT-5.5 is only accessible through Codex when signed in.

For a step-by-step Codex guide, see our free GPT-5.5 with Codex guide.

OpenAI's "limited time" window means Codex access for Free and Go users will end. Make your project flexible by letting the model ID be configurable—swap to a paid plan or API when needed without rewriting code.

Path 2: OpenAI trial credit for new API accounts

New OpenAI developer accounts typically receive a small trial credit. The amount can vary—historically $5 for 90 days, more for .edu emails. When GPT-5.5 API is generally available, you can use this trial balance for real calls.

How to claim trial credit

Create a new developer account at platform.openai.com using a fresh email (previous billing history may disqualify you).
Verify your phone number. This is required for the trial.
Create a project-scoped API key under the trial organization.
Check the usage dashboard for your credit amount and expiry date.

GPT-5.5 usage with trial credit

With $5 credit and current pricing ($5/M input, $30/M output tokens), you get about 1M input tokens or ~160K output tokens with GPT-5.5. Enough to prototype, benchmark, or validate workflows—not enough for production.

Save costs during trial

Use Batch mode: Batch API requests cost 50% less. Great for workflows not requiring instant responses. See OpenAI API pricing.
Set reasoning.effort to low: Default is low (same as GPT-5.4). Higher values consume more tokens.

Important limitations

Trial credit is one-time. When used up, calls return 402. You cannot get a second trial on the same payment or phone credentials.

Path 3: Aggregator free tiers

Third-party gateways (OpenRouter, Together, Groq) sometimes offer free quota for new models. These offers are temporary—check availability before relying on them.

Typical setup pattern

Sign up and verify your email with the aggregator.
Obtain an aggregator API key.
Change your SDK’s base URL to point to the aggregator.
Use the aggregator’s model alias, e.g., openai/gpt-5.5.

Example with OpenRouter:

from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="sk-or-v1-...",
)

response = client.chat.completions.create(
    model="openai/gpt-5.5",
    messages=[{"role": "user", "content": "Explain the Responses API in two paragraphs."}],
)

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

Caveats:

Aggregators have their own rate limits.
Free quota is shared and can disappear fast.
When free access ends, requests return 402 or 429. Use these for prototyping only.

Which free path should you pick?

Use case	Best free path
Terminal-based coding assistant	Codex CLI (Path 1)
Quick Python or Node experiments	Trial credit (Path 2)
Testing from a hosted app	Aggregator (Path 3)
Comparing GPT-5.5 against GPT-5.4 on real prompts	Trial credit + Apidog collection
One-off “can this answer my question” research	ChatGPT Plus (not free, but cheapest per hour)

For anything beyond a prototype, these free paths run out quickly. Use them to learn request shapes and tune prompts before switching to paid tokens.

Pre-build the request shape in Apidog

To avoid rewrites when moving from free to paid, build your request in a version-controlled Apidog collection.

In Apidog:

Create a new collection and add a POST https://api.openai.com/v1/responses request.
Set the auth header from an environment variable to swap keys without editing requests.
Save an example response so downstream developers can work with mocks when keys are missing.
Clone the collection for aggregator testing: point baseUrl at OpenRouter and change the model string.

When trial credit expires or you upgrade, just update the environment variable—no other changes required. For VS Code integration, see our Apidog in VS Code walkthrough.

Free-path limitations to plan around

Rate limits vary by load: Codex Free/Go slows down during peak hours.
Trial credits do not stack: Duplicate accounts (same card/phone/IP) do not get multiple trials.
GPT-5.5 Pro is always paid: No free access to Pro.
Thinking mode uses more quota: Keep reasoning.effort at low unless you need accuracy.
Free windows are temporary: Codex Free/Go access is time-limited (OpenAI launch announcement).

A realistic free-tier prototype workflow

Pick a real team task: report, code review, research brief, etc.
Run 10 examples through GPT-5.4 (existing tools), log output quality.
Run the same 10 examples through GPT-5.5 (Codex CLI or trial credit).
Compare output-per-token and error rate.
Decide if the upgrade justifies the extra cost for your workload.

This can be done in an afternoon, and will inform your production choice before committing to paid usage.

FAQ

Is Codex Free/Go trial permanent?

No. OpenAI calls it “limited time.” Expect it to end within months.

Does ChatGPT Free provide GPT-5.5 in-browser?

No. Free ChatGPT uses GPT-5.3. GPT-5.5 requires Plus or higher.

Can I run GPT-5.5 for free via Hugging Face or Ollama?

No. GPT-5.5 is closed-weight; only available via OpenAI or Codex sign-in.

Is there a student discount?

OpenAI has offered .edu email perks before. Check the OpenAI education page for current offers.

How do I switch from free to paid without rewriting code?

Use environment variables for OPENAI_API_KEY and OPENAI_BASE_URL. When your trial ends, just change these. See our GPT-5.5 API guide for best practices.

How to Use the GPT-5.5 API

Hassann — Fri, 24 Apr 2026 02:00:21 +0000

GPT-5.5 launched on April 23, 2026. OpenAI immediately opened the model for ChatGPT and Codex, with Responses and Chat Completions APIs coming “very soon.” This guide covers both: how to call GPT-5.5 as soon as API keys work, and how to access it today via the Codex sign-in path.

Try Apidog today

This article includes endpoint shapes, authentication, Python and Node examples, the parameter table, pricing breakdown, error handling, and a testing workflow in Apidog to help you save credits while iterating.

For a product overview, see What is GPT-5.5. For a free-tier guide, see How to use GPT-5.5 API for free.

TL;DR

GPT-5.5 is available via Responses and Chat Completions endpoints. Model IDs: gpt-5.5 and gpt-5.5-pro.
API pricing: $5 / M input, $30 / M output; Pro: $30 / M input, $180 / M output.
Context window: 1M tokens (API), 400K (Codex CLI).
Until API GA, access GPT-5.5 via Codex with ChatGPT sign-in.
Use Apidog to pre-build collections; request shape matches GPT-5.4 with new model ID and expanded reasoning block.

Prerequisites

Before making your first call, ensure:

OpenAI developer account with a billable tier. ChatGPT Plus/Pro is separate from API billing; for both UI and API, you need both.
API key with GPT-5 access. Prefer project-scoped keys for production workloads.
SDK version supporting gpt-5.5: Python openai>=2.1.0, Node openai@5.1.0 or newer.
API client for easy request replay. Use curl for one-off, then switch to Apidog or similar for iteration.

Export your API key:

export OPENAI_API_KEY="sk-proj-..."

Endpoint and authentication

GPT-5.5 uses the same endpoints as GPT-5:

POST https://api.openai.com/v1/responses
POST https://api.openai.com/v1/chat/completions

Responses API is tool-aware (supports thinking mode, web search, computer use). Chat Completions maintains compatibility with legacy integrations.

Authenticate using a bearer token. Every request sends a JSON body with model ID, prompt/message array, and additional parameters as needed.

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.5",
    "input": "Summarize the last 10 releases of the openai/codex repo in three bullets.",
    "reasoning": { "effort": "medium" }
  }'

Successful calls return a JSON object with an output array and a usage block (input, output, reasoning tokens). Errors return a standard OpenAI envelope with code and message; see the error table below.

Request parameters

Here’s a full map of gpt-5.5 parameters and their effects:

Parameter	Type	Values	Notes
`model`	string	`gpt-5.5`, `gpt-5.5-pro`	Required. Pro is 6× cost.
`input` / `messages`	string or array	Prompt or chat array	Required. Use `input` for Responses, `messages` for Chat Completions.
`reasoning.effort`	string	`none`, `low`, `medium`, `high`, `xhigh`	Default: `low`. `xhigh` = max depth, higher cost.
`max_output_tokens`	integer	1 – 128000	Output cap, excludes reasoning tokens.
`tools`	array	Function, web_search, file_search, computer_use, code_interpreter	Define available tools. Model chains them as needed.
`tool_choice`	string/object	`auto`, `none`, or a specific tool	Force specific tool usage.
`response_format`	object	`{ "type": "json_schema", "schema": {...} }`	Structured output. Strict mode default.
`stream`	boolean	true / false	Server-sent events; reasoning tokens streamed separately.
`user`	string	Free-form	Helps abuse detection. Pass a hashed user ID.
`metadata`	object	Up to 16 key-value pairs	Visible in OpenAI dashboard/logs.
`seed`	integer	Any int32	Soft determinism; output is similar for same prompt + seed.
`temperature`	number	0 – 2	Ignored if `reasoning.effort >= medium`.

Parameters most affecting cost: reasoning.effort, max_output_tokens, and tools. High or xhigh reasoning.effort can increase output tokens 3–8× compared to low.

Python example

SDK usage mirrors GPT-5.4; update the model ID and use the expanded reasoning.effort range.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.5",
    input=[
        {
            "role": "system",
            "content": "You are a senior Go engineer. Answer in terse, runnable code.",
        },
        {
            "role": "user",
            "content": (
                "Write a worker pool with bounded concurrency and a context "
                "cancellation path. No third-party deps."
            ),
        },
    ],
    reasoning={"effort": "medium"},
    max_output_tokens=4000,
)

print(response.output_text)
print(response.usage.model_dump())

response.output_text flattens the output array. For structured events (tool calls, citations, etc.), use response.output.
usage contains input_tokens, output_tokens, reasoning_tokens. Bill against all three.

Node example

import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-5.5",
  input: [
    { role: "system", content: "You are a careful reviewer." },
    {
      role: "user",
      content:
        "Review this migration and flag any operation that would lock a write-heavy table for more than 200 ms.",
    },
  ],
  reasoning: { effort: "high" },
  tools: [{ type: "file_search" }],
  max_output_tokens: 6000,
});

console.log(response.output_text);
console.log(response.usage);

Set reasoning.effort to high for review tasks where correctness outweighs cost.

Thinking mode

Thinking mode uses reasoning.effort set to high or xhigh with a higher max_output_tokens. There’s no special model ID—just adjust these parameters per request.

Default to medium for most tasks (agentic work, multi-file debugging, doc generation). Costs remain close to GPT-5.4.
Use high/xhigh for research, correctness-critical tasks, and long tool chains. Budget for 3–8× output tokens and longer response times.

If using computer_use or long web-search chains, higher effort reduces hallucinations (see OpenAI’s launch post).

Structured output

Strict JSON output is default. Pass a schema to the SDK for guaranteed JSON structure.

response = client.responses.create(
    model="gpt-5.5",
    input="Extract the title, speaker, and start time from this transcript chunk.",
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "session_extract",
            "strict": True,
            "schema": {
                "type": "object",
                "required": ["title", "speaker", "start_time"],
                "properties": {
                    "title": {"type": "string"},
                    "speaker": {"type": "string"},
                    "start_time": {"type": "string", "format": "date-time"},
                },
            },
        },
    },
)

For pipelines that feed downstream code, always set a schema. This prevents malformed output and eliminates manual retry logic.

Tool use and agents

The Responses API exposes five first-party tool types:

web_search: real-time search with citations
file_search: vector search over uploaded files
code_interpreter: sandboxed Python
computer_use: mouse, keyboard, and browser via Operator stack
function: custom callbacks

GPT-5.5 chains tools more effectively than 5.4. In tests like The Decoder’s, 5.5 completed 11% more multi-step tool chains without user intervention.

Error handling and retries

Handle these common error codes explicitly:

Code	Meaning	Retry?
`429 rate_limit_exceeded`	Rate cap hit.	Yes, use exponential backoff + jitter.
`400 context_length_exceeded`	Input + output + reasoning > 1M tokens.	No; shorten input.
`500 server_error`	OpenAI server error.	Yes, up to 3 attempts.
`403 policy_violation`	Safety refusal.	No; rewrite prompt.

Reasoning tokens count toward context window. For example, reasoning.effort: "xhigh" on a 900K-token input can trigger context overflow.

Testing workflow with Apidog

Due to GPT-5.5’s cost, avoid burning tokens with repeated trial runs. Recommended workflow:

Build the request in Apidog, save it in a collection, and tag the environment (dev/staging/prod).
Use Apidog’s mock server to replay the last real response while refining downstream code.
Switch to a live key only when your schema and logic are stable.

Apidog also integrates with Claude Code and Cursor, so you can access collections directly from your editor. See the VS Code walkthrough and Apidog vs. Postman comparison for setup instructions.

Calling GPT-5.5 before the API is general

Until OpenAI’s Responses API is fully available, use the Codex sign-in flow for early access. The Codex free guide explains how to install the CLI, authenticate with ChatGPT, and select the model.

FAQ

Is there a gpt-5.5-mini? Not at launch. gpt-5.4-mini remains the cost-optimized option.

Context window size? 1M tokens (API), 400K (Codex CLI). Both count reasoning tokens.

Do I need to rewrite GPT-5.4 code? No. Swap the model ID, adjust max_output_tokens if needed, and tune reasoning.effort as appropriate.

How to reduce cost? Options: Batch (50% off), Flex (50% off with slower queue), and strict schemas to avoid retries. See the GPT-5.5 pricing breakdown for details.

Where to get API GA updates? Watch the OpenAI developer community and OpenAI API pricing page.

What Is GPT-5.5? OpenAI's New Frontier Model Explained

Hassann — Fri, 24 Apr 2026 01:46:22 +0000

OpenAI shipped GPT-5.5 on April 23, 2026, just six weeks after GPT-5.4. Marketed as “a new class of intelligence for real work,” GPT-5.5 is a frontier model designed for multi-step coding, advanced computer use, and deep research. It’s available today in ChatGPT and Codex, with API access launching soon.

Try Apidog today

If you’re evaluating whether GPT-5.5 is worth adopting, this guide focuses on what’s new, how it differs from 5.4, key benchmarks, actionable usage steps, and practical caveats.

For hands-on guides, see:

To prepare for the API launch, get Apidog and pre-build your collection.

TL;DR

GPT-5.5: OpenAI’s advanced coding/reasoning model, released April 23, 2026.
Scores 88.7% on SWE-bench and 92.4% on MMLU; 60% fewer hallucinations vs. 5.4.
Three variants: GPT-5.5 standard, GPT-5.5 Thinking (extended reasoning), GPT-5.5 Pro (highest accuracy).
Available now in ChatGPT Plus, Pro, Business, Enterprise, Edu and Codex across all plans (including a temporary free window for Free and Go).
API is staged—developers can use it via Codex sign-in path now; full API is rolling out soon.
API pricing: $5/M input tokens, $30/M output tokens—double GPT-5.4, but more token-efficient.

What GPT-5.5 Actually Is

GPT-5.5 leads the GPT-5 family, above GPT-5.4, 5.4-mini, and 5.3. Codename “Spud,” official name GPT-5.5.

Variants:

GPT-5.5 (default): Faster, sharper, and more token-efficient for most tasks.
GPT-5.5 Thinking: Same model but with a larger reasoning budget—ideal for complex spreadsheets, dense research, and multi-file debugging. Capped at ~3,000 messages/week in ChatGPT.
GPT-5.5 Pro: Highest-accuracy; for correctness-critical work. Only on Pro, Business, and Enterprise plans.

Key features:

Trained to plan, select tools, and self-check outputs. Expect fewer prompts, more accurate tables, and more clarifying questions instead of hallucinations.

What Changed from GPT-5.4

The six-week interval means targeted upgrades rather than a generational leap. Here’s the practical diff:

Capability	GPT-5.4	GPT-5.5
SWE-bench	~74 %	88.7 %
MMLU	91.1 %	92.4 %
Hallucination rate	baseline	−60 %
Context window (API)	1.05 M	1 M (Codex: 400 K)
API input price	$2.50 / M	$5.00 / M
API output price	$15.00 / M	$30.00 / M
Computer use	Improving	Production-grade
Multi-step tool chains	Single-shot	Full autonomous loops

SWE-bench is the headline metric. GPT-5.5’s 88.7% means it closes GitHub issues at a senior engineering level (per OpenAI). Test it on your codebase for real-world validation.

Pricing doubled, but token efficiency improves. Independent tests (The Decoder) show net cost rises ~20% overall, less on short-prompt workloads.

What It Is Good At

OpenAI targets four use cases:

Agentic coding: Repo reading, file ops, running tests, iterative development. Powered by the SWE-bench metrics.
Computer use: Drives browsers, shells, fills forms, scrapes data, recovers from intermediate errors.
Deep research: Longer reasoning chains, better web search, and improved summarization. “Thinking” variant is optimized for this.
Document/spreadsheet generation: Fewer layout errors, correct formulas, cleaner slides. Available in ChatGPT Plus/Business.

Not ideal for:

Cheap, high-volume tasks (classification, embeddings, bulk summarization)—use GPT-5.4-mini or 5.3 for better cost efficiency.

Availability Today

Here’s the access snapshot (as of April 23, 2026):

Surface	Plan	Access
ChatGPT	Free / Go	GPT-5.3 default, no GPT-5.5
ChatGPT	Plus	GPT-5.5 standard + Thinking (3,000/week)
ChatGPT	Pro / Business / Enterprise / Edu	Standard + Thinking + Pro
Codex	All plans (incl. Free/Go)	GPT-5.5 with 400K context; Free/Go on limited-time trial
API	Responses / Chat Completions	“Very soon”; not GA at launch

Codex is the actionable path: GPT-5.5 is live in Codex, so you can use it from the CLI today—no API keys required.

Pricing in One Line

Budgeting? Here’s what to expect:

GPT-5.5 API: $5/M input, $30/M output.
GPT-5.5 Pro API: $30/M input, $180/M output (same as 5.4 Pro).
Batch/Flex: Half standard rate.
Priority: 2.5× standard rate.
Codex CLI: Free on Plus, Pro, Business, Enterprise, Edu, Go, and temporarily Free (plan caps apply).

Full details and per-workload estimates in the GPT-5.5 pricing article.

How To Try It Today

Get started with minimal friction:

Open ChatGPT (paid plan): Select GPT-5.5 from the model picker.
Install Codex CLI:

   npm install -g @openai/codex
   # or
   brew install codex

Then run codex and sign in with your ChatGPT account. Use /model gpt-5.5 to switch. Free/Go plans are included for a limited time.

Full walkthrough: How to use GPT-5.5 for free with Codex

Pre-build for API rollout: The API is coming soon. Build your request collection now in Apidog so you’re ready when the model ID goes live. See the GPT-5.5 API guide for endpoint specs.

Safety and Red-Teaming

OpenAI has run GPT-5.5 through third-party cyber/bio risk tests ahead of launch. Safeguards, especially for offensive security tasks, are tighter with each model.

For developers:

Expect stricter refusal behavior on dual-use code.
The API rollout is staged while new safeguards are finalized.
If you’re building consumer-facing agents, plan for more restrictive default policies than 5.4.

Should You Switch?

Decision matrix:

Coding agents: Switch now. SWE-bench gains stack up, and Codex access is live.
High-volume inference: Stick with GPT-5.4-mini for defaults; use GPT-5.5 only for hard cases.
Consumer-facing products: Wait for API GA, then A/B test. The price jump is real; only switch if hallucination reduction matters for your users.

Full decision flow: pricing breakdown.

FAQ

Is GPT-5.5 available on the API?

Not yet for direct key-based calls (as of April 23, 2026). It’s live in Codex after ChatGPT sign-in, so early testers have access.

What is the context window?

1M tokens in ChatGPT and (soon) the API; 400K tokens in Codex CLI.

How do Thinking and Pro differ?

Thinking extends the reasoning budget on the standard model; Pro is a separate, higher-accuracy variant for critical tasks. Pro is available on Pro, Business, and Enterprise only.

Is GPT-5.5 free?

No, only paid ChatGPT plans. Codex offers temporary free access for Free and Go plans (rate limits apply). See the free guide for no-cost usage.

Can I still use GPT-5.4?

Yes. GPT-5.4 is still available and cheaper ($2.50/$15 per million tokens). For cost-sensitive pipelines, keep it as your default.

How to Use the Hy3 Preview API for Free ?

Hassann — Thu, 23 Apr 2026 10:41:35 +0000

Tencent open-sourced Hy3 Preview on April 22, 2026. Within a day, OpenRouter listed it as a fully free endpoint—no credit card, no metering, no trial window. You can call the same 295B-parameter Mixture-of-Experts model powering Tencent’s Yuanbao app and CodeBuddy assistant from your own code, for $0.

Try Apidog today

This guide shows you how to use the Hy3 Preview API for free via OpenRouter, the Hugging Face Space, or by running the raw Hy3 repo yourself. It covers Hy3’s unique reasoning modes and details on testing the API in Apidog—no throwaway scripts required.

If you want the fastest way to a working response, jump to “Step-by-step: call Hy3 Preview free on OpenRouter.”

TL;DR

Hy3 Preview is free on OpenRouter under model ID tencent/hy3-preview:free, with $0 input and output pricing.
Mixture-of-Experts model: 295B total parameters, 21B active, 192 experts (top-8 routing), and a 256K-token context window.
Three reasoning modes: no_think (fast), low, and high (deep chain-of-thought for coding/agent tasks).
Benchmarks: SWE-bench Verified 74.4, Terminal-Bench 2.0 54.4, GPQA Diamond 87.2, MMLU 87.42.
Three free ways to run: OpenRouter free tier, Hugging Face Hy3-preview Space, or local inference with vLLM and open weights.
Apidog is a great fit with the OpenRouter endpoint: Hy3 uses the OpenAI Chat Completions schema; just point your request at OpenRouter.

What is Hy3 Preview?

Hy3 Preview is Tencent’s first flagship release from their restructured Hunyuan foundation-model team, now led by Yao Shunyu (ex-OpenAI). It’s Tencent’s most capable model to date—a direct response to top Chinese open-weights models from DeepSeek, Alibaba, and Zhipu.

Technical highlights (official model card):

Architecture: Mixture-of-Experts, 80 layers + one MTP layer, 64 attention heads with grouped-query attention.
Parameters: 295B total, 21B active per forward pass.
Experts: 192 specialists, top-8 routing per token.
Context: 256K tokens (262,144 on OpenRouter).
Tokenizer: 120,832 entries, BF16 precision.
License: Tencent Hy Community License (commercial use allowed with conditions).

Agentic training and improved RL infrastructure enable strong results on SWE-bench Verified, Terminal-Bench 2.0, and code/shell tasks—close to top closed models.

Three free ways to use Hy3 Preview

Choose based on your workflow:

Path	What it is	Free?	Good for
OpenRouter `tencent/hy3-preview:free`	Hosted OpenAI-compatible API	Yes, $0 in/out	Agents, scripts, backend features
Hugging Face Space	Browser chat demo	Yes	Quick prompts, smoke tests
Self-hosted weights (vLLM)	Run on your own GPUs	Free software, hardware cost	Privacy, high volume, custom work

Most developers should start with OpenRouter—quick setup, generous free-tier rate limits, and OpenAI API compatibility.

Step-by-step: call Hy3 Preview free on OpenRouter

Minimal steps to your first free call:

Create an OpenRouter account. Sign up at openrouter.ai. Email only; no payment required for free-tier models.
Generate an API key. In your dashboard, go to “Keys,” create a new key, and export it (e.g., export OPENROUTER_API_KEY=sk-or-...).
Open the model page. Visit the Hy3 Preview free listing. Confirm the “Free” status and review usage stats (at launch: 6.81B prompt tokens/day).

Send your first request. OpenRouter uses the OpenAI Chat Completions schema. Any OpenAI SDK works; here’s a curl example:

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "tencent/hy3-preview:free",
    "messages": [
      {"role": "user", "content": "Explain the MoE routing decision inside a top-8 of 192 setup in 3 sentences."}
    ],
    "temperature": 0.9,
    "top_p": 1.0
  }'

Enable reasoning as needed. Add a reasoning parameter with effort set to low or high. OpenRouter returns a reasoning_details array:

{
  "model": "tencent/hy3-preview:free",
  "messages": [
    {"role": "user", "content": "Plan, then write a Bash script that rotates daily log files older than 30 days into a dated archive folder."}
  ],
  "reasoning": {"effort": "high"}
}

Iterate. Use the same thread to maintain context—Hy3’s 256K window can handle entire codebases.

That’s it. The OpenRouter free-tier model is identical to the one published on Hugging Face; quality is not downgraded.

Free, Plus, and self-host: comparison

Choose the right path for your use case:

Capability	OpenRouter Free	OpenRouter Paid	Self-hosted (vLLM/SGLang)
Per-token cost	$0	Per provider	Electricity + GPU amortization
Reasoning modes	`no_think`, `low`, `high`	Same	Same
Context length	256K	256K	256K (memory permitting)
Throughput under load	Shared, deprioritized	Dedicated	Your hardware
Rate limits	OpenRouter free cap	Provider-specific	None
Data retention	OpenRouter policy	Provider-specific	Stays on your hardware
Reasoning token visibility	Yes (`reasoning_details`)	Yes	Yes

Free is ideal for prototyping, benchmarks, and low-traffic agents. Paid/self-hosted is better for lower latency or if you exceed rate caps.

Prompt and parameter tips to maximize Hy3

Match temperature to mode. Use temperature=0.9, top_p=1.0 for creative work; drop to 0.3 for structured output.
Use no_think for chat. Default mode is fastest; use low/high only for planning, multi-step code, or math.
Name tools in the system prompt. Even with OpenRouter, explicitly describe tools for better results.
Quote code. Paste full files and then ask your question; don’t summarize.
Batch multi-file edits. Hy3 performs best with all relevant files provided at once.
Ask for a plan first. Use a two-step prompt: plan, then execute for better agentic task results.

Limits worth knowing

Rate limits flex with load. Free tier is shared; peak hours get 429s. Use retries with exponential backoff.
Reasoning tokens count as output. On the free tier, reasoning_details are free, but they’re billed on paid routes.
License is not Apache 2.0. Tencent Hy Community License allows commercial use with attribution and policy compliance—read the full license.
Tool calling requires correct parser. For self-hosting, use vLLM/SGLang with --tool-call-parser hy_v3 (or hunyuan for SGLang).
English and Chinese best supported. Other languages work, but quality drops.
Trailing US flagship models on some reasoning benchmarks. Hy3 is top-tier for Chinese models, but OpenAI/Google DeepMind still lead on the hardest tasks.

The developer fast path: Hy3 Preview plus Apidog

Command-line curl works for demos, but for real iteration use a visual API client.

Open Apidog and create a new project. Import the OpenAI Chat Completions OpenAPI spec.
Set base URL to https://openrouter.ai/api/v1 and add an environment variable for OPENROUTER_API_KEY.
Create a request to /chat/completions with model set to tencent/hy3-preview:free.
Fork requests to compare reasoning modes. Duplicate and tweak one parameter to run side by side (no_think, low, high).
Save prompt templates. Use Apidog environments and variables to manage system prompts, schemas, and user turns for reuse.

If you’re migrating from Postman, see the API testing without Postman in 2026 guide. Prefer VS Code? Use Apidog inside VS Code to keep prompt tuning next to your code.

Free alternatives when you hit the cap

If OpenRouter’s free pool is throttled, try:

Hugging Face Space: Hy3-preview Space for browser chat. Not scriptable, but free and good for comparisons.
Other free Chinese open-weights models: Alibaba’s Qwen 3.5 Omni and Zhipu GLM 5V Turbo have generous free tiers:

These don’t match Hy3’s coding scores, but cover chat/multilingual/multimodal use cases. For production, set up one Apidog collection per model and benchmark on your actual prompts.

Self-hosting Hy3 Preview with vLLM

If you have sufficient hardware, local inference is an option. Hy3’s model card recommends vLLM with tensor parallelism (8-way) and multi-token prediction:

vllm serve tencent/Hy3-preview \
  --tensor-parallel-size 8 \
  --speculative-config.method mtp \
  --speculative-config.num_speculative_tokens 1 \
  --tool-call-parser hy_v3 \
  --reasoning-parser hy_v3 \
  --enable-auto-tool-choice \
  --served-model-name hy3-preview

SGLang: use --tool-call-parser hunyuan and --reasoning-parser hunyuan. Once the server is up at http://localhost:8000/v1, point any OpenAI SDK to it as you would OpenRouter—just update the base URL and key.

Expect to need eight H100-class GPUs (BF16) for the full model. Quantized versions may appear later, but full precision is currently required.

FAQ

Is Hy3 Preview free?

Yes. OpenRouter’s tencent/hy3-preview:free is $0 per million input/output tokens. Reasoning tokens are free on the free tier but count toward rate limits. Confirm current status on the OpenRouter model page.

How does Hy3 Preview compare to DeepSeek V3 and Qwen 3?

Hy3’s SWE-bench Verified (74.4) and Terminal-Bench 2.0 (54.4) scores put it with the best Chinese open models, with a strong agent/tool use focus. For chat, Qwen 3 and DeepSeek V3 are competitive; for agent/coding workflows, Hy3’s RL-trained tool use stands out.

What are Hy3’s reasoning modes?

Three: no_think (default), low, and high. Set via the reasoning parameter (OpenRouter) or chat_template_kwargs={"reasoning_effort": "high"} (direct model call). Use high for planning/multi-step code/math; default to off for chat.

Can I use Hy3 Preview commercially?

Yes, under the Tencent Hy Community License. Commercial use requires attribution and compliance—read full terms.

What context length does the free tier support?

256K tokens (262,144). Paste entire codebases and still have room for tool schemas and history.

How do I test Hy3 Preview without coding?

Use the Hugging Face Space for browser chat or point Apidog at the OpenRouter endpoint. Apidog supports the OpenAI OpenAPI spec—just set base URL, API key, and model name.

Best Prediction Market API for 2026

Hassann — Thu, 23 Apr 2026 09:45:49 +0000

Prediction markets let developers and traders bet on real-world outcomes—elections, Fed decisions, crypto prices, and more. By 2026, these markets are a major data source, with Polymarket alone handling billions in volume. If you’re building trading bots, dashboards, forecasting tools, or news products, you need a reliable prediction market API feed.

Try Apidog today

The challenge: every API differs. Some use on-chain WebSockets, others offer CFTC-regulated REST endpoints, and a few are built for play money prototyping. Picking the wrong API can waste weeks due to mismatched auth flows, rate limits, or unsupported data formats.

This guide compares the top prediction market APIs for 2026, explains their strengths, and shows how to evaluate and test them with Apidog. Official docs are spread across Polymarket, Kalshi, and Manifold Markets. If you’re working on-chain, see our guide to the best crypto wallet API for Polymarket and Augur integrations.

TL;DR

Polymarket: Deepest liquidity, on-chain CLOB and Gamma APIs. Ideal for high-volume trading and election data.
Kalshi: Only CFTC-regulated US event exchange. REST and WebSocket APIs; requires KYC for trading.
Manifold Markets: Play-money, clean REST API. Great for prototyping, research, and learning.
Augur v2: Runs on Ethereum via subgraph. Niche, low volume, fully decentralized.
PredictIt: Public read-only feed, strict rate limits. Use for data, not trading.
Metaculus: REST API for research and aggregated forecasts. No trading.

What to Look for in a Prediction Market API

Before integrating, evaluate these 7 criteria:

Market coverage: Does it cover politics, sports, crypto, and more, or just one category? (Polymarket/Kalshi = broad; PredictIt = US politics only.)
Liquidity & volume data: Need endpoints for 24h volume, open interest, resolver status.
Real-time feeds: REST polling is limited. Prefer APIs with WebSocket support for live data.
Historical data: Backtesting requires long-term, minute/tick-level data. Some APIs limit free access to 30 days.
Regulated status: US users need CFTC-regulated APIs (Kalshi) or must handle IP restrictions.
Auth model: Trading often requires API keys, wallet signatures, or KYC.
Rate limits & SDKs: Know the per-IP or per-key limits. (Polymarket: ~50 req/sec; Kalshi: tiered; Manifold: relaxed.)

Comparison Table

Provider	Type	API style	Trading auth	Best for
Polymarket	Decentralized, on-chain (Polygon)	REST (CLOB, Gamma) + WebSocket	EIP-712 wallet signature	High-volume crypto-native trading and election data
Kalshi	CFTC-regulated US exchange	REST + WebSocket	Email/password + API key, KYC	US-compliant event contracts and regulated products
Manifold Markets	Play-money social market	REST (clean JSON)	API key	Prototyping, research, teaching
Augur v2	Decentralized (Ethereum)	The Graph subgraph + contracts	Wallet signature	Fully decentralized, censorship-resistant markets
PredictIt	Regulated US political market	Public JSON feed (read)	No public trading API	Historical US political sentiment data
Metaculus	Forecasting research platform	REST	Token auth	Aggregated expert forecasts, research datasets

Top Prediction Market API Providers

Polymarket (CLOB and Gamma)

Polymarket is the largest decentralized prediction market (Polygon, USDC). It exposes two APIs:

CLOB API: Orderbook data, trades, order placement.
Gamma API: Market metadata, event grouping, category browsing.
WebSocket: Real-time trades and orderbook updates.

Read endpoints are open. Trading requires EIP-712 signatures from a Polygon wallet. Use the Polymarket SDK to generate signatures, and integrate wallet providers like Privy or MetaMask. See our guides on using the Privy API and MetaMask API for implementation.

Best for: High-volume trading, election markets, on-chain teams.

Example: Get Polymarket markets

curl https://clob.polymarket.com/api/markets

Kalshi

Kalshi is a CFTC-regulated US event exchange. It covers macro (CPI, Fed), weather, politics, sports, and entertainment. The API uses REST and WebSocket; docs here.

Trading requires a verified account (KYC) and API keys. Orderbooks and trades need authentication. The API enforces per-tier rate limits and token refresh flows, so handle token caching and rotation.

Best for: US-compliant trading, macro and sports automation.

Example: Get Kalshi markets

curl -H "Authorization: Bearer {TOKEN}" https://trading-api.kalshi.com/trade-api/v2/markets

Manifold Markets

Manifold uses “mana” (play money), so you can prototype with zero risk. The REST API (docs) is straightforward. Read markets, comments, and profiles without auth. Betting requires an API key; creating a test account is simple.

Best for: Prototyping, tutorials, student projects, hackathons.

Example: Get Manifold markets

curl https://api.manifold.markets/v0/markets

Augur v2

Augur is a decentralized Ethereum prediction market (REP token). Most access is via The Graph subgraph (GraphQL). For trading, interact with smart contracts directly.

Developer notes: Documentation is sparse, markets are slow, and Ethereum gas costs apply. Integrate with an Ethereum node provider; see our Alchemy API guide.

Best for: Decentralized apps, censorship resistance, research.

Example: Query Augur with GraphQL

{
  markets(first: 5) {
    id
    description
    outcomes {
      price
    }
  }
}

PredictIt

PredictIt is a regulated US political market. No trading API, but a public JSON feed is available at:

https://www.predictit.org/api/marketdata/all/

Usage: Consume as a read-only data source. Rate limits are strict; implement caching and exponential backoff on 429 errors.

Best for: US political price data, sentiment research.

Example: Fetch PredictIt data

curl https://www.predictit.org/api/marketdata/all/

Metaculus

Metaculus is a forecasting platform—no trading, but high-quality aggregated predictions. The REST API (docs) returns questions, predictions, and history using token auth.

Best for: Research, dashboards, academic datasets.

Example: Get Metaculus questions

curl https://www.metaculus.com/api2/questions/

How to Choose

Compliance: For US retail and real money, pick Kalshi. For crypto-native with wallet auth, pick Polymarket.
Coverage: Elections—Polymarket (liquidity), Kalshi (wider contract list). Crypto—Polymarket. Play money/education—Manifold.
Stack fit: On-chain teams: Polymarket, Augur. REST-first teams: Kalshi.
Backtesting/data: PredictIt (US politics), Metaculus (aggregated forecasts).

Testing Prediction Market APIs with Apidog

Each API uses different auth and flows. Kalshi rotates login tokens, Polymarket requires EIP-712 signatures, Manifold uses API keys, Metaculus uses token auth. Managing these in Postman is messy.

Apidog provides a unified workspace for:

Importing OpenAPI specs
Attaching environment-specific auth profiles
Chaining requests into test scenarios
Mocking API responses
Running pre-request flows (e.g., Kalshi login)
Diffing payloads to catch schema changes

For multi-venue dashboards or bots, Apidog can save hours over juggling curl, Postman, and scripts. Download Apidog and import the Polymarket/Kalshi OpenAPI spec to get started.

FAQ

Which prediction market has the most liquidity in 2026?

Polymarket leads, especially for elections and macro events. Kalshi is second, growing on US-regulated contracts.

Can I trade Polymarket from the US?

No—Polymarket blocks US IPs for trading, per CFTC settlement. Market data is still accessible. Use Kalshi for US-compliant trading.

Do I need a crypto wallet for Polymarket’s API?

Yes, for trading. Read endpoints are public, but placing/canceling orders needs EIP-712 signatures from a Polygon wallet. See our MetaMask API guide.

Is there a free prediction market API for learning?

Manifold Markets is fully free (play money). Metaculus is also free for read access.

Kalshi vs. Polymarket for developers?

Kalshi: REST/WebSocket, email auth, CFTC-compliant.

Polymarket: On-chain, wallet signatures, higher liquidity, no US retail trading. Choose based on jurisdiction and settlement needs.

How do I avoid rate limits while backtesting?

Cache snapshots locally, respect 429s with exponential backoff, and batch WebSocket subscriptions if possible. For more, see API testing without Postman in 2026.