Cara Menggunakan GPT-5.3 Codex API

Intinya

GPT-5.3 Codex akhirnya tersedia melalui API, beberapa minggu setelah rilis awalnya. Anda dapat mengaksesnya dengan dua cara:

OpenRouter - ID Model openai/gpt-5.3-codex, harga kompetitif
OpenAI Developers Platform - ID Model gpt-5.3-codex, akses langsung

Untuk memulai: daftar di OpenRouter atau platform OpenAI, dapatkan kunci API Anda, dan buat permintaan pertama Anda menggunakan endpoint Chat Completions standar.

💡

Setelah menghasilkan kode dengan GPT-5.3 Codex, impor spesifikasi API Anda ke Apidog untuk memvalidasi endpoint, membuat kasus uji, dan memastikan kode yang ditulis AI Anda benar-benar berfungsi.

tombol

Pendahuluan

Selama berminggu-minggu, para pengembang ingin mengintegrasikan GPT-5.3 Codex ke dalam aplikasi mereka, tetapi ada kendala. OpenAI merilis model ini melalui Aplikasi Codex, CLI, dan ekstensi IDE, namun API-nya tetap tidak dapat diakses. Tim yang membangun alat pengembangan bertenaga AI, pipeline otomatisasi, dan asisten coding terpaksa menunggu.

Penantian itu telah berakhir.

GPT-5.3 Codex kini tersedia melalui API, memberikan pengembang akses terprogram yang telah mereka minta sejak model tersebut dirilis. Anda memiliki dua pilihan:

OpenRouter - Akses melalui openrouter.ai dengan harga kompetitif dan API terpadu
OpenAI Developers Platform - Akses langsung melalui developers.openai.com

Baik Anda membangun produk SaaS, mengotomatiskan alat internal, atau mengintegrasikan kemampuan AI ke dalam aplikasi yang sudah ada, API GPT-5.3 Codex menyediakan jalur yang mudah untuk memanfaatkan model pengkodean OpenAI yang paling mumpuni. Dengan harga mulai dari $0,00125 per juta token input dan jendela konteks yang dapat menangani basis kode besar, aksesibilitasnya tidak pernah semudah ini.

Dalam panduan ini, kami akan membahas semua yang perlu Anda ketahui untuk mengintegrasikan GPT-5.3 Codex ke dalam alur kerja pengembangan Anda. Mulai dari menyiapkan akun OpenRouter Anda hingga melakukan panggilan API siap produksi, Anda akan memiliki pengetahuan untuk mulai membangun dengan lebih cerdas, lebih cepat.

Apa itu GPT-5.3 Codex?

Dirilis oleh OpenAI, GPT-5.3 Codex secara khusus dioptimalkan untuk tugas pembuatan, pemahaman, dan debugging kode. Tidak seperti model bahasa tujuan umum, Codex telah dilatih dengan sejumlah besar kode pemrograman, membuatnya sangat baik dalam:

Pembuatan Kode: Menulis fungsi, kelas, dan bahkan seluruh aplikasi dari deskripsi
Pemahaman Kode: Menjelaskan fungsi kode yang tidak dikenal dan menyarankan perbaikan
Debugging: Mengidentifikasi bug dan menyarankan perbaikan
Dokumentasi: Membuat docstring dan dokumentasi API
Refactoring: Memperbaiki struktur kode tanpa mengubah fungsionalitas

Versi yang tersedia melalui OpenRouter (openai/gpt-5.3-codex) mendukung jendela konteks 400.000 token—cukup untuk mengunggah seluruh basis kode berukuran sedang dalam satu permintaan. Ini menjadikannya ideal untuk tugas-tugas yang membutuhkan pemahaman hubungan kode yang luas di berbagai file.

Mengapa Menggunakan OpenRouter?

OpenRouter berfungsi sebagai gateway API terpadu yang menyediakan akses ke berbagai model AI dari berbagai penyedia melalui antarmuka tunggal yang konsisten.

Berikut adalah mengapa pengembang memilih OpenRouter untuk mengakses GPT-5 Codex:

API Terpadu: Satu kunci API mengakses puluhan model
Harga Kompetitif: Seringkali lebih murah daripada akses API langsung
Tanpa Batas Frekuensi: Kuota fleksibel berdasarkan penggunaan
Mudah Beralih: Tukar model tanpa mengubah kode Anda
Kredit Gratis: Akun baru menerima $1 kredit gratis untuk memulai

Jika Anda sudah menggunakan model lain melalui OpenRouter, menambahkan GPT-5 Codex hanya membutuhkan perubahan ID model dalam panggilan API Anda yang sudah ada.

OpenRouter vs OpenAI Developers Platform

Anda memiliki dua pilihan untuk mengakses GPT-5.3 Codex melalui API:

