OpenRouter: Panduan dengan Contoh Praktis

Mengelola banyak API penyedia AI dengan cepat menjadi melelahkan. Setiap penyedia memiliki metode autentikasi, model penetapan harga, dan spesifikasi API yang berbeda. Pengembang menghabiskan banyak waktu berpindah antara OpenAI, Anthropic, Google, dan platform lain hanya untuk mengakses model yang berbeda.

OpenRouter menyelesaikan kerumitan ini dengan menyediakan API terpadu yang menghubungkan Anda ke lebih dari 400 model dari puluhan penyedia. Anda dapat mengakses GPT-5, Claude 4, Gemini 2.5 Pro, dan ratusan model lainnya menggunakan satu kunci API dan antarmuka yang konsisten. Platform ini menangani fallback otomatis, pengelolaan biaya, dan perutean penyedia di belakang layar.

Dalam tutorial ini, saya menjelaskan semua yang perlu Anda ketahui tentang OpenRouter, mulai dari menyiapkan panggilan API pertama hingga menerapkan fitur lanjutan seperti keluaran terstruktur. Pada akhirnya, Anda akan mempelajari cara membangun aplikasi andal yang tidak terikat pada satu penyedia saja.

Apa itu OpenRouter?

OpenRouter adalah platform API terpadu yang memberi Anda akses ke lebih dari 400 model AI dari puluhan penyedia melalui satu endpoint. Alih-alih mengelola kunci API terpisah untuk OpenAI, Anthropic, Google, Meta, dan lainnya, Anda menggunakan satu kunci untuk menjangkau seluruh katalog model mereka.

Platform ini bekerja sebagai router cerdas, mengirimkan permintaan Anda ke penyedia yang tepat sambil menangani autentikasi, penagihan, dan penanganan error. Pendekatan ini mengatasi berbagai masalah yang muncul saat menggunakan banyak penyedia AI.

Masalah yang diselesaikan OpenRouter

Bekerja dengan banyak penyedia AI cepat menjadi berantakan. Masing-masing memiliki format API, proses login, dan sistem penagihan sendiri. Anda akhirnya harus memelihara kode terpisah untuk setiap layanan, yang memperlambat pengembangan dan membuat pengujian model baru menjadi merepotkan.

Keadaan menjadi lebih buruk saat penyedia mengalami gangguan atau menabrak Anda dengan batas laju. Aplikasi Anda rusak, dan tidak ada yang bisa dilakukan selain menunggu. Selain itu, mencari tahu penyedia mana yang menawarkan harga terbaik untuk model serupa berarti Anda harus melacak biaya secara manual di berbagai platform.

Masalah terbesar adalah terkunci pada satu penyedia. Ketika Anda membangun semuanya di sekitar API spesifik mereka, beralih ke model yang lebih baik atau opsi yang lebih murah di kemudian hari menjadi proyek besar.

Cara OpenRouter memperbaikinya

OpenRouter menyelesaikan masalah ini dengan serangkaian fitur terhubung:

• Satu kunci API berfungsi dengan 400+ model dari semua penyedia utama
• Peralihan otomatis ke penyedia cadangan saat pilihan pertama gagal
• Perbandingan harga berdampingan untuk semua model agar Anda bisa membandingkan biaya seketika
• Bekerja dengan kode OpenAI yang sudah ada—cukup ubah URL endpoint
• Pemantauan real-time yang merutekan permintaan ke penyedia tercepat yang tersedia

Semua komponen ini bekerja bersama untuk membuat pengembangan AI lebih mulus dan andal.

Siapa yang sebaiknya menggunakan OpenRouter?

Berbagai tipe pengguna mendapatkan manfaat dari pendekatan terpadu ini:

