# Cara Menggunakan GPT-6.1 Sol API

> Source: <https://dev.to/walse/cara-menggunakan-gpt-61-sol-api-50kc>
> Published: 2026-09-30 05:05:10+00:00

Untuk memanggil API GPT-6.1 Sol, kirim permintaan `POST` ke `https://api.openai.com/v1/responses` dengan `"model": "gpt-6.1-sol"` dan token Bearer Anda. Harga standar tetap $2 untuk input dan $10 untuk output per juta token, tetapi input yang di-cache turun dari $0,20 menjadi $0,10. Migrasi dari `gpt-6-sol` umumnya cukup dengan mengganti ID model, tetapi ada perubahan penting pada `reasoning.effort`: GPT-6.1 Sol tidak menerima `none` atau `minimal`, sehingga keduanya harus dipetakan ke `low`.

OpenAI meluncurkan GPT-6.1 Sol di DevDay pada 29 September 2026. Ringkasan [DevDay 2026](https://apidog.com/id/blog/openai-devday-2026?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) mencakup peluncuran lainnya, sedangkan [apa itu GPT-6.1 Sol](https://apidog.com/id/blog/what-is-gpt-6-1-sol?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) membahas tolok ukur secara lebih detail.

Panduan ini mencakup:

`reasoning.effort`
`gpt-6-sol`
Sebagian besar spesifikasi kedua model sama. Perbedaan berikut dirangkum dari [halaman model GPT-6.1 Sol](https://developers.openai.com/api/docs/models/gpt-6.1-sol), [halaman model GPT-6 Sol](https://developers.openai.com/api/docs/models/gpt-6-sol), dan [panduan migrasi Menggunakan GPT-6](https://developers.openai.com/api/docs/guides/latest-model) dari OpenAI.

|  | `gpt-6-sol` | `gpt-6.1-sol` | Yang perlu dilakukan | 
|---|---|---|---|
| Input / output per 1M token, Standar | $2 / $10 | $2 / $10 | Tidak ada perubahan | 
| Input yang di-cache per 1M token | $0,20 | $0,10 | Hitung ulang biaya cache | 
| Penulisan cache per 1M token | $2,50 | $2,50 | Tidak ada perubahan | 
| Jendela konteks / input maks / output maks | 1.050.000 / 922.000 / 128.000 | 1.050.000 / 922.000 / 128.000 | Tidak ada perubahan | 
| Batas pengetahuan | 20 April 2026 | 30 April 2026 | Uji ulang evaluasi yang sensitif terhadap tanggal | 
| `reasoning.effort` | `none` ,`low` ,`medium` ,`high` ,`xhigh` ,`max` | `low` ,`medium` ,`high` ,`xhigh` ,`max` | Petakan `none` ke`low` , lalu evaluasi ulang | 
| Panggilan fungsi di Chat Completions | Hanya dengan `reasoning_effort: "none"` | Tidak didukung | Pindahkan panggilan alat ke Responses API | 
| Endpoint | Chat Completions, Responses, Batch | Sama | Tidak ada perubahan | 
| Rate limit | Tier 1: 500 RPM / 500K TPM; Tier 5: 15.000 RPM / 40M TPM | Sama | Tidak ada perubahan | 

Halaman GPT-6 Sol kini mengarahkan pembaca ke GPT-6.1 Sol sebagai “model Sol yang lebih baru.”

Simpan API key sebagai variabel lingkungan:

```
export OPENAI_API_KEY="your_api_key"
```

Kemudian panggil [Responses API](https://developers.openai.com/api/reference/resources/responses/methods/create):

```
curl https://api.openai.com/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-6.1-sol",
    "reasoning": {"effort": "medium"},
    "input": "List three ways a webhook retry policy can create duplicate orders. One line each."
  }'
```

Contoh menggunakan SDK Python:

``` python
from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6.1-sol",
    reasoning={"effort": "medium"},
    input="List three ways a webhook retry policy can create duplicate orders. One line each.",
)

print(response.output_text)
print(response.usage)
```

Saat memproses respons, periksa bagian berikut:

`status` bernilai `completed` jika permintaan berhasil. Jika batas output habis, nilainya dapat menjadi `incomplete`, dengan `incomplete_details.reason` bernilai `max_output_tokens`.` output` adalah array. Cari item dengan `type: "message"` dan baca konten `output_text` berdasarkan tipe, bukan indeks array.`usage.output_tokens` mencakup token penalaran yang ditagih sebagai token output.`usage.output_tokens_details.reasoning_tokens` menunjukkan jumlah token penalaran.`usage.input_tokens_details` menyediakan `cached_tokens` dan `cache_write_tokens`, yang penting untuk menghitung biaya cache.
Saat bereksperimen, [panduan penalaran](https://developers.openai.com/api/docs/guides/reasoning) menyarankan untuk menyediakan setidaknya 25.000 token bagi penalaran dan output.

Gunakan Responses API untuk permintaan yang melibatkan alat. GPT-6.1 Sol hanya mendukung Chat Completions untuk permintaan tanpa alat. Lihat juga [panduan OpenAI Responses API](https://apidog.com/id/blog/openai-responses-api?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation).

`reasoning.effort` adalah pengatur utama biaya, latensi, dan kualitas. Nilai default-nya adalah `medium`.

Menurut [panduan pemilihan model](https://developers.openai.com/api/docs/guides/model-selection) OpenAI:

| Effort | Gunakan untuk | Yang dilaporkan OpenAI untuk GPT-6.1 Sol | 
|---|---|---|
| `low` | Obrolan, ekstraksi, klasifikasi, dan beban kerja yang sebelumnya memakai `none` | Pada percakapan yang ditandai pengguna, respons dengan kesalahan faktual turun dari 11,4% pada GPT-6 Sol menjadi 7,7% | 
| `medium` | Otomasi agen dan alur kerja pemanggilan alat | AutomationBench 1.0.6: +2,2 pp dari Claude Opus 5.5 dengan biaya sekitar sepertiga; +4,8 pp dari GPT-6 Sol pada pengaturan yang sama | 
| `high` | Debugging kompleks dan perencanaan mendalam | Tidak ada klaim khusus per pengaturan | 
| `xhigh` | Hasil akhir yang rapi dan eksekusi asinkron yang panjang | Tidak ada klaim khusus per pengaturan | 
| `max` | Penggunaan komputer dan tugas sains yang sulit | OSWorld 2.0: +7 pp dari GPT-6 Sol pada `max` ; Terminal-Bench Science 0.1: $5,47 per tugas, dibandingkan $23,21 untuk Opus 5.5 dan $23,80 untuk GPT-6 Astra | 

Ada dua catatan penting:

Jika aplikasi Anda sebelumnya memakai `none` untuk latensi rendah, mulai dari `low` lalu ukur latensi, biaya, dan kualitas pada prompt produksi Anda. Untuk mengubah effort di tengah percakapan tanpa merusak cache prompt, gunakan item input `configuration_update` alih-alih mengubah `reasoning.effort` pada tingkat permintaan.

Simpan ID model dalam konfigurasi atau variabel lingkungan agar rollback mudah dilakukan:

```
export MODEL_ID="gpt-6.1-sol"
```

Kemudian gunakan variabel tersebut:

```
response = client.responses.create(
    model=os.environ["MODEL_ID"],
    reasoning={"effort": "medium"},
    input="..."
)
```

`none` dan `minimal` ke `low`
GPT-6.1 Sol tidak mendukung `none` atau `minimal`.

``` php
def normalize_effort(effort: str) -> str:
    if effort in {"none", "minimal"}:
        return "low"
    return effort
```

Uji ulang tugas representatif setelah pemetaan ini. Pada GPT-6 Astra, mengirim `none` dapat menghasilkan HTTP 400, jadi perbaiki konfigurasi ini sebelum memindahkan lalu lintas.

Jika `effort` bukan `none`, hapus parameter berikut dari kode lama:

`temperature`` top_p``top_logprobs`` logprobs` pada Chat Completions
Contoh payload yang perlu dihindari:

```
{
  "model": "gpt-6.1-sol",
  "reasoning": {"effort": "low"},
  "temperature": 0.2,
  "input": "..."
}
```

Gunakan payload tanpa parameter sampling:

```
{
  "model": "gpt-6.1-sol",
  "reasoning": {"effort": "low"},
  "input": "..."
}
```

GPT-6 Sol hanya mengizinkan panggilan fungsi di Chat Completions saat menggunakan `reasoning_effort: "none"`. Kombinasi itu tidak tersedia pada GPT-6.1 Sol.

Jika aplikasi Anda menggunakan tools atau function calling, gunakan Responses API.

Terakhir, uji ulang evaluasi yang bergantung pada informasi terkini. Batas pengetahuan berubah dari 20 April menjadi 30 April 2026. Jika Anda bermigrasi dari Astra ke Sol, lihat [panduan migrasi Astra ke Sol](https://apidog.com/id/blog/gpt-6-astra-to-sol-migration?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation).

Harga berikut adalah per 1 juta token, berdasarkan [halaman harga API](https://developers.openai.com/api/docs/pricing).

| Tingkat | Input | Input yang di-cache | Penulisan cache | Output | 
|---|---|---|---|---|
| Standar | $2,00 | $0,10 | $2,50 | $10,00 | 
| Batch | $1,00 | $0,05 | $1,25 | $5,00 | 
| Flex | $1,00 | $0,05 | $1,25 | $5,00 | 
| Fast | $4,00 | $0,20 | $5,00 | $20,00 | 
| Standar, prompt di atas 272K token input | $4,00 | $0,20 | $5,00 | $15,00 | 

[Halaman model GPT-6.1 Sol](https://developers.openai.com/api/docs/models/gpt-6.1-sol) menyatakan bahwa prompt dengan input di atas 272K token dikenai tarif input dan cache 2x serta tarif output 1,5x untuk seluruh permintaan.

Gunakan `service_tier` untuk memilih tingkat layanan:

```
{
  "model": "gpt-6.1-sol",
  "service_tier": "flex",
  "input": "..."
}
{
  "model": "gpt-6.1-sol",
  "service_tier": "fast",
  "input": "..."
}
```

`"priority"` diterima sebagai alias untuk Fast. Fast tidak tersedia dengan residensi data UE. Ultrafast untuk GPT-6.1 Sol “akan segera hadir” dan saat ini lebih luas tersedia untuk GPT-6 Astra. Lihat [mode Ultrafast OpenAI](https://apidog.com/id/blog/openai-ultrafast-mode?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation).

Untuk pekerjaan asinkron atau semalam, gunakan Batch API. Lihat [panduan OpenAI Batch API](https://apidog.com/id/blog/openai-batch-api?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation).

Pada GPT-6.1 Sol, pembacaan cache berharga 0,05x tarif input, dibandingkan 0,1x pada GPT-6 Sol. Penulisan cache tetap 1,25x tarif input pada kedua model, sesuai [panduan caching prompt](https://developers.openai.com/api/docs/guides/prompt-caching).

Misalnya, Anda memiliki prompt sistem 50.000 token yang digunakan kembali pada 1.000 permintaan:

`$0,125` pada kedua model.`$9,99`.`$5,00`.
Prefiks yang dapat di-cache minimum adalah 1.024 token terlihat. Prefiks cache tetap memenuhi syarat setidaknya selama 30 menit setelah penulisan atau penggunaan terakhir. Untuk strategi breakpoint, lihat [caching prompt GPT-6](https://apidog.com/id/blog/gpt-6-prompt-caching-90-percent?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation).

Jangan memindahkan produksi hanya berdasarkan harga atau benchmark. Kirim permintaan tersimpan yang sama ke kedua ID model, lalu bandingkan hasilnya.

Di [Apidog](https://apidog.com/?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation):

Buat environment dengan:

`OPENAI_API_KEY` sebagai secret`MODEL_ID=gpt-6-sol`` EFFORT=medium`
Buat request berikut dan simpan:

```
POST https://api.openai.com/v1/responses
Authorization: Bearer {{OPENAI_API_KEY}}
Content-Type: application/json
{
  "model": "{{MODEL_ID}}",
  "reasoning": {"effort": "{{EFFORT}}"},
  "max_output_tokens": 25000,
  "input": "Return a JSON object with keys risk and fix for this policy: retry any 5xx three times with no idempotency key."
}
```

Tambahkan assertion untuk:

`200`
`$.status` sama dengan `$.output[*].type` berisi `message`
`$.usage.output_tokens` lebih besar dari `0`
`$.usage.output_tokens_details.reasoning_tokens` ada`risk` dan `fix`
Tambahkan skrip post-processor untuk menghitung biaya per panggilan:

``` js
const u = pm.response.json().usage;
const d = u.input_tokens_details || {};
const cached = d.cached_tokens || 0;
const writes = d.cache_write_tokens || 0;
const model = pm.environment.get("MODEL_ID");

const cachedRate = model === "gpt-6.1-sol" ? 0.10 : 0.20;

const cost = (
  (u.input_tokens - cached - writes) * 2 +
  cached * cachedRate +
  writes * 2.5 +
  u.output_tokens * 10
) / 1e6;

console.log(model, "cost per call $", cost.toFixed(5));
```

`gpt-6.1-sol` dan jalankan kembali.
Bandingkan:

`reasoning_tokens`` output_tokens`
Jika Anda memetakan `none` ke `low`, jalankan baseline dengan `none` pada GPT-6 Sol dan kandidat dengan `low` pada GPT-6.1 Sol.

Masukkan request dan prompt produksi Anda ke dalam skenario pengujian. Kemudian jalankan kedua variasi dari Apidog CLI:

```
npm install -g apidog-cli

apidog run --access-token "$APIDOG_ACCESS_TOKEN" \
  -t "$SCENARIO_ID" \
  -e "$ENV_ID" \
  --env-var "MODEL_ID=gpt-6-sol" \
  -r cli,junit

apidog run --access-token "$APIDOG_ACCESS_TOKEN" \
  -t "$SCENARIO_ID" \
  -e "$ENV_ID" \
  --env-var "MODEL_ID=gpt-6.1-sol" \
  -r cli,junit
```

`--env-var` menimpa variabel hanya untuk satu eksekusi, sehingga satu skenario dapat menguji kedua model. Assertion yang gagal akan menggagalkan pekerjaan CI, sementara laporan JUnit memberi hasil dua eksekusi yang dapat dibandingkan.

Untuk assertion pada output yang berbeda antar-eksekusi, lihat [menguji agen AI non-deterministik](https://apidog.com/id/blog/testing-non-deterministic-ai-agents?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation).

Tidak. Keduanya berharga $2 untuk input dan $10 untuk output per 1 juta token. Input GPT-6.1 Sol yang di-cache berharga $0,10, dibandingkan $0,20 pada GPT-6 Sol.

`reasoning.effort: "none"`?
GPT-6.1 Sol tidak mendukung `none` maupun `minimal`. Petakan keduanya ke `low`, hapus `temperature` dan `top_p`, lalu jalankan ulang evaluasi sebelum memindahkan lalu lintas.

Bisa, untuk permintaan tanpa alat. Panggilan alat memerlukan Responses API.

Tidak. Panggilan API ditagih per token sejak permintaan pertama. Lihat [Apakah GPT-6.1 Sol gratis?](https://apidog.com/id/blog/gpt-6-1-sol-free?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) untuk rute penggunaan termurah.

Simpan satu request representatif, jalankan di `gpt-6-sol` dengan effort saat ini, lalu jalankan kembali di `gpt-6.1-sol`. Bandingkan `usage`, biaya, latensi, dan output menggunakan prompt dari lalu lintas aplikasi Anda sendiri.

[Unduh Apidog](https://apidog.com/download?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) untuk menyimpan kedua eksekusi sebagai assertion yang dapat dijalankan ulang di CI. Jika Anda juga mempertimbangkan Anthropic, lihat [GPT-6.1 Sol vs Claude Sonnet 5.5](https://apidog.com/id/blog/gpt-6-1-sol-vs-claude-sonnet-5-5?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation).