Tutorial OpenAI Responses API: 14 Contoh Python yang Bisa Dijalankan

Tutorial OpenAI Responses API: 14 Contoh Python yang Bisa Dijalankan

Tutorial OpenAI Responses API yang sebenarnya Anda butuhkan: 14 contoh Python yang dapat dijalankan, mencakup alat bawaan, streaming, pemanggilan fungsi, MCP, dan migrasi 3 langkah dari Chat Completions. Responses API diluncurkan pada 11 Maret 2025 sebagai primitif terunifikasi OpenAI untuk aplikasi bergaya agen, dan hingga April 2026 ini menjadi titik awal yang direkomendasikan untuk setiap proyek OpenAI baru. Kami telah menguji setiap contoh di bawah ini menggunakan SDK Python openai>=1.50 terbaru pada April 2026 — setiap blok kode berjalan sebagaimana adanya.

Poin penting

• Responses API (diluncurkan 11 Maret 2025) menyatukan Chat Completions, Assistants, dan alat bawaan ke dalam satu primitif yang memiliki status (stateful).
• Mendukung web_search, file_search, code_interpreter, computer_use, image_generation, dan server MCP jarak jauh secara langsung.
• Migrasi dari Chat Completions hanya membutuhkan 3 langkah: ubah endpoint, ganti nama messages menjadi input, perbarui skema alat.
• Gunakan previous_response_id (dengan store: true) untuk manajemen status yang ringan; gunakan Conversations API untuk thread multi-putaran yang andal.

Apa Itu OpenAI Responses API?

OpenAI Responses API adalah primitif terunifikasi yang diluncurkan pada Maret 2025 yang menggabungkan kesederhanaan Chat Completions dengan kemampuan penggunaan alat dari Assistants API. API ini mendukung input teks + gambar, alat bawaan (pencarian web, pencarian file, interpreter kode, penggunaan komputer, pembuatan gambar), pemanggilan fungsi, output terstruktur, streaming, dan percakapan yang memiliki status melalui previous_response_id.

Jadi, mengapa OpenAI merilis API ketiga ketika Chat Completions sudah berfungsi? Karena loop agen—di mana model memanggil alat, mendapatkan hasil, lalu memutuskan langkah berikutnya—cukup canggung jika dibangun di atas chat.completions. Anda akhirnya harus bolak-balik mengirim hasil alat dalam array messages, mengelola ID thread dengan Assistants API, atau membuat sistem status sendiri. Responses API memperlakukan loop tersebut sebagai konsep kelas utama.

Jika Anda memulai proyek OpenAI baru di tahun 2026, Responses API adalah pilihan default, sedangkan Chat Completions adalah primitif lama yang sebaiknya Anda tinggalkan. Pengecualian utamanya: audio real-time (gunakan Realtime API) dan embedding murni (gunakan Embeddings API). Untuk hal lainnya—chatbot, agen, pipeline RAG, ekstraktor data terstruktur—Responses API adalah apa yang disarankan oleh dokumentasi OpenAI dan postingan pengumuman OpenAI.

Jika Anda mengoordinasikan beberapa model atau menginginkan lapisan scaffolding tingkat lebih tinggi, Anda biasanya akan memasangkan Responses API dengan OpenAI Agents SDK. Kami membahas trade-off-nya dalam perbandingan OpenAI Agents SDK kami. Intinya: Responses adalah primitifnya, Agents SDK adalah framework-nya.

Bagaimana Perbedaan Responses API dengan Chat Completions?

Responses API adalah superset dari Chat Completions: setiap fitur Chat Completions berfungsi di Responses, ditambah dengan alat bawaan, status, dan loop agen. OpenAI merekomendasikan Responses untuk semua proyek baru. Chat Completions tetap didukung tetapi bukan lagi primitif default untuk agen.

Berikut adalah perbandingan sisi demi sisi, bersumber dari dokumen platform OpenAI:

Setiap fitur Chat Completions berfungsi di Responses; sebaliknya tidak benar. Aturan keputusannya singkat: jika Anda membutuhkan alat bawaan, status, atau memulai dari nol, gunakan Responses. Jika Anda memiliki pipeline Chat Completions yang stabil yang tidak menyentuh alat dan gateway Anda belum mendukung Responses, migrasi tidak mendesak, namun jangan membangun agen baru di atas API lama.

Penyiapan dan Panggilan Responses API Pertama Anda

Untuk melakukan panggilan Responses API pertama Anda, instal OpenAI Python SDK versi 1.50 atau lebih baru, atur variabel lingkungan OPENAI_API_KEY Anda, dan panggil client.responses.create() dengan model dan input. Contoh hello-world lengkapnya memakan waktu kurang dari 60 detik.

Langkah 1 — Instal SDK:

pip install --upgrade "openai>=1.50"

Langkah 2 — Atur kunci API Anda:

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

(Di Windows PowerShell: $env:OPENAI_API_KEY = "sk-proj-...". Jangan pernah commit ini ke git, gunakan file .env plus python-dotenv untuk pengembangan lokal.)

Langkah 3 — Panggilan hello-world:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Say hello in exactly 5 words.",
)

print(response.output_text)

Jalankan itu dan Anda akan mendapatkan salam 5 kata sebagai balasan. Helper output_text menggabungkan setiap potongan teks menjadi satu string, yang berguna ketika Anda tidak peduli dengan output terstruktur.

Langkah 4 -- Inspeksi objek respons:

print("ID:        ", response.id)
print("Status:    ", response.status)
print("Model:     ", response.model)
print("Output:    ", response.output)            # list of output items
print("First text:", response.output[0].content[0].text)
print("Usage:     ", response.usage)             # input_tokens, output_tokens

Array response.output itulah yang perlu Anda hafalkan. Ini adalah daftar item bertipe: teks, panggilan alat, hasil alat, ringkasan penalaran. Anda akan terus-menerus mengiterasinya begitu mulai menggunakan alat bawaan.

Bagaimana Cara Melakukan Streaming Respons dengan Responses API?

Streaming dengan Responses API menggunakan Server-Sent Events. Berikan stream=True ke client.responses.create() dan iterasi melalui aliran event yang dihasilkan. Setiap event memiliki bidang type, response.output_text.delta untuk potongan token, dan response.completed untuk payload akhir. SDK 1.50+ mengekspos aliran event yang bertipe.

Jika Anda merender token ke UI, Anda akan mengiterasi event response.output_text.delta dan mengabaikan yang lainnya.

from openai import OpenAI

client = OpenAI()

with client.responses.stream(
    model="gpt-5",
    input="Write a haiku about Python decorators.",
) as stream:
    for event in stream:
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)
        elif event.type == "response.error":
            print(f"\n[error] {event.error}")
            break
        elif event.type == "response.completed":
            print("\n[done]")

    final = stream.get_final_response()
    print(f"\nTokens: {final.usage.output_tokens}")

Beberapa jebakan yang kami temui saat pengujian: context manager stream menangani pembersihan koneksi secara otomatis, jadi jangan menutupnya secara manual. Jika Anda ingin asinkron, ganti OpenAI() dengan AsyncOpenAI() dan gunakan async with serta async for, dengan nama event dan bentuk yang sama.

Alat Bawaan: Pencarian Web, Pencarian File, Interpreter Kode, Penggunaan Komputer, Pembuatan Gambar

Responses API dilengkapi dengan lima alat bawaan: web_search untuk pencarian internet langsung, file_search untuk pengambilan vector store, code_interpreter untuk eksekusi Python dalam sandbox, computer_use untuk otomatisasi browser/desktop, dan image_generation untuk pembuatan gambar inline. Aktifkan salah satunya dengan menambahkan {"type": "<tool_name>"} ke array tools.

Berikut adalah matriks yang selalu kami tempel di samping editor kami:

Saat kami menguji web_search dalam pipeline kami, latensi menambah 1,5–3 detik pada panggilan pertama tetapi di-cache untuk pengulangan, jadi rencanakan hal ini di UI. Contoh pencarian web OpenAI Cookbook adalah referensi paling bersih jika Anda ingin mendalami lebih lanjut.

Pencarian Web

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    tools=[{"type": "web_search"}],
    input="What did OpenAI announce at DevDay 2025? Cite your sources.",
)

print(response.output_text)

# Inspect the web_search_call items in response.output for raw search hits
for item in response.output:
    if item.type == "web_search_call":
        print(f"[searched] {item.query}")

Pencarian File

Pencarian file adalah tarian dua langkah: buat vector store, unggah file Anda, lalu referensikan ID store di array tools Anda.

from openai import OpenAI

client = OpenAI()

# 1. Create a vector store + upload a file
store = client.vector_stores.create(name="company-handbook")
client.vector_stores.files.upload_and_poll(
    vector_store_id=store.id,
    file=open("handbook.pdf", "rb"),
)

# 2. Use it in a Responses call
response = client.responses.create(
    model="gpt-5",
    input="What's our PTO policy?",
    tools=[{
        "type": "file_search",
        "vector_store_ids": [store.id],
    }],
)
print(response.output_text)

Interpreter Kode

Perlu model untuk menjalankan Python pada CSV dan membuat grafik? code_interpreter melakukannya dalam container sandbox.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Read sales.csv and plot monthly revenue as a bar chart. Return a summary.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
)
print(response.output_text)

Container bertahan lintas panggilan dalam sesi yang sama, berguna ketika Anda ingin model terus melakukan iterasi pada dataframe.

Penggunaan Komputer

Masih dalam tahap pratinjau pada April 2026. Model mendapatkan browser/desktop virtual dan mengklik sekitarnya untuk menyelesaikan tugas. Lewati ini kecuali Anda memiliki kasus penggunaan otomatisasi browser spesifik yang tidak dapat diselesaikan oleh dunia Playwright/Selenium.

Pembuatan Gambar

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Generate a diagram showing a CI/CD pipeline with build, test, and deploy stages.",
    tools=[{"type": "image_generation"}],
)

# Image bytes live in image_generation_call items
for item in response.output:
    if item.type == "image_generation_call":
        with open("pipeline.png", "wb") as f:
            f.write(item.result)

Pemanggilan Fungsi dengan Alat Kustom

Pemanggilan fungsi di Responses API memungkinkan model memanggil fungsi Python Anda sendiri. Definisikan setiap fungsi sebagai skema JSON di array tools, jalankan panggilan, periksa response.output untuk item function_call, eksekusi fungsi, dan kirimkan hasilnya kembali melalui function_call_output.

Responses API mengubah pemanggilan fungsi dari tarian 4 langkah menjadi satu putaran pulang-pergi (round-trip) ketika Anda membiarkan loop agen menanganinya untuk Anda. Berikut adalah contoh konversi mata uang lengkap:

import json
from openai import OpenAI

client = OpenAI()

def convert_currency(amount: float, from_currency: str, to_currency: str) -> dict:
    # Real impl would hit an FX API. Stubbed for the example.
    rate = 1.08 if (from_currency, to_currency) == ("USD", "EUR") else 1.0
    return {"amount": amount * rate, "currency": to_currency}

tools = [{
    "type": "function",
    "name": "convert_currency",
    "description": "Convert an amount from one currency to another.",
    "parameters": {
        "type": "object",
        "properties": {
            "amount": {"type": "number"},
            "from_currency": {"type": "string"},
            "to_currency": {"type": "string"},
        },
        "required": ["amount", "from_currency", "to_currency"],
    },
}]

# Turn 1: model decides to call our function
first = client.responses.create(
    model="gpt-5",
    input="How much is 250 USD in EUR?",
    tools=tools,
)

# Find the function_call item, run it, send the result back
for item in first.output:
    if item.type == "function_call" and item.name == "convert_currency":
        args = json.loads(item.arguments)
        result = convert_currency(**args)

        second = client.responses.create(
            model="gpt-5",
            previous_response_id=first.id,
            input=[{
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": json.dumps(result),
            }],
            tools=tools,
        )
        print(second.output_text)

Itulah loop lengkapnya. Jika Anda baru mengenal pola ini, postingan dasar-dasar pemanggilan fungsi kami menjelaskan model konseptualnya, dan kami mempertahankan kumpulan pustaka pemanggilan fungsi jika Anda lebih memilih tidak membuat skema secara manual. Parameter tool_choice (diatur ke "auto", "required", atau nama alat tertentu) adalah tuas Anda untuk memaksa atau melarang panggilan alat ketika Anda membutuhkan determinisme.

Output Terstruktur (Skema JSON dan Pydantic)

Output terstruktur menjamin model mengembalikan JSON yang sesuai dengan skema Anda. Berikan parameter response_format={"type": "json_schema", "json_schema": {...}} atau, dengan Python SDK, berikan model Pydantic secara langsung melalui client.responses.parse(). Model dibatasi pada waktu decode, bukan hanya diprompt.

from openai import OpenAI
from pydantic import BaseModel

client = OpenAI()

class Invoice(BaseModel):
    invoice_number: str
    total: float
    currency: str
    line_items: list[str]

response = client.responses.parse(
    model="gpt-5",
    input="Extract: Invoice #INV-2024-001 for $1,250.00 USD. Items: hosting, support, SSL cert.",
    text_format=Invoice,
)

invoice: Invoice = response.output_parsed
print(invoice.invoice_number, invoice.total, invoice.line_items)

Jalur Pydantic adalah yang Anda inginkan 95% dari waktu: aman tipe, lebih sedikit boilerplate, dan IDE Anda melengkapi hasil secara otomatis. Gunakan skema JSON mentah hanya ketika Anda perlu berbagi skema lintas bahasa atau ketika skema dihasilkan secara dinamis. Kami menggali trade-off-nya dalam panduan output terstruktur dan skema JSON dan pengantar Pydantic untuk skema aman tipe kami.

Manajemen Status: previous_response_id, Conversations API, dan store=true

Gunakan previous_response_id untuk konteks multi-putaran yang ringan, Conversations API untuk sesi ber-thread yang andal, atau kirim riwayat pesan lengkap untuk kontrol sisi klien penuh. previous_response_id memerlukan store: true dan hanya bertahan untuk respons yang di-cache; jatuh kembali ke riwayat lengkap jika ID tidak dapat diselesaikan.

Berikut adalah contoh dua putaran menggunakan previous_response_id:

from openai import OpenAI

client = OpenAI()

# Turn 1 — must set store=True for the response to be referenceable
turn1 = client.responses.create(
    model="gpt-5",
    input="My name is Mert and I'm building a weather agent.",
    store=True,
)

# Turn 2 — reference turn 1 by ID; the model "remembers" the name
turn2 = client.responses.create(
    model="gpt-5",
    previous_response_id=turn1.id,
    input="What was my name again?",
    store=True,
)

print(turn2.output_text)  # "Your name is Mert..."

Jika Anda lupa store: true, previous_response_id Anda tidak akan resolve ke apa pun dan model dimulai dari nol setiap putaran. Kami telah menghabiskan satu jam untuk men-debug ini, API tidak memberikan error, ia hanya membuat Anda menjadi amnesia secara diam-diam. Retensi default adalah 30 hari; jika Anda membutuhkan lebih lama, beralihlah ke Conversations API yang memberi Anda kontrol eksplisit atas siklus hidup thread.

Kapan Anda harus upgrade ke Conversations API? Ketika Anda memiliki banyak pengguna dalam satu aplikasi, ketika thread bertahan lebih lama dari satu sesi, atau ketika Anda ingin pengeditan/pencabangan pesan sisi server. Untuk chatbot cepat, previous_response_id sudah cukup.

Cara Bermigrasi dari Chat Completions ke Responses API

Migrasi dari Chat Completions ke Responses API membutuhkan tiga langkah: ubah /v1/chat/completions menjadi /v1/responses, ganti messages dengan input, dan ganti skema tools dengan format baru. Pemanggilan fungsi dan input multimodal memerlukan penanganan yang sedikit berbeda. OpenAI menyediakan paket migrasi resmi di GitHub.

Langkah 1 -- Pertukaran Endpoint:

# Before (Chat Completions)
response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "Hello"}],
)
text = response.choices[0].message.content

# After (Responses)
response = client.responses.create(
    model="gpt-5",
    input="Hello",
)
text = response.output_text

Langkah 2 -- Ganti nama messages → input:

# Before
client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Summarize this PDF."},
    ],
)

# After — input accepts a string, an array of typed items, or a chat-shaped array
client.responses.create(
    model="gpt-5",
    instructions="You are a helpful assistant.",   # system → instructions
    input="Summarize this PDF.",
)

Langkah 3 -- Perbarui skema alat:

# Before (Chat Completions tool format)
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather",
        "parameters": {"type": "object", "properties": {"city": {"type": "string"}}},
    },
}]

# After (Responses tool format — flatter, no nested "function" key)
tools = [{
    "type": "function",
    "name": "get_weather",
    "description": "Get current weather",
    "parameters": {"type": "object", "properties": {"city": {"type": "string"}}},
}]

Hanya itu. Gulirkan traffic secara bertahap dengan feature flag, pertahankan jalur kode Chat Completions Anda tetap aktif di balik antarmuka yang sama selama satu atau dua minggu, catat kedua bentuk respons secara berdampingan, dan hanya alihkan 100% setelah Anda memverifikasi kesetaraan. Paket migrasi di repo openai-cookbook memiliki pola adapter yang lebih lengkap jika Anda menginginkan referensi.

Cara Menggunakan MCP dan Server MCP Jarak Jauh dengan Responses API

Responses API mendukung server MCP (Model Context Protocol) jarak jauh sebagai jenis alat. Tambahkan entri seperti {"type": "mcp", "server_url": "https://mcp.example.com", "server_label": "..."} ke array tools. Model menemukan katalog alat server MCP dan memanggilnya seperti alat bawaan.

Jika Anda belum pernah menyentuh MCP, berikut adalah pitch 30 detiknya: ini adalah protokol terbuka yang memungkinkan layanan apa pun mengekspos API-nya sebagai katalog alat yang dapat dipanggil oleh model. Shopify, Stripe, GitHub, dan daftar vendor yang berkembang menjalankan endpoint MCP publik. Deep-dive Model Context Protocol (MCP) kami mencakup protokol itu sendiri.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Find me the top-ranking competitor for 'openai responses api tutorial' and summarize their content gaps.",
    tools=[{
        "type": "mcp",
        "server_url": "https://mcp.semrush.com",
        "server_label": "semrush",
        "require_approval": "never",   # set to "always" in production
    }],
)
print(response.output_text)

Perlakukan server MCP seperti API pihak ketiga mana pun. require_approval: "never" baik-baik saja untuk prototipe; dalam produksi Anda menginginkan "always" (atau allowlist alat) sehingga server MCP yang dikompromikan tidak dapat secara diam-diam mengekstraksi data. Audit katalog alat server sebelum mengarahkan agen Anda ke sana.

Harga, Batas Rate, dan Jebakan Produksi

Harga Responses API sama dengan Chat Completions untuk biaya token (prompt + penyelesaian), dengan surcharge per panggilan pada alat bawaan (web_search, file_search). Batas rate mengikuti tier OpenAI Anda yang ada. Jebakan produksi umum termasuk default retensi store: true, 429 sementara pada traffic burst, dan kelambatan fitur varian Azure.

Harga berubah, selalu verifikasi di halaman harga OpenAI pada saat penulisan.

Untuk penanganan error, bungkus panggilan dalam try/except openai.RateLimitError dan try/except openai.APIStatusError, dengan backoff eksponensial melalui tenacity:

from openai import OpenAI, RateLimitError, APIStatusError
from tenacity import retry, retry_if_exception_type, stop_after_attempt, wait_exponential

client = OpenAI()

@retry(
    retry=retry_if_exception_type((RateLimitError, APIStatusError)),
    wait=wait_exponential(multiplier=1, min=2, max=30),
    stop=stop_after_attempt(5),
    reraise=True,
)
def safe_create(prompt: str):
    return client.responses.create(model="gpt-5", input=prompt)

print(safe_create("Hello").output_text)