• Pengembang dapat mencoba model baru tanpa harus membuat akun di mana-mana, membuat eksperimen lebih cepat
• Tim enterprise mendapatkan uptime yang dibutuhkan lewat cadangan otomatis saat penyedia gagal
• Pengguna yang sensitif pada anggaran dapat menemukan opsi termurah untuk kebutuhan mereka tanpa rumus spreadsheet
• Peneliti mendapatkan akses instan ke model-model terdepan tanpa overhead penyiapan akun

Sekarang setelah Anda memahami apa yang ditawarkan OpenRouter, mari kita siapkan panggilan API pertama Anda.

Prasyarat

Sebelum masuk ke OpenRouter, Anda perlu menyiapkan beberapa hal di mesin Anda. Tutorial ini mengasumsikan Anda nyaman dengan pemrograman Python dasar dan pernah bekerja dengan API. Anda tidak perlu menjadi ahli, tetapi sebaiknya memahami konsep seperti membuat permintaan HTTP dan menangani respons JSON.

Anda memerlukan Python 3.7 atau lebih baru yang terpasang di sistem. Kita akan menggunakan paket Python openai untuk berinteraksi dengan API OpenRouter, bersama dengan python-dotenv untuk menangani variabel lingkungan dengan aman. Anda dapat memasang keduanya dengan:

pip install requests openai python-dotenv

Anda juga memerlukan akun dan kunci API OpenRouter. Kunjungi openrouter.ai untuk membuat akun gratis—Anda akan mendapat sedikit kredit untuk uji coba. Setelah masuk, buka bagian API Keys di pengaturan akun Anda dan buat kunci baru.

Setelah mendapatkan kunci API, buat berkas .env di direktori proyek Anda dan tambahkan kunci seperti ini:

OPENROUTER_API_KEY=your_api_key_here

Ini menjaga kunci API Anda tetap aman dan tidak masuk ke kode. Jika Anda berencana menggunakan OpenRouter di luar pengujian, Anda perlu menambah kredit ke akun melalui halaman Credits.

Dengan dasar-dasar ini, Anda siap melakukan panggilan API pertama melalui OpenRouter.

Melakukan Panggilan API Pertama di OpenRouter

Memulai dengan OpenRouter sangat sederhana jika Anda pernah menggunakan OpenAI SDK sebelumnya. Anda hanya mengubah satu baris kode dan langsung mendapat akses ke ratusan model dari berbagai penyedia.

Permintaan pertama dan penyiapan

Mari langsung ke contoh yang berfungsi untuk menunjukkan pendekatan OpenRouter:

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"),
)

response = client.chat.completions.create(
   model="openai/gpt-5-mini",
   messages=[
       {
           "role": "user",
           "content": "Write a haiku about debugging code at 2 AM"
       }
   ]
)

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

Night hum, coffee cooled
cursor blinks, bug hides somewhere
I chase ghosts 'til dawn

Keajaibannya terjadi di dua tempat. Pertama, parameter base_url mengarahkan ulang permintaan Anda ke server OpenRouter alih-alih OpenAI. Kedua, nama model mengikuti format provider/model-name - openai/gpt-5-mini alih-alih hanya gpt-5-mini. Ini memberi tahu OpenRouter versi penyedia mana yang Anda inginkan sambil mempertahankan antarmuka yang familier. Berikut beberapa model umum yang dapat Anda masukkan ke contoh di atas tanpa error:

• google/gemini-2.0-flash-001
• google/gemini-2.5-pro
• mistralai/mistral-nemo
• deepseek/deepseek-r1-distill-qwen-32b

Sekarang setelah Anda melihat betapa mudahnya bekerja dengan berbagai model, Anda mungkin bertanya-tanya: apa yang terjadi saat model pilihan Anda tidak tersedia? Bagaimana membangun aplikasi yang tetap andal bahkan ketika penyedia menghadapi masalah? Di sinilah fitur perutean dan ketahanan OpenRouter berperan.

Perutean Model untuk Ketahanan