Fitur	OpenRouter	OpenAI Developers Platform
ID Model	`openai/gpt-5.3-codex`	`gpt-5.3-codex`
Harga Input	$0.681 / 1 Juta token	$1.75 / 1 Juta token
Input Cache	-	$0.175 / 1 Juta token
Harga Output	$14.00 / 1 Juta token	$14.00 / 1 Juta token
Waktu Penyiapan	Instan	Membutuhkan akun OpenAI
Akses Terpadu	Ya (100+ model)	Tidak (hanya model OpenAI)
Terbaik Untuk	Proyek multi-model	Alur kerja berbasis OpenAI

Pilih OpenRouter jika: Anda menginginkan akses terpadu ke berbagai penyedia LLM, harga kompetitif, dan fleksibilitas untuk beralih model.

Pilih OpenAI Developers Platform jika: Anda lebih suka akses langsung, sudah menggunakan API OpenAI, dan menginginkan dukungan resmi.

Kedua opsi menyediakan model GPT-5.3 Codex yang sama—perbedaannya terletak pada harga, kenyamanan, dan pengaturan yang sudah ada.

Opsi Akses 1: OpenAI Developers Platform

Jika Anda lebih suka akses langsung melalui API resmi OpenAI, berikut cara memulainya:

Langkah 1: Buat Akun OpenAI

Arahkan ke platform.openai.com dan daftar atau masuk.

Langkah 2: Buat Kunci API Anda

Buka Kunci API di bilah sisi kiri
Klik Buat kunci rahasia baru
Salin dan simpan kunci Anda (ditampilkan hanya sekali)

Buat Kunci API Anda di platform pengembang OpenAI

Langkah 3: Lakukan Permintaan Pertama Anda

curl -X POST https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.3-codex",
    "messages": [
      {
        "role": "user",
        "content": "Write a Python function that calculates the factorial of a number."
      }
    ]
  }'

Ganti YOUR_OPENAI_API_KEY dengan kunci API Anda yang sebenarnya.

Contoh Python (OpenAI Langsung)

import os
from openai import OpenAI

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

response = client.chat.completions.create(
    model="gpt-5.3-codex",
    messages=[
        {
            "role": "user",
            "content": "Create a REST API endpoint in FastAPI for user authentication"
        }
    ],
    temperature=0.7,
    max_tokens=2000
)

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

Opsi Akses 2: OpenRouter

Langkah 1: Buat Akun Anda

Arahkan ke openrouter.ai dan daftar dengan email Anda. Proses pendaftaran membutuhkan waktu kurang dari dua menit.

Langkah 2: Dapatkan Kunci API Anda

Setelah masuk, klik ikon profil Anda dan pilih "API Keys." Buat kunci baru dan salin segera—kunci hanya ditampilkan sekali untuk alasan keamanan.

Langkah 3: Tambahkan Kredit

Meskipun akun baru menerima $1 kredit gratis, Anda sebaiknya menambahkan lebih banyak untuk penggunaan berkelanjutan. Arahkan ke "Credits" dan tambahkan dana melalui kartu kredit atau metode lain yang didukung. Minimal $5-$10 direkomendasikan untuk pengembangan reguler.

Langkah 4: Verifikasi Ketersediaan Model

Di dasbor OpenRouter, cari "gpt-5.3-codex" untuk memastikan ketersediaannya. ID model yang akan Anda gunakan adalah openai/gpt-5.3-codex.

Melakukan Panggilan API Pertama Anda

Cara termudah untuk menguji pengaturan Anda adalah dengan curl. Buka terminal Anda dan jalankan:

curl -X POST https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer YOUR_OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -H "HTTP-Referer: https://your-site.com" \
  -d '{
    "model": "openai/gpt-5.3-codex",
    "messages": [
      {
        "role": "user",
        "content": "Write a Python function that calculates the factorial of a number."
      }
    ]
  }'

Ganti YOUR_OPENROUTER_API_KEY dengan kunci Anda yang sebenarnya dan https://your-site.com dengan URL situs web Anda (diperlukan oleh OpenRouter untuk analitik).

Anda akan menerima respons JSON yang berisi kode yang dihasilkan. Selamat—Anda telah melakukan panggilan API GPT-5.3 Codex pertama Anda.

Integrasi Python

Untuk aplikasi Python, Anda dapat menggunakan OpenAI SDK dengan URL dasar khusus:

Instalasi

pip install openai requests python-dotenv

Penggunaan Dasar

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

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

def generate_code(prompt: str) -> str:
    """Menghasilkan kode menggunakan GPT-5.3 Codex melalui OpenRouter."""
    response = client.chat.completions.create(
        model="openai/gpt-5.3-codex",
        messages=[
            {
                "role": "system",
                "content": "Anda adalah programmer ahli. Tulis kode yang bersih dan terdokumentasi dengan baik."
            },
            {
                "role": "user",
                "content": prompt
            }
        ],
        temperature=0.7,
        max_tokens=2000
    )

    return response.choices[0].message.content

