GPT-5.5 Spud: Unified Multimodal API — Developer Integration Guide

OpenAI shipped GPT-5.5 on April 23, 2026 — six weeks after GPT-5.4 and one week after Anthropic released Claude Opus 4.7. The internal codename is "Spud," and the model is something genuinely different from the incremental updates that preceded it.

GPT-5.5 is the first fully retrained base model OpenAI has released since GPT-4.5. Every prior 5.x release was a tuned derivative of the same underlying architecture. Spud is not. It processes text, images, audio, and video inside a single unified system — no Whisper call for transcription, no DALL-E endpoint for image generation, no separate pipeline stitching the modalities together. One model, one API endpoint, all four modalities.

For developers building production applications, that architectural shift matters more than the benchmark numbers. Here is what you need to know.

Why GPT-5.5 Is a Different Kind of Release

The GPT-5.x lineage started with GPT-5 (August 2025), then cycled through 5.1, 5.2, 5.3, 5.4, and now 5.5. Most of those were targeted improvements — better reasoning in 5.2, faster latency in 5.3, stronger computer-use in 5.4. They shared the same fundamental architecture.

GPT-5.5 breaks from that pattern. OpenAI rebuilt the token embedding layer to unify all four modalities at the representation level. Text, audio frames, image patches, and video keyframes are projected into the same vector space from the start. Previous OpenAI models encoded modalities separately and fused them at a later layer; Spud does not. The result is that the model reasons across modalities rather than translating between them.

The practical consequence: you can send an audio file, a screenshot, and a text question in a single request, and the model understands the relationships between all three without any preprocessing on your side. If you have been building pipelines that pass audio through Whisper first, then feed the transcript to GPT, you have a genuine opportunity to simplify your stack.

Benchmark Performance: Where Spud Leads and Where It Doesn't

GPT-5.5 landed well on agent-oriented benchmarks and general knowledge, but the picture is more nuanced when you look at code quality head-to-head against Claude Opus 4.7.

Terminal-Bench 2.0 measures complex command-line workflows — multi-step operations that require planning, tool invocation, iteration, and recovery from failed steps. GPT-5.5's 82.7% vs Opus 4.7's 69.4% is a meaningful gap for developers building autonomous agents that operate over CLI tools, file systems, or APIs.

SWE-Bench Pro is the inverse story. Claude Opus 4.7 holds a 5.7-point lead (64.3% vs 58.6%) on solving real GitHub issues. That benchmark rewards careful, precise code generation — the kind of output you want when a human will review the PR.

The practical read: GPT-5.5 is the stronger choice for autonomous, long-running agentic tasks. Opus 4.7 remains stronger for code generation where precision matters and a human reviews the output. OpenAI's own Agents SDK is built to run on GPT-5.5 by default.

Pricing and Tier Structure

GPT-5.5 is priced higher than GPT-5.4 but offset by significantly better token efficiency — OpenAI reports the model completes equivalent Codex tasks with fewer tokens and fewer retries.

For context: GPT-5.4 runs at $2.50/$15 standard, so GPT-5.5 doubles the per-token rate. OpenAI's position is that the token efficiency gain offsets the price increase in most workloads — and for multimodal tasks that previously required multiple API calls (Whisper + GPT + DALL-E), the consolidation often results in lower total cost.

GPT-5.5 Pro is aimed at scientific research, complex analysis, and the highest-stakes production tasks. For most teams, standard GPT-5.5 or batch mode will be the right starting point.

Context Window and Available Modalities

The context window is 1 million tokens in ChatGPT and the upcoming Responses/Chat Completions API. In Codex CLI, the window is fixed at 400K tokens across all subscription plans.

GPT-5.5 handles four modalities natively:

• Text: Standard token-based processing, same API interface as GPT-5.4
• Image: Send base64-encoded or URL-referenced images; the model generates images natively as output (no separate DALL-E call)
• Audio: Send audio files directly; transcription and speech synthesis are handled within the same request
• Video: Pass video files or frame sequences; the model analyzes temporal content and can describe, summarize, or reason about video