Kami mengalami 429 sementara pada burst 20 permintaan paralel di lingkungan staging kami, tenacity dengan backoff eksponensial memperbaikinya dengan bersih. String error yang kami catat adalah openai.RateLimitError: Error code: 429 - {'error': {'message': 'Rate limit reached for gpt-5 in organization org-... on requests per min (RPM)'}}. Baca sekali dan lanjutkan; decorator retry menangani sisanya.

Catatan varian Azure: Azure OpenAI mengekspos Responses API tetapi tertinggal 4–8 minggu di belakang rollout yang dikendalikan Sam Altman. Pada April 2026, dukungan MCP di Azure hanya pratinjau, konfirmasikan terhadap dokumen Azure OpenAI Responses API Microsoft Learn sebelum Anda merilis.

Kompatibilitas Gateway: jika Anda memproksi OpenAI melalui proxy LiteLLM, dukungan Responses API tiba di tahun 2026. Sebagian besar gateway lain sedang mengejar ketertinggalan. Dan untuk rollout produksi, Anda akan menginginkan observabilitas dan logging AI yang terhubung sebelum Anda mengalihkan traffic, event Responses API lebih kaya daripada Chat Completions, dan Anda akan ingin setiap panggilan alat dicatat.

Kapan TIDAK Menggunakan Responses API

Lewati Responses API untuk audio real-time latensi rendah (gunakan Realtime API), pembuatan embedding (gunakan Embeddings API), dan alur kerja fine-tuning. Tetap gunakan Chat Completions jika gateway/proxy Anda belum mendukung Responses (sebagian besar melakukannya via LiteLLM pada 2026).

Beberapa diskualifikasi jujur lainnya:

• Agen suara real-time, Realtime API menggunakan WebSockets dan dibangun untuk pergantian giliran sub-detik. Streaming Responses API adalah HTTP SSE; ini akan terasa lambat untuk suara.
• Pipeline embedding murni, client.embeddings.create() lebih murah, lebih cepat, dan itulah yang diharapkan oleh setiap integrasi vektor DB.
• Fine-tuning, Anda melatih dan menerapkan fine-tune melalui API fine-tuning; Anda kemudian dapat memanggilnya melalui Responses, tetapi pelatihan itu sendiri bukan alur kerja Responses.
• Pekerjaan Batch API, jika Anda memproses satu juta prompt semalam dengan diskon 50%, Batch API masih menang dalam hal harga.
• Semantik Chat Completions yang terkunci, jika penggunaan eval, observabilitas, dan pustaka prompt Anda semua mengasumsikan chat.completions.choices[0].message.content, biaya migrasi adalah nyata. Jangan bermigrasi hanya karena itu lebih baru.

Jika stack Anda senang dengan Chat Completions dan Anda tidak membangun agen, migrasi itu tidak gratis, sprint Q2 Anda mungkin tidak membutuhkannya. Lebih baru tidak berarti lebih baik untuk Anda, Responses API adalah primitif yang tepat untuk agen, bukan untuk setiap beban kerja OpenAI.

Pertanyaan yang Sering Diajukan

Apa itu OpenAI Responses API?

OpenAI Responses API adalah primitif terunifikasi yang diluncurkan pada Maret 2025 yang menggabungkan kesederhanaan Chat Completions dengan penggunaan alat Assistants API. Ini mendukung input teks dan gambar, lima alat bawaan, pemanggilan fungsi, output terstruktur, streaming, dan percakapan yang memiliki status melalui previous_response_id.

Kapan OpenAI Responses API dirilis?

OpenAI mengumumkan Responses API pada 11 Maret 2025 bersamaan dengan pengumuman "alat baru untuk membangun agen" yang lebih luas. API ini telah tersedia secara umum sejak peluncuran, dengan Conversations API, dukungan MCP, dan alat image_generation ditambahkan dalam pembaruan bertahap sepanjang 2025 dan awal 2026.

Apakah OpenAI Responses API memiliki status (stateful)?

Ya, opsional. Berikan previous_response_id plus store: true dan model membawa konteks lintas panggilan tanpa Anda mengirim riwayat lengkap. Untuk thread berumur lebih panjang, Conversations API memberi Anda manajemen siklus hidup thread yang eksplisit. Anda juga dapat tetap stateless dan mengirim riwayat lengkap setiap putaran, seperti Chat Completions.