# Contoh penggunaan
code = generate_code("Create a REST API endpoint in FastAPI for user authentication")
print(code)

Respons Streaming

def generate_code_streaming(prompt: str):
    """Menghasilkan kode dengan respons streaming."""
    response = client.chat.completions.create(
        model="openai/gpt-5.3-codex",
        messages=[{"role": "user", "content": prompt}],
        stream=True,
        temperature=0.7
    )

    for chunk in response:
        if chunk.choices[0].delta.content:
            print(chunk.choices[0].delta.content, end="", flush=True)

# Contoh penggunaan
generate_code_streaming("Write a React component for a file upload button")

Penanganan Kesalahan

import json

def generate_code_safe(prompt: str) -> dict:
    """Menghasilkan kode dengan penanganan kesalahan yang tepat."""
    try:
        response = client.chat.completions.create(
            model="openai/gpt-5.3-codex",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.7,
            max_tokens=2000
        )

        return {
            "success": True,
            "code": response.choices[0].message.content,
            "usage": {
                "prompt_tokens": response.usage.prompt_tokens,
                "completion_tokens": response.usage.completion_tokens,
                "total_tokens": response.usage.total_tokens
            }
        }

    except Exception as e:
        return {
            "success": False,
            "error": str(e)
        }

# Periksa penggunaan token
result = generate_code_safe("Write a Python decorator for logging")
if result["success"]:
    print(f"Token usage: {result['usage']['total_tokens']} tokens")

Integrasi Node.js

Pengembang JavaScript dan TypeScript dapat mengintegrasikan GPT-5.3 Codex menggunakan OpenAI SDK atau native fetch:

Instalasi

npm install openai

Penggunaan Dasar

import OpenAI from "openai";

const openai = new OpenAI({
  baseURL: "https://openrouter.ai/api/v1",
  apiKey: process.env.OPENROUTER_API_KEY,
  defaultHeaders: {
    "HTTP-Referer": "https://your-site.com",
    "X-Title": "Your App Name",
  },
});

async function generateCode(prompt) {
  const completion = await openai.chat.completions.create({
    model: "openai/gpt-5.3-codex",
    messages: [
      {
        role: "system",
        content: "Anda adalah pengembang full-stack ahli. Tulis kode yang siap produksi.",
      },
      {
        role: "user",
        content: prompt,
      },
    ],
    temperature: 0.7,
    max_tokens: 2000,
  });

  return completion.choices[0].message.content;
}

// Contoh penggunaan
const code = await generateCode("Create a Python function for binary search");
console.log(code);

Menggunakan Native Fetch

async function generateCodeFetch(prompt) {
  const response = await fetch(
    "https://openrouter.ai/api/v1/chat/completions",
    {
      method: "POST",
      headers: {
        "Authorization": `Bearer ${process.env.OPENROUTER_API_KEY}`,
        "Content-Type": "application/json",
        "HTTP-Referer": "https://your-site.com",
        "X-Title": "Your App Name",
      },
      body: JSON.stringify({
        model: "openai/gpt-5.3-codex",
        messages: [{ role: "user", content: prompt }],
        temperature: 0.7,
        max_tokens: 2000,
      }),
    }
  );

  const data = await response.json();
  return data.choices[0].message.content;
}

Parameter dan Opsi Tingkat Lanjut

GPT-5.3 Codex mendukung beberapa parameter untuk menyempurnakan panggilan API Anda:

Temperatur

Mengontrol keacakan. Nilai yang lebih rendah (0,1-0,3) menghasilkan keluaran yang lebih deterministik—ideal untuk pembuatan kode di mana konsistensi penting:

response = client.chat.completions.create(
    model="openai/gpt-5.3-codex",
    messages=[{"role": "user", "content": "Write a sorting algorithm"}],
    temperature=0.2,  # Rendah untuk kode yang konsisten, dapat diprediksi
)

Token Maksimal

Batasi panjang respons untuk mengontrol biaya:

response = client.chat.completions.create(
    model="openai/gpt-5.3-codex",
    messages=[{"role": "user", "content": "Explain this entire codebase"}],
    max_tokens=4000,  # Batasi panjang respons
)

Top P

Alternatif untuk temperatur untuk mengontrol keberagaman keluaran:

response = client.chat.completions.create(
    model="openai/gpt-5.3-codex",
    messages=[{"role": "user", "content": "Write a function"}],
    top_p=0.9,
)

Urutan Penghenti

Tentukan string yang menghentikan pembuatan:

response = client.chat.completions.create(
    model="openai/gpt-5.3-codex",
    messages=[{"role": "user", "content": "Write Python code"}],
    stop=["```", "###"],  # Berhenti di blok kode