One million tokens of context is substantial. For reference, a typical 100K-line codebase fits in roughly 700K tokens. You can now send your entire medium-sized repository in a single API call — relevant for automated code review, architecture analysis, or repo-level refactoring tasks.

API Integration Guide

As of April 24, 2026, full Responses API and Chat Completions access is staged — currently available via Codex sign-in for developers, with the general API rollout described as "very soon." The model IDs to watch for are gpt-5.5 and gpt-5.5-pro.

Text-Only Request (Chat Completions)

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-5.5",
    messages=[
        {"role": "system", "content": "You are a senior software engineer."},
        {"role": "user", "content": "Review this function for edge cases."}
    ],
    max_tokens=2048
)

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

Multimodal Request: Image + Text

import base64

with open("screenshot.png", "rb") as f:
    image_data = base64.b64encode(f.read()).decode("utf-8")

response = client.chat.completions.create(
    model="gpt-5.5",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{image_data}"
                    }
                },
                {
                    "type": "text",
                    "text": "What errors are visible in this UI? List them with severity."
                }
            ]
        }
    ]
)

Multimodal Request: Audio Transcription + Analysis

with open("meeting.mp3", "rb") as f:
    audio_data = base64.b64encode(f.read()).decode("utf-8")

response = client.chat.completions.create(
    model="gpt-5.5",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "audio",
                    "audio": {
                        "data": audio_data,
                        "format": "mp3"
                    }
                },
                {
                    "type": "text",
                    "text": "Summarize the action items from this recording."
                }
            ]
        }
    ]
)

Note that the audio modality interface follows the same pattern as image input — no separate Whisper API call needed. The transcript, analysis, and any follow-up reasoning happen in a single model inference.

Batch Processing for Cost Reduction

For high-volume workloads where latency is not critical, the Batch API cuts costs by half:

import json

batch_requests = [
    {
        "custom_id": f"request-{i}",
        "method": "POST",
        "url": "/v1/chat/completions",
        "body": {
            "model": "gpt-5.5",
            "messages": [{"role": "user", "content": document}],
            "max_tokens": 1024
        }
    }
    for i, document in enumerate(documents)
]

with open("batch_requests.jsonl", "w") as f:
    for req in batch_requests:
        f.write(json.dumps(req) + "\n")

batch_file = client.files.create(
    file=open("batch_requests.jsonl", "rb"),
    purpose="batch"
)

batch = client.batches.create(
    input_file_id=batch_file.id,
    endpoint="/v1/chat/completions",
    completion_window="24h"
)

Batch results arrive within 24 hours at $2.50 per million input tokens — the most cost-efficient path for document processing, classification, or any workload that tolerates latency.

Agentic Use Cases Where GPT-5.5 Excels

The Terminal-Bench 2.0 lead is not an accident. GPT-5.5 was trained specifically for multi-step autonomous task completion. Three categories stand out:

1. Long-running CLI agent workflows. Tasks that involve: read a file, decide what to do, invoke a shell command, observe the output, retry on failure, and produce a final result. GPT-5.5 handles the iteration loop with significantly fewer stalls than 5.4. OpenAI reports it "uses significantly fewer tokens to complete the same Codex tasks" — meaning the model is better at deciding when it has enough information to act rather than asking for clarification.

2. Multimodal investigation pipelines. Security analysts reviewing screenshots, logs, and audio recordings in a single context window. Accessibility auditors comparing UI screenshots to specs. QA engineers sending screen recordings and asking the model to identify regressions. These workloads become dramatically simpler without the orchestration layer between modalities.

3. Code + documentation cross-referencing. Sending an entire codebase (within the 1M context) alongside its documentation and asking the model to identify inconsistencies. At GPT-5.4's context limit, this required chunking or vector search. At 1M tokens, many medium repos fit directly.

For Claude Code-style agentic coding, GPT-5.5 via Codex is OpenAI's answer. The Terminal-Bench lead suggests it is competitive for autonomous task completion; SWE-Bench Pro results suggest human-in-the-loop code review still favors Opus 4.7.

Common Mistakes When Integrating GPT-5.5

Assuming audio input replaces structured data. Sending audio files works, but for structured extraction (dates, numbers, names), the transcription quality benefits from an explicit instruction in the text part of the message. Don't assume the model will automatically apply structured output constraints to audio-derived content without being told.

Ignoring batch mode for classification tasks. If you are running GPT-5.5 on thousands of documents for classification, tagging, or summarization, and latency is not a constraint, not using the Batch API means you are paying 2× unnecessarily. Batch mode is half the price with no quality trade-off.

Over-estimating token efficiency gains for simple tasks. The token efficiency improvement is most pronounced on complex, multi-step tasks. For simple Q&A or single-turn completions, GPT-5.4 at half the price is often the better call. Reserve GPT-5.5 for workloads where the capability improvement justifies the cost.

Using Chat Completions when Responses API is available. The Responses API is the unified interface OpenAI is investing in going forward. It supports tool calling, multimodal output, and streaming in a more consistent way than Chat Completions. For new production integrations, build against Responses API from the start.

Sending full videos when frame sampling suffices. Video input works natively but large video files consume tokens proportionally to their duration. For most use cases, sampling key frames (every 5-10 seconds) and sending those as image inputs gives similar analysis quality at a fraction of the token cost.

FAQ

Q: When will GPT-5.5 be available in the general API?

OpenAI's announcement states it will be in the Responses and Chat Completions APIs "very soon." As of April 24, developers can access it through Codex. Watch the OpenAI API changelog for the rollout announcement.

Q: Is GPT-5.5 better than GPT-6 for everyday tasks?

GPT-6 (released April 14, 2026) sits above GPT-5.5 in OpenAI's model hierarchy with a 2M token context window and Symphony architecture. For the highest-stakes tasks, GPT-6 is the more capable option. For most production workloads — agentic coding, document analysis, multimodal pipelines — GPT-5.5 offers a better price-to-capability ratio.

Q: Does GPT-5.5 replace the Whisper API for audio transcription?

For most use cases, yes. GPT-5.5 handles audio input natively with equivalent transcription quality. The Whisper API remains available for dedicated transcription-only workloads where you do not need subsequent language model reasoning on the output.

Q: What is the model ID for GPT-5.5?

The model identifier is gpt-5.5 for standard and gpt-5.5-pro for the Pro tier. These identifiers are confirmed in the OpenAI changelog and will be available once the general API rollout completes.

Q: How does GPT-5.5 handle the Claude Mythos comparison?

VentureBeat's Terminal-Bench 2.0 results show GPT-5.5 at 82.7% narrowly ahead of Claude Mythos Preview. Mythos remains in gated access (approximately 50 organizations). For most developers, the relevant comparison is GPT-5.5 vs Claude Opus 4.7, where the trade-off is agentic tasks (GPT-5.5) vs precision code generation (Opus 4.7).

Key Takeaways

• GPT-5.5 is a genuine architectural rebase, not an incremental fine-tune. It is the first fully retrained OpenAI model since GPT-4.5.
• Native omnimodal processing means text, audio, image, and video share a single embedding space. One API call, no preprocessing pipelines.
• Benchmark positioning is task-dependent: Terminal-Bench 2.0 (82.7%) and MMLU (92.4%) favor GPT-5.5; SWE-Bench Pro (58.6% vs 64.3%) still favors Claude Opus 4.7.
• API pricing: $5/$30 per million tokens standard; half that on Batch. Worth the upgrade for complex multimodal or long-running agentic tasks; overkill for simple Q&A.
• 1M token context window opens up whole-repo analysis that previously required RAG or chunking.
• General API access is staged — currently through Codex, full Responses/Chat Completions rollout imminent.

Prefer a deep-dive walkthrough? Watch the full video on YouTube.