Apa perbedaan antara Responses API dan Chat Completions?

Responses API adalah superset dari Chat Completions. Setiap fitur Chat Completions berfungsi di Responses, ditambah alat bawaan (web_search, file_search, dll.), status melalui previous_response_id, dan loop agen sebagai konsep kelas utama. OpenAI merekomendasikan Responses untuk semua proyek baru pada 2026.

Apakah API Chat Completions sudah dihentikan (deprecated)?

Tidak. Pada April 2026, Chat Completions tidak dihentikan, ini tetap didukung sepenuhnya. OpenAI merekomendasikan Responses untuk proyek baru, dan sebagian besar tutorial gaya agen mengasumsikan Responses. Chat Completions sekarang adalah primitif warisan: stabil, tetapi bukan lagi tempat fitur baru muncul pertama kali.

Model OpenAI mana yang mendukung Responses API?

GPT-5, gpt-5-mini, gpt-4.1, dan model penalaran seri-o semuanya mendukung Responses API. Seri-o menambahkan parameter reasoning_effort (low, medium, high) untuk beban kerja berpikir ekstended. Pembuatan gambar dialihkan melalui gpt-image-1 di balik layar ketika Anda mengaktifkan alat image_generation.

Bagaimana cara bermigrasi dari Chat Completions ke Responses API?

Tiga langkah: ganti client.chat.completions.create() menjadi client.responses.create(), ganti array messages dengan input (dan pindahkan prompt sistem ke instructions), dan datarkan skema alat Anda (hapus kunci function yang bersarang). Paket migrasi OpenAI di GitHub memiliki contoh adapter lengkap.

Apakah Responses API mendukung streaming?

Ya. Berikan stream=True ke client.responses.create() (atau gunakan client.responses.stream() sebagai context manager) dan iterasi Server-Sent Events yang bertipe. Event aliran token yang akan Anda tangani adalah response.output_text.delta untuk konten dan response.completed untuk payload akhir. Streaming asinkron berfungsi melalui AsyncOpenAI.

Bisakah saya menggunakan Responses API di Azure?

Ya. Azure OpenAI mengekspos Responses API, tetapi paritas fitur tertinggal 4–8 minggu di belakang rollout langsung OpenAI. Pada April 2026, dukungan MCP di Azure berada dalam pratinjau. Periksa Microsoft Learn untuk keanehan khusus Azure saat ini sebelum Anda merilis ke produksi.

Apakah Responses API bekerja dengan server MCP?

Ya, server MCP (Model Context Protocol) jarak jauh adalah jenis alat kelas utama. Tambahkan {"type": "mcp", "server_url": "...", "server_label": "..."} ke array tools Anda dan model menemukan serta memanggil katalog alat server seperti alat bawaan mana pun. Gunakan require_approval: "always" dalam produksi untuk keamanan.

Penutup

Anda sekarang memiliki gambaran lengkap Responses API: bagaimana perbedaannya dengan Chat Completions, cara meluncurkan panggilan pertama Anda, cara menghubungkan alat bawaan, dan cara memigrasikan proyek Chat Completions yang ada dalam tiga langkah. Beberapa poin penting untuk dipegang teguh:

• Bangun dulu, lalu optimalkan. Mulailah dengan contoh hello-world, tambahkan alat bawaan, lalu lapisi dengan status menggunakan previous_response_id.
• Migrasi secara bertahap. Gunakan feature flag, catat kedua bentuk respons, alihkan 100% hanya setelah verifikasi kesetaraan.
• Luncurkan integrasi MCP. Ini adalah frontier 2026, sebagian besar vendor berlomba-lomba untuk mengekspos endpoint MCP, dan Responses API adalah cara paling bersih untuk mengonsumsinya.

Di Techsy, kami membantu tim meluncurkan integrasi OpenAI tingkat produksi, termasuk rollout Responses API dan migrasi Chat Completions. Dapatkan konsultasi gratis.

Oleh tim editorial Techsy, insinyur produksi yang meluncurkan integrasi OpenAI sejak 2024. Terakhir diperbarui: 25 April 2026.