Membangun aplikasi AI yang andal berarti mempersiapkan hal yang tak terduga. Penyedia mengalami downtime, model terkena batas laju, dan terkadang moderasi konten memblokir permintaan Anda. Perutean model adalah solusi OpenRouter—secara otomatis beralih di antara model yang berbeda untuk menjaga aplikasi Anda tetap berjalan mulus.

Menyiapkan fallback manual

Cara paling sederhana untuk menambah ketahanan adalah menentukan model cadangan. Saat pilihan utama Anda gagal, OpenRouter mencoba alternatif Anda secara berurutan. Parameter extra_body meneruskan instruksi perutean ini ke API OpenRouter karena OpenAI SDK tidak mendukung fitur ini secara native:

response = client.chat.completions.create(
   model="moonshotai/kimi-k2",  # Primary choice
   messages=[
       {"role": "user", "content": "Explain quantum computing in simple terms"}
   ],
   extra_body={
       "models": ["anthropic/claude-sonnet-4", "deepseek/deepseek-r1"]
   }   
)

print(f"Response from: {response.model}")
print(response.choices[0].message.content)

Response from: moonshotai/kimi-k2
Imagine a normal computer bit as a tiny light-switch that can only be OFF (0) or ON (1)...

OpenRouter mencoba Kimi-K2 terlebih dahulu. Jika tidak tersedia, terkena batas laju, atau diblokir, ia otomatis mencoba Claude Sonnet 4, lalu DeepSeek R1. Field response.model menampilkan model mana yang sebenarnya merespons.

Auto router untuk kemudahan maksimal

Setelah Anda memahami fallback manual, auto router menjadi sangat menarik. Fitur ini menangani pemilihan model dan fallback secara otomatis, didukung oleh sistem evaluasi NotDiamond:

response = client.chat.completions.create(
   model="openrouter/auto",
   messages=[
       {"role": "user", "content": "Debug this Python code in 3 sentences: def factorial(n): return n * factorial(n-1)"}
   ]
)

print(f"Auto router selected: {response.model}")
print(response.choices[0].message.content)

Auto router selected: openai/chatgpt-4o-latest
The given code is missing a base case, which causes infinite recursion and eventually a RecursionError. To fix it, add a base case like `if n == 0: return 1` before the recursive call. Here's the corrected version:

\```python
def factorial(n):
   if n == 0:
       return 1
   return n * factorial(n - 1)
\```

Auto router menganalisis prompt Anda dan memilih model terbaik yang tersedia, dengan fallback bawaan jika pilihan pertama tidak tersedia. Anda mendapatkan ketahanan tanpa konfigurasi apa pun. Namun, gunakan auto-router dengan hati-hati dalam skenario sensitif atau profil tinggi karena cenderung meremehkan kompleksitas masalah Anda dan memilih model berkapasitas lebih rendah.

Membangun strategi fallback yang efektif

Tidak semua model cocok menjadi cadangan satu sama lain. Downtime penyedia dapat memengaruhi semua model dari perusahaan yang sama, jadi pilih cadangan dari penyedia yang berbeda. Batas laju dan biaya sangat bervariasi, jadi pasangkan model mahal dengan alternatif yang lebih murah juga:

# Good fallback chain: different providers, decreasing cost
response = client.chat.completions.create(
   model="anthropic/claude-sonnet-4",
   messages=[
       {"role": "user", "content": "Your prompt here"}
   ],
   extra_body={
       "models": [
           "x-ai/grok-4",                  # Close performance
           "moonshotai/kimi-k2",           # Cheaper
           "deepseek/deepseek-r1:free"     # Free backup
       ]
   }   
)

Ini memberi Anda kualitas premium saat tersedia, performa solid sebagai cadangan, dan ketersediaan terjamin sebagai pilihan terakhir. Kebijakan moderasi konten juga berbeda antar penyedia, jadi mendiversifikasi rantai Anda memberi cakupan lebih baik untuk topik sensitif.

Menemukan model untuk rantai fallback Anda

Halaman model memungkinkan Anda memfilter berdasarkan penyedia dan kapabilitas untuk membangun rantai. Banyak model kuat seperti DeepSeek R1 dan Kimi-K2 bersifat gratis karena open-source, sehingga sangat cocok sebagai cadangan. Model gratis memiliki batas 50 permintaan per hari untuk pengguna baru, atau 1000 permintaan per hari jika Anda telah membeli 10 kredit.

Untuk aplikasi dinamis, Anda dapat menemukan model secara terprogram:

def get_provider_models(api_key: str, provider: str) -> list[str]:
   r = requests.get(
       "https://openrouter.ai/api/v1/models",
       headers={"Authorization": f"Bearer {api_key}"}
   )
   return [m["id"] for m in r.json()["data"] if m["id"].startswith(provider)]

# Build fallbacks across providers
openai_models = get_provider_models(api_key, "openai/")
anthropic_models = get_provider_models(api_key, "anthropic/")

Pendekatan ini memungkinkan Anda membangun rantai fallback tangguh yang beradaptasi seiring ketersediaan model baru.

Streaming untuk Respons Real-time

Saat bekerja dengan model AI, khususnya untuk respons panjang, pengguna berharap melihat keluaran muncul secara bertahap alih-alih menunggu respons lengkap. Streaming mengatasi hal ini dengan mengirimkan potongan respons saat dibuat, menciptakan pengalaman yang lebih interaktif seperti antarmuka ChatGPT.

Penyiapan streaming dasar

Untuk menyiapkan streaming di OpenRouter, tambahkan stream=True pada permintaan Anda. Respons menjadi sebuah iterator yang menghasilkan potongan saat model menghasilkannya:

response = client.chat.completions.create(
   model="openai/gpt-5",
   messages=[
       {"role": "user", "content": "Write a detailed explanation of how neural networks learn"}
   ],
   stream=True
)

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

Setiap potongan berisi bagian kecil dari respons. Field delta.content menyimpan fragmen teks baru, dan kita mencetaknya segera tanpa baris baru untuk menciptakan efek streaming. Parameter end="" mencegah print menambahkan baris baru antar potongan.

Membangun handler streaming yang lebih baik

Untuk aplikasi produksi, Anda memerlukan kontrol lebih atas proses streaming. Berikut handler yang lebih komprehensif yang mengelola respons lengkap:

def stream_response(model, messages, show_progress=True):
   response = client.chat.completions.create(
       model=model,
       messages=messages,
       stream=True
   )
  
   complete_response = ""
  
   for chunk in response:
       if chunk.choices[0].delta.content is not None:
           content = chunk.choices[0].delta.content
           complete_response += content
          
           if show_progress:
               print(content, end="", flush=True)
  
   if show_progress:
       print()  # Add final newline
  
   return complete_response

# Use it with different models
result = stream_response(
   "anthropic/claude-sonnet-4",
   [{"role": "user", "content": "Explain quantum entanglement like I'm 12 years old"}]
)

Handler ini menangkap respons lengkap sambil menampilkan progres, memberi Anda pengalaman streaming dan teks akhir sekaligus, serta menyertakan pemformatan keluaran yang tepat.

Streaming mengubah pengalaman pengguna dari “menunggu dan berharap” menjadi “melihat progres berlangsung.” Ini membuat aplikasi AI Anda terasa jauh lebih responsif dan menarik bagi pengguna.

Menangani Reasoning Tokens di OpenRouter

Beberapa model AI dapat menampilkan proses “berpikir” mereka sebelum memberikan jawaban akhir. Reasoning tokens memberikan tampilan transparan tentang bagaimana model mendekati masalah kompleks, menunjukkan logika langkah demi langkah yang mengarah pada kesimpulan. Memahami penalaran internal ini membantu Anda memverifikasi jawaban, men-debug perilaku model, dan membangun aplikasi yang lebih tepercaya.

Apa itu reasoning tokens

Reasoning tokens muncul dalam field reasoning terpisah pada respons, berbeda dari konten utama. Model yang berbeda mendukung reasoning dengan cara berbeda—sebagian menggunakan level upaya sementara yang lain menggunakan anggaran token. 

Berikut contoh sederhana yang menunjukkan reasoning dalam aksi:

response = client.chat.completions.create(
   model="anthropic/claude-sonnet-4",
   messages=[
       {"role": "user", "content": "How many 'r's are in the word 'strrawberry'?"}
   ],
   max_tokens=2048,
   extra_body={
       "reasoning": {
           "max_tokens": 512
       }
   }
)

print("Final answer:")
print(response.choices[0].message.content)
print("\nReasoning process:")
print(response.choices[0].message.reasoning)

Final answer:
To count the 'r's in 'strrawberry', I'll go through each letter:
...
There are **4** 'r's in the word 'strrawberry'.

Reasoning process:
...

Model akan menampilkan jawaban akhir dan penalaran internal yang mengarah pada kesimpulan tersebut. Keluaran ganda ini membantu Anda memahami apakah model mendekati masalah dengan benar.

Mengontrol intensitas reasoning

Anda dapat mengontrol seberapa besar upaya penalaran yang dilakukan model ke dalam responsnya dengan dua pendekatan. Parameter effort berfungsi pada model seperti seri o milik OpenAI dan menggunakan level yang sesuai dengan persentase token tertentu berdasarkan pengaturan max_tokens Anda:

• Upaya tinggi: Menggunakan sekitar 80% dari max_tokens untuk reasoning
• Upaya sedang: Menggunakan sekitar 50% dari max_tokens untuk reasoning
• Upaya rendah: Menggunakan sekitar 20% dari max_tokens untuk reasoning

# High effort reasoning for complex problems
response = client.chat.completions.create(
   model="deepseek/deepseek-r1",
   messages=[
       {"role": "user", "content": "Solve this step by step: If a train travels 240 miles in 3 hours, then speeds up by 20 mph for the next 2 hours, how far does it travel total?"}
   ],
   max_tokens=4000,  # High effort will use ~3200 tokens for reasoning
   extra_body={
       "reasoning": {
           "effort": "high" 
       }
   }
)

print("Problem solution:")
print(response.choices[0].message.content)
print("\nStep-by-step reasoning:")
print(response.choices[0].message.reasoning)

Untuk model yang mendukung alokasi token langsung, seperti model Anthropic, Anda dapat menentukan anggaran reasoning secara tepat:

def get_reasoning_response(question, reasoning_budget=2000):
   response = client.chat.completions.create(
       model="anthropic/claude-sonnet-4",
       messages=[{"role": "user", "content": question}],
       max_tokens=10000,
       extra_body={
           "reasoning": {
               "max_tokens": reasoning_budget  # Exact token allocation
           }
       }
   )
   return response

# Compare different reasoning budgets
response = get_reasoning_response(
   "What's bigger: 9.9 or 9.11? Explain your reasoning carefully.",
   reasoning_budget=3000
)

print("Answer:", response.choices[0].message.content)
print("Detailed reasoning:", response.choices[0].message.reasoning)

Anggaran token yang lebih tinggi umumnya menghasilkan penalaran yang lebih menyeluruh, sementara anggaran lebih rendah memberikan proses berpikir yang lebih cepat tetapi kurang detail.

Melestarikan reasoning dalam percakapan

Saat membangun percakapan multi-giliran, Anda perlu melestarikan reasoning dan jawaban akhir untuk mempertahankan konteks. Ini sangat penting untuk diskusi kompleks di mana proses berpikir model memengaruhi respons berikutnya:

# First message with reasoning
response = client.chat.completions.create(
   model="anthropic/claude-sonnet-4",
   messages=[
       {"role": "user", "content": "Should I invest in renewable energy stocks? Consider both risks and opportunities."}
   ],
   extra_body={
       "reasoning": {
           "max_tokens": 3000
       }
   }
)

# Build conversation history with reasoning preserved
messages = [
   {"role": "user", "content": "Should I invest in renewable energy stocks? Consider both risks and opportunities."},
   {
       "role": "assistant",
       "content": response.choices[0].message.content,
       "reasoning_details": response.choices[0].message.reasoning_details  # Preserve reasoning
   },
   {"role": "user", "content": "What about solar energy specifically? How does that change your analysis?"}
]

# Continue conversation with reasoning context
follow_up = client.chat.completions.create(
   model="anthropic/claude-sonnet-4",
   messages=messages,
   extra_body={
       "reasoning": {
           "max_tokens": 2000
       }
   }
)

print("Follow-up answer:")
print(follow_up.choices[0].message.content)
print("\nContinued reasoning:")
print(follow_up.choices[0].message.reasoning)

Field reasoning_details menyimpan rantai penalaran lengkap, memungkinkan model membangun analisis sebelumnya saat menjawab pertanyaan lanjutan. Ini menciptakan percakapan yang lebih koheren dan kontekstual.

Pertimbangan biaya dan penagihan

Reasoning tokens ditagihkan sebagai token keluaran, sehingga meningkatkan biaya penggunaan Anda. Namun, sering kali token ini meningkatkan kualitas respons sehingga layak secara biaya, terutama untuk tugas kompleks di mana akurasi lebih penting daripada kecepatan. Menurut dokumentasi OpenRouter, reasoning tokens dapat meningkatkan kinerja model pada problem yang menantang sambil memberikan transparansi pada proses pengambilan keputusan.

Untuk aplikasi yang memperhatikan biaya, Anda dapat menyeimbangkan kualitas reasoning terhadap pengeluaran dengan menyesuaikan level upaya atau anggaran token berdasarkan kompleksitas tugas. Pertanyaan sederhana mungkin tidak memerlukan reasoning sama sekali, sementara masalah kompleks diuntungkan dari reasoning berupaya tinggi.

Bekerja dengan Model Multimodal di OpenRouter

Sejauh ini Anda bekerja dengan teks, tetapi bagaimana jika Anda perlu menganalisis gambar atau dokumen? Mungkin Anda ingin mengajukan pertanyaan tentang sebuah bagan, mengekstrak informasi dari PDF, atau menjelaskan apa yang terjadi dalam sebuah foto. Di sinilah model multimodal hadir—mereka dapat memahami teks dan konten visual dalam satu permintaan.

Memahami kapabilitas multimodal

Alih-alih mencoba mendeskripsikan gambar dengan teks, Anda dapat mengirimkan gambarnya langsung dan mengajukan pertanyaan tentangnya. Ini membuat aplikasi Anda jauh lebih intuitif karena model melihat persis apa yang Anda kerjakan. Anda tidak perlu menebak apakah deskripsi teks Anda menangkap semua detail penting.

Anda menggunakan model multimodal melalui antarmuka yang sama seperti sebelumnya, hanya dengan parameter tambahan attachments untuk menyertakan konten visual. Lampiran file bekerja dengan semua model di OpenRouter. Bahkan jika sebuah model tidak mendukung PDF atau gambar secara native, OpenRouter secara internal akan mengurai file tersebut dan meneruskan kontennya ke model.

Bekerja dengan gambar

Anda dapat menyertakan gambar dalam permintaan melalui URL atau encoding base64. Jika gambar Anda sudah daring, pendekatan URL lebih sederhana:

response = client.chat.completions.create(
   model="openai/gpt-5-mini",
   messages=[
       {
           "role": "user",
           "content": "What's happening in this image? Describe the scene in detail."
       }
   ],
   extra_body={
       "attachments": [
           {
               "type": "image/jpeg",
               "url": "https://example.com/photo.jpg"
           }
       ]
   }
)

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

Untuk gambar lokal, Anda dapat menggunakan encoding base64:

import base64

def encode_image_to_base64(image_path):
   with open(image_path, "rb") as image_file:
       encoded_string = base64.b64encode(image_file.read()).decode('utf-8')
   return encoded_string

# Analyze a local screenshot
encoded_image = encode_image_to_base64("screenshot.png")

response = client.chat.completions.create(
   model="openai/gpt-5-mini",
   messages=[
       {
           "role": "user",
           "content": "This is a screenshot of a data dashboard. What insights can you extract from the charts and metrics shown?"
       }
   ],
   extra_body={
       "attachments": [
           {
               "type": "image/png",
               "data": encoded_image
           }
       ]
   }
)

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

Model akan melihat gambar aktual dan memberi Anda wawasan spesifik tentang apa yang terlihat, bukan hanya respons generik.

Memroses dokumen PDF

Pemrosesan PDF bekerja dengan cara yang sama namun membuka analisis dokumen. Anda dapat mengajukan pertanyaan tentang laporan, menganalisis formulir, atau mengambil informasi dari dokumen kompleks:

def encode_pdf_to_base64(pdf_path):
   with open(pdf_path, "rb") as pdf_file:
       encoded_string = base64.b64encode(pdf_file.read()).decode('utf-8')
   return encoded_string

# Analyze a research paper
encoded_pdf = encode_pdf_to_base64("research_paper.pdf")

response = client.chat.completions.create(
   model="openai/gpt-5-mini",
   messages=[
       {
           "role": "user",
           "content": "Summarize the key findings from this research paper. What are the main conclusions and methodology used?"
       }
   ],
   extra_body={
       "attachments": [
           {
               "type": "application/pdf",
               "data": encoded_pdf
           }
       ]
   }
)

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

Ini sangat cocok untuk laporan keuangan, makalah akademik, kontrak, atau PDF apa pun di mana Anda memerlukan analisis AI atas konten sebenarnya. Anda juga dapat menyertakan beberapa lampiran dalam satu permintaan jika perlu membandingkan gambar atau menganalisis beberapa dokumen sekaligus.

Biaya dan pemilihan model

Permintaan multimodal lebih mahal daripada permintaan teks saja karena Anda memproses tipe data tambahan. Gambar dan PDF memerlukan daya komputasi lebih besar, yang tercermin pada harga. Anda dapat memeriksa harga multimodal spesifik setiap model di halaman model.

Model yang berbeda memiliki keunggulan berbeda dalam konten visual. Ada yang lebih baik dalam analisis gambar detail, sementara yang lain unggul dalam pemahaman dokumen. Anda perlu bereksperimen dengan berbagai model untuk menemukan yang paling sesuai dengan kebutuhan dan anggaran Anda.

Menggunakan Keluaran Terstruktur

Saat Anda membangun aplikasi nyata, Anda memerlukan format data yang prediktabel agar kode Anda dapat menguraikannya dengan andal. Respons teks bebas sangat baik untuk antarmuka chat, tetapi buruk untuk aplikasi yang perlu mengekstrak informasi spesifik. Alih-alih menerima teks tak terduga yang harus Anda parse dengan regex atau berharap model memformatnya dengan benar, keluaran terstruktur memaksa model mengembalikan JSON terjamin dengan field dan tipe data yang tepat yang Anda butuhkan. Ini menghilangkan error parsing dan menyederhanakan kode aplikasi Anda.

Anatomi permintaan keluaran terstruktur

Keluaran terstruktur menggunakan parameter response_format dengan struktur dasar berikut:

"response_format": {
   "type": "json_schema",           # Always this for structured outputs
   "json_schema": {
       "name": "your_schema_name",  # Name for your schema
       "strict": True,              # Enforce strict compliance
       "schema": {
           # Your actual JSON schema definition goes here
       }
   }
}

Contoh analisis sentimen

Mari menelusuri contoh lengkap yang mengekstrak sentimen dari teks. Ini menunjukkan cara kerja keluaran terstruktur dalam praktik:

response = client.chat.completions.create(
   model="openai/gpt-5-mini",
   messages=[
       {"role": "user", "content": "Analyze the sentiment: 'This movie was absolutely terrible!'"}
   ],
   extra_body={
       "response_format": {
           "type": "json_schema",
           "json_schema": {
               "name": "sentiment_analysis",
               "strict": True,
               "schema": {
                   "type": "object",
                   "properties": {
                       "sentiment": {"type": "string", "enum": ["positive", "negative", "neutral"]},
                       "confidence": {"type": "number"}
                   },
                   "required": ["sentiment", "confidence"]
               }
           }
       }
   }
)

import json
result = json.loads(response.choices[0].message.content)
print(result)

{'sentiment': 'negative', 'confidence': 0.98}

Berikut yang terjadi pada skema ini:

• sentiment: Field string yang dibatasi pada tiga nilai spesifik menggunakan enum. Model tidak bisa mengembalikan apa pun di luar "positive", "negative", atau "neutral"
• confidence: Field angka untuk skor keyakinan model
• required: Kedua field harus ada dalam respons — model tidak bisa melewatkannya
• strict: True: Memaksa kepatuhan ketat terhadap struktur skema

Tanpa keluaran terstruktur, Anda mungkin mendapatkan respons seperti “Sentimennya sangat negatif dengan keyakinan tinggi” atau “Negatif (95% yakin)”. Dengan skema, Anda selalu mendapatkan JSON yang dapat diurai dan langsung digunakan dalam kode Anda.

Mengatur strict: True menegakkan skema secara ketat—model tidak bisa menyimpang dari struktur Anda. Array required menentukan field mana yang harus ada. Anda dapat menggunakan enum untuk membatasi nilai, array untuk daftar, dan tipe object bertingkat untuk data kompleks.

Kompatibilitas model

Tidak semua model mendukung keluaran terstruktur, tetapi sebagian besar model modern mendukungnya. Anda dapat memeriksa halaman model untuk kompatibilitas. Ketika sebuah model tidak mendukung keluaran terstruktur secara native, OpenRouter sering menangani pemformatannya secara internal.

Keluaran terstruktur mengubah respons AI dari teks tak terduga menjadi data andal yang dapat diandalkan aplikasi Anda. Untuk penggunaan produksi apa pun yang memerlukan ekstraksi data konsisten, fitur ini sangat penting.

Kesimpulan

Kita telah mempelajari cara mengakses ratusan model AI melalui API terpadu OpenRouter, mulai dari membuat permintaan pertama hingga menerapkan fitur seperti streaming, reasoning tokens, dan keluaran terstruktur.

Fallback otomatis dan perutean model platform ini membuat aplikasi Anda tetap andal bahkan ketika penyedia individual menghadapi masalah. Dengan pola kode yang sama, kita dapat membandingkan model, beralih penyedia, dan menemukan kecocokan sempurna untuk setiap tugas tanpa mengelola banyak kunci API.

Mulailah bereksperimen dengan permintaan sederhana dan secara bertahap coba lebih banyak fitur seiring peningkatan kebutuhan Anda. Uji model yang berbeda untuk jenis tugas yang berbeda—sebagian lebih baik untuk penulisan kreatif, sementara yang lain lebih kuat dalam analisis data atau problem penalaran.

Pengetahuan yang Anda peroleh di sini memberi Anda bekal untuk membangun aplikasi AI yang tidak terkunci pada satu penyedia mana pun, memberi kebebasan untuk beradaptasi seiring hadirnya model dan kapabilitas baru.