DEV Community: Walse

Cara Menggunakan Seedance 2.0 API 2026

Walse — Sat, 04 Apr 2026 13:04:51 +0000

Ringkasan

API Seedance 2.0 resmi dirilis pada 2 April 2026 via Volcengine Ark. Workflow-nya: kirim tugas pembuatan video via POST, lalu polling endpoint GET sampai status succeeded. Mendukung teks-ke-video, gambar-ke-video, kontrol bingkai awal/akhir, referensi multimodal, dan pembuatan audio asli. Video 1080p 5 detik sekitar $0.93. Download hasil dalam 24 jam sebelum link expired.

Coba Apidog hari ini

Hypereal AI

Coba Hypereal AI

Pendahuluan

Pada 2 April 2026, Volcengine Ark (ByteDance) merilis API resmi Seedance 2.0. Sebelum itu, hanya bisa generate video via web console. Panduan ini langsung membahas penggunaan API untuk developer, bukan UI manual.

💡API ini menerapkan pola tugas asinkron: POST buat tugas, terima ID, lalu polling GET sampai selesai. Uji pola ini sebelum produksi. Skenario Uji Apidog memudahkan chaining POST, ekstraksi ID, polling GET, serta validasi URL video. Lihat bagian Apidog untuk langkah detail pengujian.

Artikel ini membahas tipe input yang didukung, perhitungan harga per token respons, serta error paling umum.

Apa itu Seedance 2.0?

Seedance 2.0 adalah model video generator ByteDance di Volcengine Ark dengan ID doubao-seedance-2-0-260128 (standar) dan doubao-seedance-2-0-fast-260128 (lebih cepat, kualitas lebih rendah).

Fitur utama vs versi 1.5:

Kontrol bingkai awal-dan-akhir (dua gambar pembatas)
Input multimodal: gambar, video, audio dalam satu request
Pembuatan audio asli (dialog, SFX, ambien, musik)
Lip sync lebih dari 8 bahasa
Kontrol kamera via natural language (dolly, tracking, crane, dst)
Output maksimal 15 detik, hingga 2K, 24fps, rasio 1:1–21:9

Perubahan: panduan UI vs API resmi

Panduan sebelumnya seperti ini membahas web console. API resmi (rilis 2 April 2026) memungkinkan otomatisasi penuh dari bahasa pemrograman apa pun. Fokus artikel ini adalah implementasi melalui API untuk integrasi ke produk Anda.

Prasyarat

Daftar akun di volcengine.com.

Akses Ark console:

https://console.volcengine.com/ark/region:ark+cn-beijing/apikey

Buat API key, lalu ekspor ke environment variable:
```
export ARK_API_KEY="your-api-key-here"
```
Setiap request butuh header:
```
Authorization: Bearer YOUR_ARK_API_KEY
```

Akun baru mendapatkan kredit trial gratis, cukup untuk ±8x generate full 15 detik 1080p.

Teks-ke-Video: Permintaan Pertama

Endpoint dasar API Seedance:

https://ark.cn-beijing.volces.com/api/v3

Kirim tugas T2V via POST ke /v1/contents/generations/tasks.

Contoh cURL

curl -X POST "https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $ARK_API_KEY" \
  -d '{
    "model": "doubao-seedance-2-0-260128",
    "content": [
      {
        "type": "text",
        "text": "A golden retriever running through a sunlit wheat field, wide tracking shot, cinematic"
      }
    ],
    "resolution": "1080p",
    "ratio": "16:9",
    "duration": 5,
    "watermark": false
  }'

Respons: ID tugas

{"id": "cgt-2025xxxxxxxx-xxxx"}

Contoh Python (SDK Resmi)

Instal SDK:

pip install volcenginesdkarkruntime

Kirim tugas:

import os
from volcenginesdkarkruntime import Ark

client = Ark(api_key=os.environ.get("ARK_API_KEY"))

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "A golden retriever running through a sunlit wheat field, wide tracking shot, cinematic"
        }
    ],
    resolution="1080p",
    ratio="16:9",
    duration=5,
    watermark=False,
)

print(resp.id)

Simpan ID tugas untuk polling.

Pola Tugas Asinkron: Kirim, Polling, Unduh

Pembuatan video Seedance butuh waktu (5 detik = 1-2 menit). Workflow:

queued -> running -> succeeded
                  -> failed
                  -> expired
                  -> cancelled

Polling GET endpoint sampai status berubah dari queued/running.

Loop Polling Python

import os
import time
import requests
from volcenginesdkarkruntime import Ark

client = Ark(api_key=os.environ.get("ARK_API_KEY"))

# Step 1: Submit
resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {"type": "text", "text": "Aerial shot of a mountain lake at sunrise, slow dolly forward"}
    ],
    resolution="1080p",
    ratio="16:9",
    duration=5,
    watermark=False,
)

task_id = resp.id
print(f"Task submitted: {task_id}")

# Step 2: Poll dengan exponential backoff
wait = 10
while True:
    result = client.content_generation.tasks.get(task_id=task_id)
    status = result.status
    print(f"Status: {status}")

    if status == "succeeded":
        video_url = result.content.video_url
        print(f"Video URL: {video_url}")
        break
    elif status in ("failed", "expired", "cancelled"):
        print(f"Task ended with status: {status}")
        break

    time.sleep(wait)
    wait = min(wait * 2, 60)

# Step 3: Download segera
if status == "succeeded":
    response = requests.get(video_url, stream=True)
    with open("output.mp4", "wb") as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)
    print("Downloaded: output.mp4")

Penundaan eksponensial mencegah API overload.

Gambar-ke-Video (I2V): Animasi Gambar Diam

Tambahkan object image_url ke array content untuk set gambar awal.

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "The woman slowly turns her head and smiles at the camera"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/portrait.jpg"}
        }
    ],
    ratio="adaptive",
    duration=5,
    watermark=False,
)

Set ratio ke "adaptive" agar mengikuti aspek gambar input. Maks 30MB/gambar, hingga 9 gambar/request.

Bingkai Awal dan Akhir: Kontrol Frame Pembatas

Seedance 2.0 mendukung input dua gambar (awal–akhir) plus prompt teks. Model menghasilkan transisi di antaranya.

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "The flower blooms from bud to full open, macro lens, soft light"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/flower-bud.jpg"}
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/flower-open.jpg"}
        }
    ],
    ratio="adaptive",
    duration=8,
    watermark=False,
)

Urutan gambar: [pertama, terakhir]. Gunakan return_last_frame: true jika ingin chaining klip berikutnya.

Referensi Multimodal: Gabung Gambar, Video, dan Audio

Array content bisa berisi:

{"type": "text", "text": "..."}
{"type": "image_url", "image_url": {"url": "..."}}
{"type": "video_url", "video_url": {"url": "..."}}
{"type": "audio_url", "audio_url": {"url": "..."}}

Batas:

9 gambar (max 30MB/pcs)
3 video (2–15 detik, max 50MB/pcs)
3 audio (MP3, max 15MB/pcs)

Contoh:

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "Match the visual style of the reference clip and add the provided background audio"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/style-reference.jpg"}
        },
        {
            "type": "video_url",
            "video_url": {"url": "https://example.com/motion-reference.mp4"}
        },
        {
            "type": "audio_url",
            "audio_url": {"url": "https://example.com/background-music.mp3"}
        }
    ],
    duration=10,
    ratio="16:9",
    watermark=False,
)

Jika menyertakan referensi video, biaya per token lebih murah (V2V).

Pembuatan Audio Asli

Aktifkan generate_audio: true untuk auto generate audio sinkron dengan video.

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "A street musician plays guitar outside a cafe in Paris, crowds passing by, city sounds"
        }
    ],
    resolution="1080p",
    ratio="16:9",
    duration=10,
    generate_audio=True,
    watermark=False,
)

Audio: dialog, SFX, suara ambien, musik. Lip sync >8 bahasa. Biaya token sedikit naik dibanding video tanpa suara.

Kontrol Resolusi, Rasio, Durasi

resolusi: "480p", "720p", "1080p", "2K" (default: 1080p)
rasio: "16:9", "9:16", "4:3", "3:4", "21:9", "1:1", "adaptive"
durasi: integer 4–15 detik (default: 5)

Model fast (doubao-seedance-2-0-fast-260128) lebih cepat, kualitas lebih rendah. Gunakan fast untuk iterasi prompt, standar untuk produksi.

Pilih Seedance 2.0 jika butuh audio-video asli, frame control, atau input multimodal. Untuk T2V sederhana, model fast 480p = opsi termurah.

Membaca Biaya dari Respons

Respons sukses berisi:

{
  "usage": {
    "completion_tokens": 246840,
    "total_tokens": 246840
  }
}

Konsumsi token tergantung durasi dan resolusi. Estimasi:

1080p 15 detik: ~308.880 token
1080p 5 detik: ~102.960 token

Harga:

T2V/I2V 1080p: 46 yuan/1 juta token (~$6.40)
V2V: 28 yuan/1 juta token (~$3.90)

Contoh:

1080p 5 detik ≈ 0.47 yuan ≈ $0.93
1080p 10 detik ≈ 9.47 yuan ≈ $1.97

Bangun pelacakan biaya dengan membaca completion_tokens × tarif per jenis tugas.

Penting: Unduh Video dalam 24 Jam

URL video_url yang diberikan hanya valid 24 jam. Setelah itu, file hilang (403). Download segera setelah status succeeded. Kolom execution_expires_after memberi tahu window expire dalam detik (tugas bertahan max 7 hari, file video hanya 24 jam).

Cara Menguji API Seedance dengan Apidog

Pola asinkron perlu dua request berantai. Apidog mendukung chaining dengan Skenario Uji.

Langkah Implementasi:

1. Buat Skenario Uji

Modul Tests → New Scenario "Pembuatan video Seedance 2.0"
Set env var ARK_API_KEY di Environment Settings

2. Tambah Request POST

Endpoint: https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks
Header: Authorization: Bearer {{ARK_API_KEY}}
Body: JSON tugas

3. Extract Variable

Extract dari body response dengan JSONPath $.id → simpan ke var TASK_ID

4. Tambah Prosesor Tunggu

Delay 30 detik setelah submit

5. Polling Loop (For Max 20)

GET https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks/{{TASK_ID}}
Tunggu 10 detik tiap iterasi
Break If: $.status == "succeeded" atau $.status == "failed"

6. Assertion

$.status == "succeeded"
$.content.video_url tidak kosong

Jalankan skenario, Apidog akan tunjukkan semua langkah, respons, dan hasil assertion. Anda juga bisa import endpoint Seedance dari cURL langsung.

Rincian Harga: Biaya Video 10 Detik

Harga token pay-as-you-go, tanpa biaya bulanan.

Jenis Tugas	Tarif (per 1 Juta token)
T2V / I2V pada 1080p	46 yuan (~$6.40)
V2V (input referensi video)	28 yuan (~$3.90)

Estimasi biaya (1080p):

Durasi	Estimasi Token	Biaya (T2V/I2V)
5 detik	~103.000	~0.66 yuan / ~$0.93
10 detik	~206.000	~9.48 yuan / ~$1.32
15 detik	~309.000	~14.21 yuan / ~$1.97

Trial gratis cukup untuk ±8x generate 15 detik penuh. Untuk development, pakai 720p atau 480p, naikkan ke 1080p/2K hanya untuk produksi.

Kesalahan Umum dan Solusi

429 Terlalu Banyak Permintaan

Batas konkurensi tercapai (bukan rate limit RPM). Gunakan exponential backoff (tunggu 10 detik, gandakan tiap retry, max 60 detik).

status: "failed"

Model gagal generate video. Cek prompt (jangan mengandung konten terlarang), gambar rusak/terlalu besar, atau kombinasi parameter invalid.

status: "expired"

Tugas timeout (misal karena antrean saat traffic tinggi). Submit ulang, tidak bisa resume.

403 pada video_url

URL sudah expired (lewat 24 jam). Regenerasi dengan parameter dan seed sama (jika masih disimpan).

Reproduksi dengan seed

Simpan nilai seed dari respons, kirim ulang pada request baru untuk mencoba replikasi output.

Kesimpulan

API Seedance 2.0 menawarkan kontrol terprogram penuh atas pembuatan video AI tingkat lanjut. Pola kerja: submit via POST → polling GET → download segera. Manfaatkan input multimodal, audio asli, frame control untuk workflow yang tidak bisa dilakukan via UI. Implementasikan pengujian dengan Apidog untuk memastikan reliability pipeline sebelum produksi.

FAQ

T: Apa beda doubao-seedance-2-0-260128 dan doubao-seedance-2-0-fast-260128?

StAndar = kualitas tinggi (untuk produksi), fast = lebih cepat, kualitas turun (untuk rapid prototyping).

T: Bisa dipakai di luar Tiongkok?

Endpoint di Beijing, developer global bisa akses, tapi ada latency lebih tinggi. Cek terms Volcengine untuk batasan akun.

T: Cara chaining beberapa klip jadi video panjang?

Set return_last_frame: true pada tiap klip, ambil frame terakhir untuk jadi input awal klip selanjutnya. Gabung semua klip di aplikasi video editing.

T: Generate audio asli lebih mahal?

Token usage naik moderat karena proses audio-video bersama.

T: Bisa pakai webhook, bukan polling?

Bisa. Kirim callback_url di request, API akan POST ke URL tsb saat status berubah.

T: Melebihi 9 gambar?

API akan return error 400. Kurangi jumlah gambar ≤9.

T: Apakah seed selalu reproduksi video identik?

Seed mendekati reproduksi, tapi tidak 100% jika parameter/model berubah.

T: Cara tracking biaya per tugas?

Ambil completion_tokens dari respons, kalikan dengan tarif. Simpan di DB sendiri, tidak ada dashboard built-in.

Cara Menggunakan Grok Text to Video API (Panduan Lengkap)

Walse — Fri, 03 Apr 2026 08:47:26 +0000

Ringkasan

API Grok text-to-video memungkinkan Anda menghasilkan video dari prompt teks. Langkah dasarnya: lakukan POST /v1/videos/generations, Anda akan menerima request_id, lalu polling dengan GET /v1/videos/{request_id} sampai status-nya "done". Model yang digunakan adalah grok-imagine-video, mulai dari $0.05 per detik untuk resolusi 480p. xAI Python SDK sudah menangani polling otomatis.

Coba Apidog hari ini

Pendahuluan

Pada Januari 2026 saja, xAI menghasilkan 1,2 miliar video setelah peluncuran API Grok text-to-video. Model ini langsung menduduki peringkat 1 di leaderboard text-to-video Artificial Analysis. Inilah bukti infrastrukturnya siap untuk skala besar.

Panduan berikut langsung praktik: membuat permintaan pertama, polling hasil, pengaturan parameter, dan menulis prompt yang efektif. Anda juga akan belajar penggunaan gambar referensi, memperpanjang/mengedit video, serta menentukan kapan text-to-video tepat digunakan.

💡 API bersifat async: Frontend tidak bisa menunggu video selesai sebelum merender. Untuk membangun UI video generator, Anda perlu alur polling yang efisien agar tidak membuang kredit saat development. Smart Mock Apidog bisa memalsukan endpoint pembuatan dan polling, sehingga tim frontend dapat membangun UI tanpa menunggu backend siap. Unduh Apidog gratis untuk pengujian API Grok Anda.

Apa itu API Grok text to video?

API Grok text-to-video adalah bagian dari suite media xAI di https://api.x.ai. Anda cukup mengirim prompt teks, model grok-imagine-video akan menghasilkan video tanpa butuh gambar sumber.

Tersedia juga endpoint pembuatan gambar sinkron (POST /v1/images/generations, model grok-imagine-image, $0.02/gambar) serta endpoint untuk memperpanjang atau mengedit video.

Endpoint text-to-video hanya membutuhkan teks. Model membangun visual, gerak, dan gaya dari deskripsi Anda. Jika ingin menganimasikan gambar sumber, cek panduan API Grok image to video.

Cara Kerja Pembuatan Text-to-Video (Async Pattern)

Berbeda dari API sinkron, proses pembuatan video membutuhkan waktu sehingga menggunakan pola async:

Kirim POST dengan prompt.
Dapatkan request_id secara instan.
Video diproses di server xAI.
Polling endpoint GET dengan request_id berulang kali.
Jika status berubah ke "done", respons berisi URL video.

Frontend Anda harus menangani status menengah, misal menampilkan loading indicator sampai URL video tersedia.

Prasyarat

Sebelum mulai:

Akun xAI: Daftar di console.x.ai.
API Key: Buat API key di menu API Keys, simpan, dan gunakan sebagai Bearer token di header permintaan.

Set variabel environment agar key tidak hardcode:

export XAI_API_KEY="your_api_key_here"

Opsional: Install xAI Python SDK (cara termudah integrasi):

pip install xai-sdk

Permintaan Text-to-Video Pertama Anda

Endpoint: POST https://api.x.ai/v1/videos/generations. Field wajib: model dan prompt.

Menggunakan curl

curl -X POST https://api.x.ai/v1/videos/generations \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "prompt": "A golden retriever running through autumn leaves in slow motion, cinematic lighting"
  }'

Respons:

{
  "request_id": "d97415a1-5796-b7ec-379f-4e6819e08fdf"
}

Menggunakan Python (requests)

import requests
import os

API_KEY = os.environ["XAI_API_KEY"]
BASE_URL = "https://api.x.ai"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

payload = {
    "model": "grok-imagine-video",
    "prompt": "A golden retriever running through autumn leaves in slow motion, cinematic lighting"
}

response = requests.post(
    f"{BASE_URL}/v1/videos/generations",
    headers=headers,
    json=payload
)

data = response.json()
request_id = data["request_id"]
print(f"Generation started. Request ID: {request_id}")

Polling untuk Hasil Video

Setelah mendapat request_id, polling endpoint GET /v1/videos/{request_id} hingga status "done".

Status yang mungkin:

"processing": masih diproses
"done": selesai, URL tersedia
"failed": gagal

Contoh loop polling Python:

import requests
import time
import os

API_KEY = os.environ["XAI_API_KEY"]
BASE_URL = "https://api.x.ai"

headers = {
    "Authorization": f"Bearer {API_KEY}"
}

def poll_video(request_id: str, interval: int = 5, max_attempts: int = 60) -> dict:
    url = f"{BASE_URL}/v1/videos/{request_id}"
    for attempt in range(max_attempts):
        response = requests.get(url, headers=headers)
        data = response.json()
        status = data.get("status")
        progress = data.get("progress", 0)
        print(f"Attempt {attempt + 1}: status={status}, progress={progress}%")
        if status == "done":
            return data
        elif status == "failed":
            raise RuntimeError(f"Video generation failed: {data}")
        time.sleep(interval)
    raise TimeoutError(f"Video not ready after {max_attempts} attempts")

def generate_video(prompt: str) -> str:
    response = requests.post(
        f"{BASE_URL}/v1/videos/generations",
        headers={**headers, "Content-Type": "application/json"},
        json={"model": "grok-imagine-video", "prompt": prompt}
    )
    request_id = response.json()["request_id"]
    print(f"Request ID: {request_id}")
    result = poll_video(request_id)
    video_url = result["video"]["url"]
    print(f"Video ready: {video_url}")
    return video_url

video_url = generate_video(
    "A timelapse of a city skyline at sunset transitioning to night, aerial view"
)

Contoh respons polling selesai:

{
  "status": "done",
  "video": {
    "url": "https://vidgen.x.ai/....mp4",
    "duration": 8,
    "respect_moderation": true
  },
  "progress": 100,
  "usage": {
    "cost_in_usd_ticks": 500000000
  }
}

Menggunakan xAI Python SDK

Gunakan SDK untuk otomatisasi polling:

from xai_sdk import Client
import os

client = Client(api_key=os.environ["XAI_API_KEY"])

result = client.video.generate(
    model="grok-imagine-video",
    prompt="A golden retriever running through autumn leaves in slow motion",
    duration=8,
    resolution="720p",
    aspect_ratio="16:9"
)

print(f"Video URL: {result.video.url}")
print(f"Duration: {result.video.duration}s")

Gunakan SDK untuk integrasi cepat. Untuk kontrol lebih lanjut (retry, interval polling custom), gunakan permintaan mentah.

Menulis Prompt yang Efektif

Prompt yang baik sangat menentukan hasil. Berikut struktur yang direkomendasikan:

Deskripsi Adegan

Gabungkan subjek dan latar. Contoh:

Cangkir kopi keramik putih di atas meja kayu di samping jendela yang basah karena hujan

Gerakan

Jelaskan apa yang bergerak dan bagaimana:

Kamera perlahan mengitari cangkir saat uap mengepul ke atas

Gaya Kamera

Gunakan istilah sinematografi:

close-up, tracking shot, overhead drone view, dll.

Pencahayaan & Suasana

Gabungkan istilah seperti:

golden hour, overcast, neon-lit, studio three-point lighting, dst.

Referensi Gaya

Tambahkan gaya visual:

sinematik, dokumenter, anime, stop-motion, dst.

Contoh Struktur Prompt

A lone astronaut floats past the International Space Station,
tether drifting behind them. The camera tracks slowly
alongside, showing Earth below. Cinematic, IMAX quality,
warm sunrise light reflecting off the visor.

Kontrol Resolusi, Durasi, dan Rasio Aspek

Anda bisa atur dengan parameter opsional:

Durasi

"duration": 10

Rentang: 1-15 detik. Default: 6 detik.

Resolusi

"resolution": "720p"

Pilihan: "480p" (default), "720p".

Rasio Aspek

"aspect_ratio": "9:16"

Pilihan:

Rasio	Terbaik untuk
16:9	Desktop, YouTube, presentasi
9:16	TikTok, Reels, mobile
1:1	Instagram feed, social card
4:3	Video klasik, presentasi
3:4	Konten mobile portrait
3:2	Standar foto
2:3	Fotografi potret

Contoh Permintaan Lengkap

curl -X POST https://api.x.ai/v1/videos/generations \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "prompt": "A coastal town at dawn, waves breaking gently on a rocky shore",
    "duration": 10,
    "resolution": "720p",
    "aspect_ratio": "16:9"
  }'

Menggunakan Gambar Referensi untuk Gaya Video

Parameter reference_images menerima array max 7 URL gambar.

Contoh:

{
  "model": "grok-imagine-video",
  "prompt": "A coastal town at dawn, waves breaking gently on a rocky shore",
  "reference_images": [
    {"url": "https://example.com/my-style-reference.jpg"},
    {"url": "https://example.com/color-palette-reference.jpg"}
  ]
}

Gunakan gambar referensi dengan gaya yang konsisten untuk hasil terbaik.

Berbeda dengan image-to-video, prompt tetap memimpin adegan, gambar hanya memandu gaya visual.

Memperpanjang & Mengedit Video

xAI menyediakan endpoint tambahan:

Memperpanjang Video

POST /v1/videos/extensions

Tambahkan rekaman ke video eksisting dengan request_id dan prompt baru.

Mengedit Video

POST /v1/videos/edits

Modifikasi video berdasarkan instruksi teks.

Kedua endpoint ini juga async: dapatkan request_id, lalu polling dengan GET /v1/videos/{request_id}.

Membaca Biaya dari Respons API

Cek biaya dari field usage:

"usage": {
  "cost_in_usd_ticks": 500000000
}

Konversi ke USD:

cost_in_usd = result["usage"]["cost_in_usd_ticks"] / 10_000_000
print(f"Cost: ${cost_in_usd:.4f}")
# Output: Cost: $0.0500

Referensi Harga

Resolusi	Harga per detik	Klip 10 detik
480p	$0.05	$0.50
720p	$0.07	$0.70

Lacak penggunaan dengan menyimpan cost_in_usd_ticks dari setiap respons selesai.

Cara Menguji API Video Grok dengan Apidog

Polling async menuntut frontend menangani status memuat, sukses, error. Mocking dengan Apidog sangat disarankan.

Kasus Penggunaan 1: Smart Mock untuk Pengembangan Frontend

Smart Mock Apidog bisa memberikan respons palsu sesuai skema endpoint Anda.

Mock endpoint pembuatan: Buat endpoint POST /v1/videos/generations dengan respons request_id string.

  {
    "request_id": "d97415a1-5796-b7ec-379f-4e6819e08fdf"
  }

Mock endpoint polling: Buat GET /v1/videos/{request_id} dengan respons mock status "done" dan URL video placeholder.

  {
    "status": "done",
    "video": {
      "url": "https://vidgen.x.ai/mock-video-12345.mp4",
      "duration": 8,
      "respect_moderation": true
    },
    "progress": 100,
    "usage": {
      "cost_in_usd_ticks": 400000000
    }
  }

Frontend dapat menguji seluruh UI tanpa menghabiskan kredit API. Respons mock bisa diubah ke "failed" untuk menguji error handling.

Kasus Penggunaan 2: Skenario Pengujian untuk Loop Polling

Testing otomatis dengan Skenario Pengujian Apidog:

Tambah permintaan pembuatan: Tambah POST /v1/videos/generations dan ekstrak request_id ke variabel, misal videoRequestId.
Tambah loop polling: Tambah GET /v1/videos/{{videoRequestId}} dalam loop For, berhenti jika response.body.status == "done". Tambahkan Wait 5 detik per iterasi.
Assert hasil: Setelah loop, pastikan $.video.url tidak kosong.

Testing async workflow jadi otomatis dan dapat dijalankan di CI.

Text-to-Video vs Image-to-Video: Kapan Menggunakannya

Dua mode, model sama (grok-imagine-video), tujuan berbeda.

Gunakan text-to-video jika:

Konten orisinal dari konsep/skrip
Ingin model punya kontrol kreatif penuh
Alat content creation berbasis prompt
Tidak ada gambar sumber

Gunakan image-to-video jika:

Ada foto/ilustrasi/brand asset untuk dianimasikan
Harus mempertahankan detail visual
Animasi konsisten dari gambar terkait
Ingin menganimasikan karya seni/foto sendiri

Text-to-video membangun adegan dari awal. Image-to-video membuat gambar bergerak.

Panduan lengkap: API Grok image to video.

Jika pengguna upload gambar, gunakan POST /v1/images/generations. Jika hanya prompt, gunakan POST /v1/videos/generations.

Kesalahan Umum dan Solusinya

401 Unauthorized:

API key salah/hilang/kedaluwarsa. Pastikan header Authorization: Bearer YOUR_XAI_API_KEY tanpa spasi ekstra dan key masih aktif.

429 Too Many Requests:

Kena rate limit (max 60 req/min, 1 req/detik). Tambahkan delay polling minimal 5 detik.

status: "failed":

Prompt gagal/moderasi. Kolom respect_moderation menandakan moderasi aktif. Revisi prompt Anda.

URL video 404:

URL video sementara. Segera download ke storage Anda.

Video kosong/beku:

Prompt terlalu umum/tanpa isyarat gerakan. Tambahkan deskripsi gerakan yang jelas.

Polling lambat:

720p/durasi panjang butuh waktu lebih lama. Untuk development, gunakan 480p & durasi pendek.

Kesimpulan

API Grok text-to-video memudahkan konversi teks ke video. Kirim prompt, dapatkan request_id, polling hingga selesai, ambil MP4. Async pattern adalah kunci. Jika loop polling sudah jalan, parameter lain bisa disesuaikan dengan mudah.

Untuk produksi, lacak biaya via cost_in_usd_ticks di setiap respons. Mock endpoint di Apidog saat development untuk UI frontend yang lebih gesit. Gunakan Test Scenarios agar polling logic tetap stabil seiring integrasi berkembang.

FAQ

Model apa untuk text-to-video?

Gunakan grok-imagine-video di field model saat POST ke /v1/videos/generations.

Berapa lama pembuatan video?

Tergantung durasi & resolusi. 480p pendek <30 detik, 720p panjang bisa beberapa menit. Polling setiap 5-10 detik.

Bisakah video >15 detik?

Tidak dalam satu permintaan. Maksimal 15 detik. Untuk lebih panjang, gunakan POST /v1/videos/extensions.

Bagaimana cara download video?

Ambil URL dari result.video.url di respons polling selesai. Download segera karena URL sementara.

Jika prompt kena moderasi?

Status polling jadi "failed". Kolom respect_moderation menandakan moderasi aktif. Revisi prompt dan coba lagi.

Apakah ada free tier?

xAI mengenakan biaya per detik video. Tidak ada free tier spesifik. Cek console.x.ai untuk promo kredit akun baru.

Apa beda reference_images dengan gambar sumber?

reference_images hanya memandu gaya visual. Untuk image-to-video, gambar sumber jadi frame awal.

Tes polling loop tanpa menghabiskan kredit?

Gunakan Smart Mock Apidog untuk membuat endpoint pembuatan dan polling palsu. Skema bisa mengembalikan status "processing" dan "done" agar kode polling bisa dites tanpa akses API asli.

Cara Menggunakan API Grok Image ke Video: Panduan Lengkap Langkah demi Langkah

Walse — Fri, 03 Apr 2026 08:42:30 +0000

TL;DR

API Grok image-to-video dengan model grok-imagine-video dapat menganimasikan gambar statis menjadi klip video. Kirim POST berisi URL gambar, prompt, dan pengaturan opsional ke https://api.x.ai/v1/videos/generations. Anda akan menerima request_id untuk polling status via GET /v1/videos/{request_id} hingga status menjadi "done". Durasi output 1–15 detik. Harga mulai $0.05/detik untuk 480p.

Coba Apidog hari ini

Pengantar

Pada 28 Januari 2026, xAI meluncurkan model grok-imagine-video untuk akses API publik. Dalam bulan pertamanya, model ini menghasilkan 1,2 miliar video dan menempati peringkat #1 text-to-video di Artificial Analysis. Image-to-video adalah fitur kunci: cukup kirim foto dan prompt deskriptif ke API, lalu dapatkan klip animasi siap unduh (MP4).

Karena proses asinkron, pengujian integrasi tidak berhenti di POST 200. Anda harus memastikan loop polling menangani status "processing", "done", dan "failed" di kondisi nyata.

Skenario Uji Apidog memudahkan alur ini: chaining POST ke /v1/videos/generations, ekstraksi request_id, polling berulang hingga status == "done", dan validasi URL video. Ikuti panduan ini untuk menguji otomatis dengan Apidog.

Apa itu API Grok Image-to-Video?

API Grok image-to-video adalah bagian dari produk generasi video xAI. Model grok-imagine-video menerima gambar sebagai bingkai pertama video output. Model memproses konten gambar dan prompt, lalu menghasilkan gerakan alami untuk animasi.

Endpoint:

POST https://api.x.ai/v1/videos/generations

Autentikasi:

Authorization: Bearer YOUR_XAI_API_KEY

Ambil API key dari konsol xAI. Endpoint ini juga mendukung text-to-video (tanpa parameter image), ekstensi video, dan pengeditan.

Cara Kerja Proses Image-to-Video

Parameter image pada request menentukan bingkai pertama video. Model memulai dari gambar tersebut dan memprediksi gerakan berdasarkan prompt.

Contoh: Kirim foto danau pegunungan saat matahari terbit, prompt "riak lembut menyebar di permukaan air saat kabut pagi melayang". Bingkai pertama = foto asli. Bingkai selanjutnya = air/kabut bergerak.

Kapan pakai image-to-video:

Punya foto produk, lanskap, atau potret yang ingin digerakkan
Membutuhkan identitas visual konsisten di frame pertama
Ingin gerakan terasa nyata atau spesifik

Kapan pakai text-to-video:

Tidak ada gambar referensi
Komposisi adegan ingin ditentukan model
Kecepatan iterasi lebih penting dari presisi

Prasyarat

Sebelum mulai, siapkan:

Akun xAI di console.x.ai
API Key dari konsol (simpan di environment variable)
Python 3.8+ atau Node.js 18+ (contoh tersedia untuk keduanya)
URL gambar publik atau gambar base64 sebagai data URI

Set environment variable API key:

export XAI_API_KEY="your_key_here"

Install SDK Python xAI:

pip install xai-sdk

Untuk raw HTTP, cukup gunakan requests (Python) atau fetch (Node.js).

Permintaan Image-to-Video Pertama Anda

Menggunakan curl

curl -X POST https://api.x.ai/v1/videos/generations \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "prompt": "Gentle waves move across the surface, morning mist rises slowly",
    "image": {
      "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/1/1a/24701-nature-natural-beauty.jpg/1280px-24701-nature-natural-beauty.jpg"
    },
    "duration": 6,
    "resolution": "720p",
    "aspect_ratio": "16:9"
  }'

Respons:

{
  "request_id": "d97415a1-5796-b7ec-379f-4e6819e08fdf"
}

Video belum siap—lakukan polling untuk hasilnya.

Menggunakan Python (raw request)

import os
import requests

api_key = os.environ["XAI_API_KEY"]

payload = {
    "model": "grok-imagine-video",
    "prompt": "Gentle waves move across the surface, morning mist rises slowly",
    "image": {
        "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/1/1a/24701-nature-natural-beauty.jpg/1280px-24701-nature-natural-beauty.jpg"
    },
    "duration": 6,
    "resolution": "720p",
    "aspect_ratio": "16:9"
}

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api.x.ai/v1/videos/generations",
    json=payload,
    headers=headers
)

data = response.json()
request_id = data["request_id"]
print(f"Job started: {request_id}")

Gambar Base64

Jika gambar lokal, enkode ke data URI:

import base64

with open("my_image.jpg", "rb") as f:
    encoded = base64.b64encode(f.read()).decode("utf-8")

payload["image"] = {
    "url": f"data:image/jpeg;base64,{encoded}"
}

Polling untuk Hasil

Video digenerate secara asinkron. Gunakan endpoint:

GET https://api.x.ai/v1/videos/{request_id}

Status yang mungkin:
| Status | Arti |
|---------------|--------------------------------------|
| "processing"| Video sedang dirender |
| "done" | Video siap, URL tersedia |
| "failed" | Terjadi error |

Contoh respons selesai:

{
  "status": "done",
  "video": {
    "url": "https://vidgen.x.ai/....mp4",
    "duration": 6
  },
  "progress": 100
}

Loop Polling Python

import time

def poll_video(request_id: str, api_key: str, interval: int = 5) -> dict:
    url = f"https://api.x.ai/v1/videos/{request_id}"
    headers = {"Authorization": f"Bearer {api_key}"}

    while True:
        response = requests.get(url, headers=headers)
        data = response.json()
        status = data.get("status")

        print(f"Status: {status} | Progress: {data.get('progress', 0)}%")

        if status == "done":
            return data["video"]
        elif status == "failed":
            raise RuntimeError(f"Video generation failed for {request_id}")

        time.sleep(interval)

# Usage
video = poll_video(request_id, api_key)
print(f"Video URL: {video['url']}")
print(f"Duration: {video['duration']}s")

Tips:

Polling setiap ≥5 detik. Batas laju API 60 request/menit (1/detik).

Menggunakan SDK Python xAI

xai-sdk menangani polling asinkron otomatis via client.video.generate():

from xai_sdk import Client
import os

client = Client(api_key=os.environ["XAI_API_KEY"])

video = client.video.generate(
    model="grok-imagine-video",
    prompt="Gentle waves move across the surface, morning mist rises slowly",
    image={"url": "https://example.com/landscape.jpg"},
    duration=6,
    resolution="720p",
    aspect_ratio="16:9"
)

print(f"Video URL: {video.url}")
print(f"Duration: {video.duration}s")

Gunakan SDK untuk kode aplikasi yang bersih. Untuk kontrol interval polling/logging, gunakan raw HTTP.

Kontrol Resolusi, Durasi, dan Rasio Aspek

API mendukung penyesuaian output.

Durasi

duration = integer 1–15 (detik). Default: 6.

"duration": 10

Semakin panjang video, semakin besar biaya.

Resolusi

Nilai	Deskripsi
`"480p"`	Standar, murah, cepat
`"720p"`	Kualitas tinggi, $0.07/dtk

"resolution": "720p"

Rasio Aspek

Nilai	Penggunaan
`16:9`	Landscape, layar lebar
`9:16`	Vertikal, mobile/story
`1:1`	Persegi, Instagram
`4:3`	Klasik, presentasi
`3:4`	Potret
`3:2`	Foto standar
`2:3`	Potret tinggi

Jika image disediakan, rasio aspek default mengikuti gambar. Atur manual untuk menimpa.

Gambar Referensi untuk Panduan Gaya

Perbedaan:

image: frame pertama output, jadi dasar animasi.
reference_images: hingga 7 gambar, memandu gaya/konten, bukan frame output.

Contoh:

{
  "model": "grok-imagine-video",
  "prompt": "A product rotating slowly on a clean white surface",
  "image": {
    "url": "https://example.com/product-shot.jpg"
  },
  "reference_images": [
    {"url": "https://example.com/brand-style-reference-1.jpg"},
    {"url": "https://example.com/lighting-reference.jpg"}
  ],
  "duration": 6,
  "resolution": "720p"
}

Tanpa parameter image, referensi tetap bisa digunakan untuk text-to-video.

Memperpanjang & Mengedit Video

Memperpanjang Video

Lanjutkan video hingga 15 detik per call:

curl -X POST https://api.x.ai/v1/videos/extensions \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "video_id": "your_original_request_id",
    "prompt": "The mist continues to lift as sunlight breaks through",
    "duration": 5
  }'

Polling hasil sama seperti awal.

Mengedit Video

Edit video dengan prompt baru:

curl -X POST https://api.x.ai/v1/videos/edits \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "video_id": "your_original_request_id",
    "prompt": "Change the sky to a dramatic sunset with deep orange tones"
  }'

Polling hingga selesai.

Rincian Harga

Komponen	Biaya
Gambar input	$0.002/gambar
Output 480p	$0.05/detik
Output 720p	$0.07/detik

Contoh: Video 10 detik 720p

Input: $0.002
Output: 10 × $0.07 = $0.70
Total: $0.702

Contoh: 6 detik 480p

Input: $0.002
Output: 6 × $0.05 = $0.30
Total: $0.302

Setiap POST akan dikenakan biaya gambar input, meski URL gambar sama. Text-to-video tanpa image tidak kena biaya input.

Cara Menguji Integrasi API Video Grok Anda dengan Apidog

Pola asinkron perlu pengujian chaining, bukan single request. Pastikan:

Permintaan POST menghasilkan request_id
Polling menangani status "processing" dengan benar
Respons akhir status "done" dan URL video valid

Langkah Uji dengan Apidog

1. Buat Skenario Uji Baru

Di Apidog, buka modul Tests, klik +, beri nama "Grok image-to-video async flow".

2. Tambahkan Permintaan Generasi

URL: https://api.x.ai/v1/videos/generations
Method: POST
Header: Authorization: Bearer {{xai_api_key}}
Body (JSON):

{
  "model": "grok-imagine-video",
  "prompt": "Gentle mist rises from the water as light filters through the trees",
  "image": {
    "url": "https://example.com/your-test-image.jpg"
  },
  "duration": 6,
  "resolution": "480p"
}

3. Ekstrak request_id

Tambahkan "Extract Variable":

Nama: video_request_id
Sumber: response body
Ekstraksi: JSONPath $.request_id

4. Bangun Loop Polling

Tambahkan "For" loop:

Request polling:
- URL: https://api.x.ai/v1/videos/{{video_request_id}}
- Method: GET
- Header: Authorization: Bearer {{xai_api_key}}
Extract Variable di dalam loop:
- Nama: video_status
- JSONPath: $.status
Wait processor (5000ms)
Break If: {{video_status}} == "done"

5. Tegaskan URL Video

Setelah loop, GET ke endpoint polling. Tambahkan Assertion:

Field: $.video.url
Condition: not empty

Menjalankan Skenario

Klik Run. Apidog akan chaining request, polling hingga selesai, dan validasi URL. Integrasi dengan pipeline CI/CD:

apidog run --scenario grok-video-async-flow --env production

Kesalahan Umum & Solusi

401 Unauthorized: API key salah/hilang. Cek header Authorization dan status key di konsol xAI.
422 Unprocessable Entity: Body request salah. Pastikan model, prompt, image.url valid dan dapat diakses.
URL gambar tidak dapat diakses: Gunakan URL publik atau base64 data URI.
Status "processing" tanpa akhir: Jika >10 menit, retry request.
429 Rate Limit: Max 60 request/menit. Tambahkan delay antar polling.
Base64 upload gagal: Tambahkan prefix MIME yang benar, misal data:image/jpeg;base64,.
Aspect ratio mismatch: Jika aspect_ratio sangat beda dari gambar, gambar bisa ter-crop/letterbox. Samakan rasio aspek untuk hasil optimal.

Kesimpulan

API Grok image-to-video memungkinkan Anda mengubah foto statis jadi klip animasi pendek. POST gambar dan prompt, dapatkan request_id, polling hingga selesai, dan unduh MP4. Model grok-imagine-video terbukti skala besar dan performa tinggi.

Testing async dengan Skenario Uji Apidog: chaining Extract Variable, polling loop, dan assertion URL—menjamin integrasi tahan produksi.

Mulai bangun integrasi Anda dengan Apidog secara gratis. Tidak diperlukan kartu kredit.

FAQ

Nama model apa untuk API Grok image-to-video?

Gunakan grok-imagine-video sebagai value field model.

Apa beda parameter image vs reference_images?

image: frame pertama video.

reference_images: panduan gaya, bukan frame. Bisa digabung.

Berapa lama proses generate video?

6 detik 480p: 1–3 menit. 15 detik 720p: 4–8 menit. Polling tiap 5 detik.

Bisa pakai file lokal sebagai gambar?

Ya, enkode base64 ke data URI.

Jika tidak set aspect_ratio?

Dengan image, default ke proporsi gambar. Tanpa gambar, default 16:9.

Biaya video 10 detik 720p?

Input: $0.002 + Output: $0.70 = $0.702.

Batas laju?

60 request/menit, 1 request/detik (POST + GET total).

Bisa memperpanjang video >15 detik?

Ya, pakai endpoint POST /v1/videos/extensions, dengan polling asinkron.

Harga API SMS Bird di Tahun 2026

Walse — Fri, 03 Apr 2026 07:11:03 +0000

TL;DR

API SMS Bird mulai dari $0,00331 per pesan keluar AS dan $0,003 per pesan masuk AS, termasuk salah satu harga terendah di antara provider besar. Ada paket gratis (5 SMS/hari) untuk uji coba, dan paket Pro $49/bulan dengan 1.000 kredit SMS.

Coba Apidog hari ini

Artikel ini membahas detail biaya SMS Bird tahun 2025-2026, faktor yang memengaruhi tagihan, serta perbandingan dengan alternatif lain.

Pendahuluan

MessageBird rebranding menjadi Bird pada 2023, dengan fokus baru pada komunikasi omnichannel berbasis AI (SMS, WhatsApp, email, suara) dalam satu platform. Model harga berubah ke pay-as-you-go transparan, menempatkan biaya dasar SMS Bird di bawah Twilio, Vonage, dan mayoritas provider utama lainnya.

💡 Tips cepat: Untuk integrasi SMS, pastikan Anda memiliki data harga terbaru dan cara mudah menguji API sebelum produksi. Apidog memungkinkan Anda mendesain, menjalankan, dan memvalidasi API Bird tanpa coding manual.

Artikel ini akan menguraikan rincian harga SMS Bird, apa yang memengaruhi total biaya, serta membandingkannya dengan provider lain.

Ikhtisar Harga SMS Bird

Bird menggunakan dua komponen harga untuk SMS:

Biaya paket platform (langganan bulanan)
Biaya per pesan (bayar sesuai penggunaan setelah kuota habis)

Rincian paket:

Paket	Biaya bulanan	SMS termasuk
Gratis	$0	5 SMS/hari
Pro	$49	1.000 SMS/bulan
Enterprise	Kustom	Volume kustom

Setelah melewati batas paket, harga per pesan untuk nomor AS:

SMS Keluar: $0,00331/pesan
SMS Masuk: $0,003/pesan

Harga CRM/Marketing Automation ditampilkan dalam EUR di halaman resmi. Selalu cek bird.com/en/pricing/sms untuk update biaya operator dan konversi kurs terbaru.

Rincian Harga: SMS, MMS, WhatsApp, Email

SMS

SMS keluar AS: $0,00331/pesan. Tarif bervariasi antar negara.

Negara	Tarif keluar (perkiraan)
Amerika Serikat	~$0,00331
Inggris Raya	~€0,036
Australia	~€0,009
Jerman	~€0,056
India	Bervariasi
Brasil	~€0,047

Catatan: Biaya operator tambahan (10DLC, bebas pulsa) berlaku untuk AS & Kanada, di luar tarif dasar.

MMS

MMS (pesan gambar) lebih mahal dari SMS, didukung untuk nomor AS & Kanada. Biaya berkisar 3-5x tarif SMS. Cek tarif MMS terkini di bird.com/en/pricing/sms.

Harga WhatsApp Bird:

Biaya pemrosesan Bird (per 1.000 pesan):

| Volume | Biaya per 1.000 pesan |
|-----------------------|-----------------------|
| 1–1.000 | $0,001 |
| 1.001–100.000 | $0,005 |
| 100.001–500.000 | $0,0045 |
| 500.001+ | $0,004 |

Biaya passthrough Meta (berdasarkan jenis percakapan):

Percakapan Pemasaran: $0,0250
Percakapan Utilitas: $0,0034
Percakapan Autentikasi: $0,0034

Bird hanya meloloskan biaya Meta tanpa markup.

Email

Harga email mulai $0,001/email untuk volume rendah, makin murah jika volume besar. Paket Pro mencakup 10.000 email/bulan.

Suara

API Suara Bird berbasis penggunaan, tarif bervariasi. Panggilan keluar AS: $0,013–$0,015/menit. Panggilan masuk sedikit lebih murah. Untuk volume tinggi, hubungi sales Bird.

Faktor yang Memengaruhi Tagihan Bird Anda

1. Negara & Perutean Operator

SMS AS ($0,00331) sangat murah. Untuk negara lain, biaya bisa 10x–80x lebih mahal. Selalu cek lembar tarif Bird per negara sebelum memperkirakan biaya internasional.

2. Jenis Nomor

Jenis nomor memengaruhi biaya:

Kode panjang (10DLC): Nomor standar AS, wajib registrasi merek & kampanye (TCR).
Kode pendek: 5-6 digit, throughput tinggi, sewa bulanan $500–$1.000.
Nomor bebas pulsa: Biaya bulanan lebih rendah, throughput sedang.

Sewa nomor bulanan di luar tarif per pesan.

3. Panjang Pesan & Pengkodean

SMS standar: 160 karakter (GSM-7). Melebihi 160 karakter = multi-segmen (ditagih per segmen). Menggunakan Unicode (emoji, huruf khusus) menurunkan limit per segmen ke 70 karakter.

4. Campuran Saluran

Jika workflow Anda mengalihkan pesan gagal ke WhatsApp, akan ada biaya tambahan WhatsApp. Model biaya harus mempertimbangkan fallback channel.

5. Volume

Bird tidak mempublikasikan diskon volume SMS secara terbuka. Untuk volume besar, paket Enterprise menawarkan tarif kustom (kontak sales).

Biaya & Biaya Tersembunyi

Biaya Operator AS (10DLC)

Pendaftaran merek: Sekali, ~$4–$44
Pendaftaran kampanye: Bulanan, ~$10/bulan/kampanye
Biaya tambahan operator: Per pesan

Biaya ini ditetapkan operator AS, Bird hanya meloloskan.

Sewa Nomor Telepon

Kode panjang AS: $1–$2/bulan
Bebas pulsa: $2–$3/bulan
Kode pendek: $500–$1.000/bulan

Webhook Masuk & Pemrosesan

Menerima SMS masuk ($0,003/pesan AS) memicu biaya. Workflow opt-out/keyword akan menambah tagihan.

Langganan Platform

Biaya Pro ($49/bulan) tetap. Untuk volume rendah, biaya utama dari kelebihan pesan.

Perbandingan dengan Alternatif

Penyedia	SMS keluar AS	SMS masuk AS	Catatan
Bird	$0,00331	$0,003	Tarif dasar terendah; platform omnichannel
Twilio	$0,0079	$0,0079	Lebih mahal; ekosistem besar
Telnyx	~$0,004	~$0,001	Kompetitif; direct-to-operator
Plivo	$0,0055	$0,0005	Tarif masuk murah; platform sederhana

Bird unggul di tarif dasar. Twilio hampir 2x lebih mahal di entry-level. Penyedia seperti Telnyx/Plivo menawarkan model lebih sederhana jika hanya butuh SMS API. Untuk workflow omnichannel dan automation, Bird sangat kompetitif.

Cara Memulai dengan Bird

Buat akun gratis di bird.com. Dapatkan 5 SMS/hari, tanpa kartu kredit.
Daftarkan merek & kampanye via dashboard Bird untuk compliance 10DLC AS (durasi proses 1–3 hari kerja).
Dapatkan nomor telepon melalui API atau dashboard Bird.
Kirim API pertama:

curl -X POST https://api.bird.com/messages \
-H "Authorization: AccessKey YOUR_ACCESS_KEY" \
-H "Content-Type: application/json" \
-d '{
  "originator": "+1XXXXXXXXXX",
  "recipients": ["+1XXXXXXXXXX"],
  "body": "Pesan pertama Anda dari Bird API!"
}'

Cek dokumentasi lengkap di docs.bird.com untuk autentikasi, SDK (Node.js, Python, PHP, Go, Java, Ruby), serta pengaturan webhook.

Kesimpulan

API SMS Bird menawarkan tarif dasar terendah untuk AS ($0,00331/pesan keluar). Paket gratis bisa langsung dicoba tanpa kartu kredit, Pro cocok untuk tim kecil (1.000 SMS/bulan).

Waspada biaya tambahan: operator 10DLC, sewa nomor, dan SMS internasional (bisa 50x harga AS!). Selalu modelkan biaya sebelum produksi.

Untuk pengujian API SMS Bird, gunakan Apidog untuk pembuatan request, environment variable, chaining test, dan assertion dalam satu tool.

FAQ

Berapa harga API SMS Bird per pesan di AS?

$0,00331 per SMS keluar AS dan $0,003 per SMS masuk AS (belum termasuk biaya operator 10DLC).

Apakah Bird sama dengan MessageBird?

Ya, MessageBird rebranding jadi Bird pada 2023. Beberapa endpoint API masih memakai nama lama.

Apakah Bird mengenakan biaya untuk SMS masuk?

Ya, $0,003/pesan masuk AS.

Apa itu paket gratis Bird?

5 SMS/hari, 10 email/hari, 15 pesan AI/hari. Akses API tanpa kartu kredit, cocok untuk uji coba.

Bagaimana harga SMS Bird dibandingkan Twilio?

Bird jauh lebih murah ($0,00331 vs $0,0079 AS). Untuk 100.000 pesan/bulan: Bird ~$331, Twilio $790 (harga dasar).

Ada biaya tersembunyi di SMS Bird?

Ada: pendaftaran merek/kampanye 10DLC, biaya operator, sewa nomor ($1–$2/bulan), dan tarif internasional lebih mahal.

Bagaimana cara menguji API SMS Bird tanpa mengirim pesan nyata?

Gunakan fitur Mock Cerdas di Apidog untuk simulasi respons API Bird, atau sandbox di Bird. Skenario pengujian Apidog memungkinkan chaining request & assertion tanpa menyentuh sistem produksi.

Harga SMS API Twilio: Rincian Biaya Lengkap 2026

Walse — Fri, 03 Apr 2026 03:59:36 +0000

TL;DR

SMS long code AS (keluar & masuk): $0.0083 per pesan
MMS keluar: $0.022/pesan; MMS masuk: $0.0165/pesan
SMS bebas pulsa: $0.0083/pesan + biaya tambahan operator
Sewa short code: $1.000/bulan (acak); $1.500/bulan (vanity code)
Pendaftaran merek 10DLC: $4.50 sekali bayar (update Agustus 2025); kampanye mulai $1.50–$10/bulan
Nomor long code: $1.15/bulan; bebas pulsa: $2.15/bulan
Biaya operator di atas harga dasar
Diskon volume otomatis di 150.000 pesan/bulan
Uji coba gratis tersedia; tidak perlu kartu kredit

Pendahuluan

Twilio adalah API SMS default untuk banyak pengembang karena dokumentasinya lengkap, uptime andal, dan REST API yang baik. Namun, saat aplikasi Anda masuk produksi, biaya akan meningkat. Anda membayar tarif dasar Twilio, biaya operator, nomor telepon, dan mungkin biaya pendaftaran 10DLC.

Coba Apidog hari ini

💡 Saran: Selalu uji integrasi SMS Anda sebelum produksi. Apidog menyediakan skenario uji otomatis untuk memvalidasi respons webhook Twilio dengan spesifikasi OpenAPI. Anda dapat cek kode status, validasi skema respons, dan jalankan pengujian kontrak di CI/CD. Coba gratis untuk pastikan alur SMS Anda valid sebelum go-live.

Artikel ini mengurai setiap item biaya Twilio, agar Anda tahu apa saja yang memengaruhi tagihan, hal-hal yang sering terlewat, dan perbandingan Twilio dengan alternatif lain.

Ikhtisar Harga SMS Twilio

Twilio memakai model pay-as-you-go: bayar per segmen pesan, per nomor telepon/bulan, dan fitur tambahan opsional. Tidak ada kontrak atau minimum kecuali negosiasi diskon volume enterprise.

Tarif dasar SMS AS pada long code: $0.0083/segmen (masuk & keluar). Namun, biaya operator, sewa nomor, dan pendaftaran compliance menambah biaya setiap bulan.

Diskon volume otomatis berlaku tanpa negosiasi setelah Anda kirim >150.000 pesan/bulan (semua jenis nomor dihitung terpisah).

Rincian Harga: SMS, MMS, Bebas Pulsa, & Short Code

SMS Long Code (10-digit)

Long code adalah nomor 10 digit standar untuk pesan A2P AS.

Jenis pesan	Harga per segmen
SMS keluar	$0.0083
SMS masuk	$0.0083
MMS keluar	$0.022
MMS masuk	$0.0165

Catatan: Twilio menagih per segmen, bukan per pesan. Segmen GSM-7 = 160 karakter; Unicode (emoji/aksen) = 70 karakter/segmen. Pesan 200 karakter = 2 segmen tagihan.

Nomor Bebas Pulsa

Tarif dasar sama: $0.0083/segmen SMS, MMS keluar $0.022, MMS masuk $0.02. Tidak perlu pendaftaran 10DLC, tapi butuh verifikasi bebas pulsa untuk throughput maksimum.

Short Code (5–6 digit)

Untuk throughput tinggi. Tarif per pesan sama ($0.0083), tapi sewa nomor mahal.

Jenis short code	Biaya bulanan
Short code acak	$1.000/bulan (kuartalan)
Short code vanity	$1.500/bulan (kuartalan)
Vanity code sendiri	$500/bulan (kuartalan)

Semua short code dengan MMS: biaya setup $500 (sekali bayar).

Diskon Volume

Diskon otomatis berlaku berikut:

Pesan bulanan	Harga per segmen
1 – 150.000	$0.0083
150.001 – 300.000	$0.0081
300.001 – 500.000	$0.0079
500.001 – 750.000	$0.0077
750.001 – 1.000.000	$0.0075
1.000.001+	$0.0073

Volume dihitung per jenis nomor (long code, bebas pulsa, short code tidak digabung).

Faktor yang Memengaruhi Tagihan Twilio

Jenis Nomor Telepon

Jenis nomor (long code, bebas pulsa, short code) menentukan tarif dan diskon. Membagi trafik antar jenis bisa buat Anda tak dapat diskon volume di salah satu.

Segmen Pesan

Biaya dihitung per segmen. Pesan panjang/ber-Emoji bisa 2–3x lipat biaya per pesan.

Biaya Operator

Di atas tarif dasar Twilio, operator utama AS menambahkan biaya per pesan. Ini diteruskan ke Anda.

Biaya operator long code (SMS keluar):

Operator	Biaya keluar
AT&T	$0.0035
T-Mobile	$0.0045
Verizon	$0.004
US Cellular	$0.005
Lainnya	$0.004

MMS lebih mahal: AT&T +$0.009, T-Mobile +$0.01.

Contoh: SMS keluar ke AT&T = $0.0083 (Twilio) + $0.0035 (operator) = $0.0118/segmen.

Negara Tujuan

Harga internasional bervariasi besar: Inggris $0.04/pesan, India $0.0029, Brasil $0.075. Unduh CSV harga Twilio untuk detail.

Pendaftaran 10DLC

Bisnis yang kirim A2P SMS di AS pada long code wajib daftar merek dan kampanye. Lalu lintas tak terdaftar akan difilter operator.

Biaya & Ongkos Tersembunyi

Biaya Pendaftaran 10DLC

Update Agustus 2025 (TCR):

Pendaftaran merek:

Pemilik Tunggal / Volume Rendah: $4.50 (sekali bayar)
Standar (plus pemeriksaan sekunder): $46 (sekali bayar)

Pendaftaran kampanye:

Pemeriksaan: $15 sekali
Biaya kampanye: $1.50 – $10/bulan tergantung tipe

Jenis kampanye	Biaya bulanan
Pemilik Tunggal	$2/bulan
Campuran volume rendah	$1.50/bulan
Standar	$10/bulan
Amal	$3/bulan
Layanan darurat	$5/bulan

Pemeriksaan standar: $41.50. Banding: $11. Ulang Authentication Plus: $12.50.

Biaya Nomor Telepon

Long code: $1.15/bulan. Bebas pulsa: $2.15/bulan. Jika Anda butuh banyak nomor (misal A/B test atau kehadiran lokal), biaya bertambah.

Biaya Pemrosesan Pesan Gagal

Twilio menagih $0.001/pesan berstatus "Gagal"—biaya kecil, tapi menumpuk saat debugging atau operator filtering.

Fitur Opsional

Engagement Suite (pemendek link, click tracking): $0.015/pesan keluar (setelah 1.000 pesan gratis/bulan)
Compliance Toolkit: $0.015/pesan keluar

Paket Dukungan

Dukungan gratis terbatas. Paket berbayar mulai $250/bulan ("Developer"). Untuk kebutuhan mission-critical, kontrak support biasanya wajib.

Perbandingan Twilio vs Alternatif

Penyedia	SMS keluar AS	SMS masuk AS	Nomor telepon	10DLC diperlukan
Twilio	$0.0083 + operator	$0.0083 + operator	$1.15/bulan	Ya
Plivo	$0.005	$0.00035	$0.80/bulan	Ya
Telnyx	$0.004	$0.004	$1.00/bulan	Ya
Bird	~$0.007	~$0.007	Bervariasi	Ya

Plivo & Telnyx jauh lebih murah per pesan (khususnya SMS masuk Plivo). Telnyx mengelola biaya operator berbeda, total biaya sering lebih rendah.

Twilio unggul pada dokumentasi, ekosistem, dan fitur lanjutan (Messaging Services, sticky sender, smart encoding). Untuk volume besar dengan harga minimal, Plivo/Telnyx layak dicoba.

Cara Uji Twilio Gratis

Twilio menyediakan akun uji coba gratis (tanpa kartu kredit). Anda dapat:

Dapat nomor uji coba
Kirim/terima SMS via API
Uji webhook untuk pesan masuk
Eksplorasi Console & log

Selama trial, pesan ke nomor belum diverifikasi ada awalan "Dikirim dari akun uji coba Twilio Anda". Untuk hilangkan awalan, upgrade ke akun berbayar.

Setelah upgrade, bayar sesuai penggunaan tanpa minimum bulanan.

Cara Uji Integrasi SMS Twilio Anda dengan Apidog

Setelah kredensial & webhook Twilio siap, validasi integrasi Anda dengan pendekatan otomatis. Pengujian manual tidak berskala dan rentan human error.

Langkah Praktis dengan Apidog

Skenario Uji Apidog memungkinkan Anda merangkai permintaan API menjadi alur otomatis.

Contoh penerapan:

Import spesifikasi endpoint webhook Twilio ke skenario uji
Tambah langkah: kirim SMS → terima callback delivery → tangani balasan masuk
Gunakan mode orkestrasi untuk eksekusi berurutan
Pass data antar langkah pakai sintaks {{$.stepId.response.body.field}} (misal: SID pesan)

Pengujian Kontrak: Validasi respons API Twilio terhadap OpenAPI Anda secara otomatis. Cek:

Kode status HTTP sesuai dokumentasi
Semua field wajib di webhook ada
Tipe data field benar (SID string, timestamp format ISO)
Tidak ada field ekstra kecuali diizinkan (additionalProperties)

Mulai:

Download Apidog gratis

Import spesifikasi API Twilio atau definisikan skema webhook

Buat skenario uji sesuai alur kirim/terima SMS Anda

Kesimpulan

Harga API SMS Twilio mulai $0.0083/segmen (long code AS), tapi biaya riil termasuk markup operator, sewa nomor, dan 10DLC. Satu pesan keluar ke AT&T: sekitar $0.0118/segmen. Untuk kampanye 10DLC standar, tambahkan $10/bulan per kampanye.

Harga transparan, diskon volume otomatis, tapi Anda wajib hitung semua komponen biaya.

Setelah simulasi biaya, bangun integrasi dan uji otomatis. Gunakan Skenario Uji & Pengujian Kontrak Apidog untuk validasi webhook Twilio & pastikan respons API selalu sesuai spesifikasi—tanpa perlu boilerplate test script.

FAQ (Pertanyaan yang Sering Diajukan)

T: Berapa harga dasar SMS keluar AS di Twilio?

J: $0.0083/segmen pesan (long code AS) + biaya operator. SMS ke AT&T total $0.0118/segmen.

T: Apakah Twilio menagih SMS masuk?

J: Ya. $0.0083/segmen untuk SMS masuk (long code & bebas pulsa). Biaya operator bisa berlaku.

T: Apa itu 10DLC, wajib daftar?

J: 10DLC = sistem pendaftaran SMS A2P di AS untuk long code 10 digit. Wajib daftar jika mengirim pesan aplikasi ke konsumen AS. Biaya: pendaftaran merek $4.50 (sekali), kampanye $1.50–$10/bulan.

T: Berapa biaya short code Twilio?

J: Short code acak $1.000/bulan, vanity $1.500/bulan. Setup MMS $500 (sekali). Tarif SMS per pesan sama ($0.0083).

T: Twilio ada diskon volume?

J: Ya. 150.000 pesan pertama/bulan di $0.0083, lalu turun sampai $0.0073 (>1 juta pesan). Diskon enterprise tersedia via sales.

T: Ada uji coba gratis Twilio?

J: Ya. Akun trial gratis + saldo kredit. Tidak perlu kartu kredit. Pesan keluar trial ada awalan, hilang setelah upgrade akun.

T: Alternatif Twilio termurah untuk SMS?

J: Plivo ($0.005 keluar, $0.00035 masuk), Telnyx ($0.004 keluar/masuk). Keduanya perlu 10DLC untuk A2P AS. Twilio lebih unggul di dokumentasi, dukungan, dan fitur untuk use case kompleks.

Harga API SMS Vonage: Berapa Biayanya di Tahun 2026?

Walse — Fri, 03 Apr 2026 03:53:15 +0000

Inti Sari

Harga API SMS Vonage dimulai dari $0,00809 per pesan keluar dan $0,00649 per pesan masuk di AS. Tidak ada minimum bulanan; Anda hanya membayar apa yang dikirim/diterima. Tarif internasional bervariasi per negara, bahkan bisa lebih dari $1,00 di beberapa pasar. Untuk membangun atau menguji integrasi SMS Vonage, gunakan Apidog agar pengujian permintaan, validasi respons, dan troubleshooting error lebih efisien sebelum deploy ke produksi.

Coba Apidog hari ini

Pendahuluan

Jika Anda familiar dengan Nexmo, Anda sudah mengenal Vonage. Setelah diakuisisi pada tahun 2016, Nexmo menjadi inti platform API komunikasi Vonage. Tahun 2022, Vonage diakuisisi Ericsson, memperkuat posisinya di industri telekomunikasi API global.

Saat ini, Vonage digunakan oleh lebih dari 100.000 bisnis dan 1,6 juta developer, menawarkan harga fleksibel (pay-as-you-go), tanpa kontrak, dan menjangkau lebih dari 190 negara.

💡 Tips: Untuk integrasi API yang lebih stabil, gunakan Apidog untuk membangun skenario tes permintaan SMS Vonage, validasi respons, serta chaining API dalam satu workflow otomatis. Apidog gratis, tidak perlu kartu kredit.

Ikhtisar Harga SMS Vonage

Vonage menggunakan model pay-as-you-go untuk API SMS. Tidak ada biaya platform atau langganan bulanan. Tarif per pesan berdasarkan negara tujuan dan jenis nomor.

Jenis pesan	Harga per pesan
SMS Keluar (LVN AS)	$0.00809
SMS Masuk (LVN AS)	$0.00649
SMS Keluar (Bebas Pulsa)	Hubungi bagian penjualan
SMS Masuk (Bebas Pulsa)	Gratis

LVN (Local Virtual Number) = nomor panjang standar (10DLC). Tarif diproses real-time berdasarkan penggunaan. Untuk rencana internasional, download global rate sheet dari dashboard Vonage.

Rincian Harga: Pesan Keluar, Masuk, MMS, dan WhatsApp

SMS Keluar

Pesan yang dikirim dari aplikasi ke user. Tarif dasar AS: $0,00809 per pesan (nomor virtual lokal). Cek dashboard resmi untuk update terbaru.

SMS Masuk

Pesan ke nomor Vonage yang Anda sewa. Di AS: $0,00649 per pesan masuk. Nomor bebas pulsa sering gratis untuk pesan masuk, tapi tetap verifikasi via akun.

Harga MMS

MMS didukung via API Pesan Vonage. Tarif MMS tidak dipublikasikan secara umum—harus request via sales karena tergantung operator/negara.

WhatsApp via Vonage

WhatsApp didukung melalui API Pesan. Ada dua biaya:

Biaya WhatsApp: Dibebankan Meta per pesan, tergantung kategori (marketing, utility, authentication, service).
Biaya platform Vonage: Mulai $0,00015 per pesan. Variatif tergantung kategori dan volume.

Facebook Messenger

Biaya $0,0011 per pesan yang dikirim via API Pesan Vonage.

RCS (Rich Communication Services)

Tarif khusus operator di AS, contoh:

Operator	RCS Kaya (teks)	RCS Media Kaya
T-Mobile	$0.00620	$0.01250
Verizon	$0.00400	$0.00600
AT&T	$0.00450	$0.01000
US Cellular	$0.00620	$0.01350

Ada setup fee satu kali, $600 per negara untuk RCS.

Faktor yang Mempengaruhi Tagihan Vonage

Negara Tujuan

Destinasi adalah faktor terbesar. Pesan ke AS murah, tapi ke negara dengan konektivitas rendah bisa $0,50+ per SMS. Selalu cek global rate sheet.

Jenis Nomor

Kode Panjang (10DLC): Nomor lokal, murah untuk P2P dan aplikasi-ke-orang.
Nomor Bebas Pulsa: Throughput tinggi, pesan masuk sering gratis.
Kode Pendek: Volume tinggi marketing, perlu registrasi operator.

Setiap jenis punya tarif berbeda. Kode pendek paling mahal sewanya, tapi cocok untuk volume tinggi.

Biaya Sewa Nomor

Sewa nomor virtual = biaya tambahan bulanan. Nomor lokal mulai beberapa dollar, toll-free/kode pendek lebih mahal.

Pengkodean Pesan

GSM-7: 160 karakter/SMS.
Unicode: 70 karakter/SMS (misal pakai emoji/aksara khusus).
Pesan Unicode >70 karakter bisa dihitung jadi 2-3 SMS sekaligus.

Biaya Tambahan Operator

Operator AS bisa menambahkan surcharge pada A2P lewat 10DLC. Vonage meneruskan biaya ini ke tagihan Anda.

Biaya Tersembunyi yang Perlu Diwaspadai

Tingkat Dukungan

Gratis: Forum komunitas & dokumentasi.
Business Support: Berbayar.
Premium 24/7: $3.300/bulan; untuk kebutuhan mission-critical.

API Tambahan

Add-on	Biaya bulanan
API Audit	$550/bulan
Otomatis redaksi	$1.100/bulan
API Laporan	$495/bulan / $0,00049/CDR

API Audit untuk regulasi ketat; Otomatis redaksi menghapus PII otomatis.

Biaya API Verifikasi

API Verifikasi Vonage: $0,0572 per verifikasi berhasil (plus biaya pesan/voice). Verifikasi gagal tetap kena biaya pengiriman pesan.

Registrasi Nomor (10DLC AS)

A2P dengan kode panjang di AS wajib registrasi di The Campaign Registry (TCR):

Brand registration: Sekali bayar
Campaign registration: Bulanan per campaign

Tanpa registrasi, pesan Anda tidak akan terkirim.

Vonage vs Alternatif

Perbandingan harga SMS keluar AS:

Penyedia	SMS keluar AS	SMS masuk AS	Uji coba gratis	Dukungan
Vonage	$0.00809	$0.00649	Ya (nomor diverifikasi)	Berbayar; $3.300/bulan untuk 24/7
Twilio	$0.0079	$0.0075	Ya ($15 kredit)	Berbayar mulai $250/bulan
Plivo	$0.0055	$0.0005	Ya	Dasar gratis; berbayar tersedia
Telnyx	$0.004	$0.002	Ya ($5 kredit)	Email 24/7 gratis; telepon berbayar

Catatan:

Telnyx paling murah, tapi lebih baru dan tim support lebih kecil.
Plivo ramah developer.
Twilio unggul di ekosistem & integrasi.
Vonage unggul di keandalan operator & harga menengah.

Harga bukan segalanya: cek juga deliverability, compliance, tooling, dan support.

Cara Mencoba Vonage Secara Gratis

Vonage menawarkan akun trial gratis.

Fitur trial:

Nomor virtual Vonage untuk testing
API credentials (key & secret)
Akses dokumentasi & SDK lengkap
Kredit pengujian terbatas

Pembatasan trial:

Hanya bisa kirim ke nomor yang diverifikasi.
Tidak bisa broadcast ke nomor random sampai upgrade.

Langkah memulai:

Akses dashboard.nexmo.com atau vonage.com/communications-apis
Daftar akun gratis dengan email
Verifikasi nomor telepon Anda
Dapatkan API key & secret dari dashboard
Lakukan call API pertama via REST API atau SDK resmi

SDK Vonage tersedia untuk Node.js, Python, PHP, Ruby, Java, .NET, dan Go. Alternatif: gunakan klien HTTP untuk REST API.

Cara Menguji Integrasi SMS Vonage Anda dengan Apidog

Setelah punya API key & secret, gunakan Apidog untuk testing integrasi sebelum go-live.

Fitur Skenario Uji Apidog:

Chain beberapa request API jadi satu skenario otomatis.
Simulasi alur kerja SMS sebenarnya: kirim, cek status, handle error.

Menyiapkan Skenario Pengujian

Buka modul Tes di Apidog, buat skenario baru.
Tambahkan langkah dari:
- Import spesifikasi API (OpenAPI)
- Request custom ke endpoint Vonage REST API
- Import perintah cURL dari dokumentasi Vonage

Contoh pengujian SMS dasar:

Buat request POST ke https://rest.nexmo.com/sms/json dengan parameter:

{
  "api_key": "API_KEY_ANDA",
  "api_secret": "API_SECRET_ANDA",
  "from": "NOMOR_PENGIRIM",
  "to": "NOMOR_PENERIMA",
  "text": "Pesan testing dari Apidog"
}

Memvalidasi Respons

Apidog otomatis validasi respons dengan skema. Untuk SMS Vonage, response sukses:

HTTP status = 200
messages[0].status = "0"
messages[0].message-id tidak kosong

Jika status error (1, 2, 4, dst), assertion gagal dan Anda bisa debug respons langsung.

Meneruskan Data Antar Permintaan

Gunakan sintaks {{$.stepId.response.body.field}} untuk passing data antar step. Misal, ambil message-id dari response pertama untuk request selanjutnya.

Menjalankan Pengujian di CI/CD

Integrasi Apidog dengan GitHub Actions/GitLab CI/Jenkins tersedia. Export skenario, jalankan otomatis via Apidog CLI setiap pull request. Menangkap bug integrasi sebelum produksi.

Coba gratis di apidog.com. Tidak perlu kartu kredit.

Kesimpulan

API SMS Vonage menawarkan model bayar per pakai tanpa minimum bulanan. SMS keluar AS: $0,00809/pesan, masuk: $0,00649. Biaya bisa bertambah tergantung negara, tipe nomor, dan encoding pesan. Fitur premium (API Audit, Redaksi Otomatis, Dukungan 24/7) menambah biaya signifikan—rencanakan budget dengan matang.

Alternatif lebih murah: Telnyx & Plivo. Twilio menang di ekosistem. Vonage cocok untuk kebutuhan enterprise, keandalan operator, dan global reach.

Sebelum produksi, gunakan Apidog untuk membangun skenario pengujian Vonage Anda. Pastikan semua alur berjalan sesuai rencana dan error bisa dideteksi sebelum masuk ke user.

FAQ

Apakah Vonage sama dengan Nexmo?

Ya. Vonage mengakuisisi Nexmo pada 2016. Endpoint API lama (rest.nexmo.com) masih aktif dan dokumentasi di developer.vonage.com.

Apakah Vonage mengenakan biaya bulanan untuk SMS?

Tidak ada biaya platform bulanan untuk API SMS. Anda hanya membayar per pesan dan sewa nomor virtual. Add-on seperti Audit/Redaksi punya biaya bulanan.

Berapa biaya nomor telepon Vonage?

Nomor virtual lokal AS mulai beberapa dolar per bulan. Nomor bebas pulsa & kode pendek lebih mahal. Cek dashboard untuk harga terbaru.

Negara mana saja yang didukung SMS Vonage?

Vonage mendukung SMS di 190+ negara. Tarif sangat bervariasi. Untuk detail, download global rate sheet di dashboard.

Apakah Vonage menawarkan diskon volume?

Ya. Untuk volume tinggi, hubungi sales Vonage untuk harga khusus. Default: pay-as-you-go.

Bisakah saya menerima SMS masuk secara gratis?

Nomor bebas pulsa AS sering menerima SMS masuk gratis. Kode panjang: $0,00649/pesan masuk. Harga beda tiap negara, cek rate sheet.

Bagaimana perbandingan Vonage dengan Twilio untuk SMS?

Harga keluar SMS AS Vonage ($0,00809) sedikit lebih tinggi dari Twilio ($0,0079). Twilio unggul ekosistem & integrasi. Vonage punya keunggulan hubungan operator (Ericsson) dan harga kompetitif di pasar tertentu. Pilihan akhir tergantung kebutuhan workflow & support.

Apa Arti Cursor 3 bagi Pengembang API?

Walse — Fri, 03 Apr 2026 03:48:08 +0000

Intinya: Cursor 3 diluncurkan pada 2 April 2026, menggantikan antarmuka berbasis IDE dengan ruang kerja yang berfokus pada agen. Untuk pengembang API, perubahan utama adalah eksekusi agen paralel, output alat MCP yang lebih kaya, dan kemampuan serah terima cloud ke lokal yang menjaga alur kerja tetap lancar. Jika Anda mengintegrasikan Cursor 3 dengan Apidog's MCP Server, agen AI Anda bisa langsung membaca spesifikasi API dan menghasilkan kode yang akurat serta sadar skema—tanpa copy-paste. Coba Apidog hari ini

Pergeseran yang Sudah Terjadi di Lingkungan Pengembangan

Editor kode AI makin canggih dalam dua tahun terakhir. Namun, Cursor 3 bukan sekadar upgrade—ini adalah redesain total lingkungan pengembangan AI.

Sebelum Cursor 3, alur kerja Anda masih mirip IDE tradisional: buka file, panggil agen, tinjau perbedaan, lanjutkan. Agen berperan sebagai asisten on-demand.

Dengan Cursor 3, agen menjadi unit kerja utama. Anda kelola mereka seperti tab browser: jalankan beberapa agen paralel, pantau output mereka, dan pilih hasil terbaik.

Bagi pengembang API, perubahan ini sangat penting. Pekerjaan API sangat bergantung pada koordinasi: menulis endpoint, menguji kontrak, memperbarui dokumentasi, dan mengejar konsistensi skema. Semua berjalan paralel di proyek nyata. Kini, alat Anda bisa mengikuti ritme itu.

💡Satu hal yang tidak dilakukan Cursor 3 secara otomatis: ia tidak tahu spesifikasi API Anda. Di sinilah Apidog MCP Server dibutuhkan. Setelah terhubung, agen Cursor bisa menarik skema OpenAPI, definisi endpoint, dan skenario pengujian langsung dari Apidog. Agen berhenti mengira-ngira nama field. Kode yang dihasilkan langsung sesuai spesifikasi.

Artikel ini membahas detail perubahan di Cursor 3, dampaknya pada pengembangan API, serta workflow konkret menghubungkan Cursor 3 dengan Apidog MCP Server.

Apa yang Baru di Cursor 3

Cursor 3 dirilis 2 April 2026. Fitur utamanya adalah Agents Window, namun ada beberapa perubahan kunci yang langsung berdampak bagi developer API.

Jendela Agen (Agents Window)

Agents Window menggantikan layout editor tradisional dengan layout berbasis agen. Anda bisa menjalankan agen di beberapa repo sekaligus—baik lokal, worktree git, cloud Cursor, atau mesin SSH remote.

Akses via Cmd+Shift+P -> Agents Window. Anda tetap bisa membuka IDE seperti biasa atau beralih kapan saja.

Contoh workflow: Mulai agen untuk membuat kerangka endpoint API baru di satu repo, sementara agen lain memperbaiki bug di library bersama. Pantau dan review perubahan masing-masing sebelum merge.

Mode Desain

Di Agents Window, Design Mode memungkinkan Anda menganotasi UI browser langsung: pilih elemen, highlight area, dan tambahkan ke konteks agen tanpa perlu deskripsi manual. Cocok untuk API developer yang sering menguji frontend.

Pintasan: Cmd+Shift+D untuk toggle, Shift+drag untuk pilih area, Cmd+L untuk tambahkan elemen ke chat.

Aplikasi MCP: Output Konten Terstruktur

Cursor 3 kini mendukung output terstruktur dari aplikasi MCP. Output sebelumnya berupa plain text, sekarang bisa berupa data kaya/terstruktur.

Dengan Apidog MCP Server, respons API (endpoint, skema, hasil tes) disajikan dalam format yang langsung bisa diproses agen Cursor—bukan sekadar text blob.

Worktree, /best-of-n, dan Isolasi

Perintah baru:

/worktree: Buat worktree git terisolasi. Aman untuk eksperimen/destruktif tanpa mengganggu direktori kerja utama.
/best-of-n: Jalankan task yang sama paralel di beberapa model AI, masing-masing di worktree sendiri, lalu bandingkan hasil.

Contoh: Uji bagaimana Claude, GPT-4o, dan Gemini mengimplementasikan endpoint rumit. Pilih hasil terbaik.

Serah Terima Cloud ke Lokal

Agen kini bisa berpindah antara cloud dan lokal: mulai task berat di cloud, lalu tarik ke lokal untuk tes terhadap service nyata; atau dorong sesi ke cloud agar tetap jalan saat laptop dimatikan.

Implikasi untuk Pengembangan API

Pekerjaan API penuh context switching: spesifikasi, klien (Apidog), kode, terminal, dokumentasi—semua terpisah. Cursor 3 mulai menyatukan ini dengan agen persisten dan paralel. Nilai tambahnya makin terasa dengan MCP.

Pengembangan Endpoint Paralel

Bangun REST API dengan banyak endpoint? Tidak perlu lagi sequential. Jelaskan setiap endpoint di agen berbeda, biarkan semua berjalan paralel. Review dan merge hanya yang lolos.

Pembuatan Kode Sadar Skema

Tanpa akses spesifikasi OpenAPI, agen hanya menebak struktur data. Dengan integrasi Apidog MCP Server, agen benar-benar membaca skema: field, tipe, enum, dll. Kode yang dihasilkan langsung sesuai spesifikasi.

Pengujian Kontrak di Editor

Agen Cursor 3 bisa menjalankan perintah terminal. Gabungkan dengan Apidog CLI, dan otomatisasi validasi kontrak langsung dari editor.

Contoh:

apidog run --scenario <test-id>

Agen baca output, iterasi jika gagal, dan Anda bisa langsung review.

Dokumentasi Selalu Sinkron

Agen Cursor 3 bisa membaca dokumentasi Apidog via MCP Server dan membandingkan dengan kode. Ketidaksesuaian dideteksi otomatis—tinggal update spesifikasi atau kode lewat workflow review.

Apa yang Belum Berubah

Cursor 3 tidak otomatis menguji API, validasi auth, atau test load—ini tetap butuh alat QA khusus. Output MCP terstruktur juga bergantung versi; pastikan MCP Server Anda sudah mendukungnya (Apidog sudah).

Cursor 3 + Apidog MCP Server: Workflow Praktis

Ini contoh workflow nyata antara Cursor 3 dan Apidog MCP Server. Bukan sekadar "AI untuk tulis kode," tapi benar-benar integrasi workflow.

Penyiapan

Hubungkan Apidog MCP Server ke Cursor. Di pengaturan MCP Cursor, tambahkan:

{
  "mcpServers": {
    "apidog": {
      "command": "npx",
      "args": ["-y", "@apidog/mcp-server@latest"],
      "env": {
        "APIDOG_ACCESS_TOKEN": "your_access_token"
      }
    }
  }
}

Token akses didapat dari Apidog > Pengaturan Akun > Token Akses API. Setelah terkoneksi, agen Cursor bisa memanggil tools seperti get_endpoint_detail, list_endpoints, get_schema ke proyek Anda.

Contoh Workflow: Buat Kerangka Endpoint Baru dari Spesifikasi

Misal Anda menambah endpoint POST /invoices di Apidog (sudah ada request body, response schema, dan skenario tes).

Di Agents Window, buka sesi agen baru dan beri instruksi:

"Cari endpoint POST /invoices di proyek Apidog. Baca skema permintaan dan respons. Buat handler Node.js/Express sesuai spesifikasi. Jalankan skenario testing untuk verifikasi."

Agen akan:

Ambil detail endpoint via MCP.
Generate handler code dari skema.

Jalankan testing via:

apidog run --scenario invoice-creation-test --env staging

Patch kode jika tes gagal.

Anda review diff terakhir. Kode langsung sesuai spesifikasi karena agen akses skema aktual.

Keunggulan `/best-of-n` untuk Endpoint Kompleks

Untuk endpoint rumit, gunakan /best-of-n. Tiga agen, tiga implementasi berbeda, semua baca spesifikasi Apidog yang sama via MCP. Bandingkan hasil di worktree—pilih yang terbaik.

Sinkronisasi Dokumentasi

Setelah deploy endpoint, jalankan agen kedua:

"Periksa dokumentasi Apidog untuk POST /invoices. Bandingkan dengan kode di invoices.js. Tandai perbedaan. Jika respons di kode beda dari spesifikasi, update spesifikasi Apidog."

Agen membandingkan via MCP, mengusulkan update, dan Anda tinggal review/approve.

Baca lebih lanjut di [ikhtisar server mcp apidog] dan [memulai dengan cli apidog].

Penyiapan Praktis: Mulai Sekarang

Berikut langkah konkret untuk mulai pakai Cursor 3 + Apidog MCP Server.

Langkah 1: Update Cursor

Download latest dari cursor.com. Pastikan Agents Window tersedia di Cmd+Shift+P.

Langkah 2: Buat Token Akses Apidog

Langkah 3: Tambahkan Apidog MCP Server ke Cursor

Di Pengaturan Cursor > MCP, tambahkan konfigurasi:

{
  "mcpServers": {
    "apidog": {
      "command": "npx",
      "args": ["-y", "@apidog/mcp-server@latest"],
      "env": {
        "APIDOG_ACCESS_TOKEN": "your_token_here",
        "APIDOG_PROJECT_ID": "your_project_id"
      }
    }
  }
}

Ambil ID proyek dari URL Apidog Anda. Simpan dan restart Cursor.

Langkah 4: Verifikasi Koneksi

Buka Agents Window, mulai sesi baru, dan ketik: "Daftar endpoint di proyek Apidog saya." Jika list muncul, koneksi sukses.

Langkah 5: Instal dan Konfigurasi Apidog CLI

Untuk eksekusi pengujian, instal Apidog CLI:

npm install -g apidog-cli

Cek dengan apidog -v. Di Apidog, pada skenario testing, buka tab CI/CD dan copy perintah CLI yang sudah disiapkan. Jalankan di terminal Cursor, atau minta agen menjalankan otomatis.

Langkah 6: Jalankan Task Agen MCP Pertama Anda

Di Agents Window, beri instruksi nyata, misal:

"Cari skema objek User di Apidog. Buat TypeScript interface yang persis sama."

Review output dengan skema aktual. Jika tepat, integrasi MCP berfungsi.

Setelah ini, Anda bisa buat workflow lebih kompleks: baca spesifikasi → generate kode → jalankan pengujian—semua dalam satu sesi agen.

Kesimpulan

Cursor 3 mengubah cara Anda bekerja dengan AI di lingkungan pengembangan. Fokus pada agen dan eksekusi paralel cocok dengan pola kerja pengembangan API modern.

Output MCP terstruktur jadi kunci: agen menerima data bersih dan bertipe, sehingga kode yang dihasilkan lebih akurat dan minim koreksi.

Integrasi Cursor 3 + Apidog MCP Server + CLI = workflow di mana agen AI benar-benar memahami API Anda, membaca spesifikasi, generate kode, dan menjalankan testing—bukan sekadar demo, tapi siklus kerja harian.

Pertanyaan yang Sering Diajukan

Apakah Cursor 3 menggantikan IDE lama?

Tidak. Cursor 3 menambah Agents Window sebagai antarmuka baru. Anda bebas beralih ke IDE kapan pun, atau buka keduanya bersamaan.

Apa bedanya Cursor 3 dengan versi sebelumnya?

Arsitektur utama berubah: versi lama fokus pada editor, agen hanya fitur sampingan. Cursor 3 fokus pada agen, editor tetap bisa diakses. Tambahan: eksekusi paralel, serah terima cloud-lokal, Design Mode, /worktree, /best-of-n.

Bagaimana Apidog MCP Server terhubung ke Cursor 3?

Apidog MCP Server ditambahkan sebagai konfigurasi MCP di Cursor Settings. Server mengekspos data API proyek Apidog sebagai tools yang bisa dipanggil agen Cursor (spesifikasi endpoint, skema, skenario tes). Dukungan konten terstruktur berarti data diterima dalam format bertipe, bukan plain text.

Bisakah agen Cursor 3 menjalankan skenario pengujian Apidog otomatis?

Bisa, via Apidog CLI. Agen dapat menjalankan perintah terminal, termasuk skenario Apidog, baca output, dan iterasi kode secara otomatis. Proses ini menciptakan feedback loop antara pembuatan kode dan validasi kontrak API.

Butuh paket berbayar Cursor untuk Agents Window?

Agents Window tersedia di semua paket Cursor 3. Eksekusi cloud agent (agen tetap berjalan walau Anda offline) butuh langganan berbayar. Eksekusi lokal gratis. Cek cursor.com/pricing untuk detail terbaru.

Cara Menjalankan Gemma 4 Secara Lokal dengan Ollama: Panduan Lengkap

Walse — Fri, 03 Apr 2026 02:53:10 +0000

Ringkasan Singkat

Gemma 4 dirilis pada 3 April 2026, dan Ollama v0.20.0 langsung menambahkan dukungan di hari yang sama. Anda bisa menarik (pull) dan menjalankan model default gemma4:e4b hanya dengan dua perintah. Panduan ini akan membimbing Anda mulai dari pengaturan, pemilihan model, penggunaan API, hingga cara menguji endpoint Gemma 4 lokal dengan Apidog.

Coba Apidog hari ini

Pendahuluan

Google merilis Gemma 4 pada 2 April 2026. Dalam 24 jam, Ollama merilis v0.20.0 dengan dukungan penuh untuk keempat varian model.

Bagi developer, ini adalah perubahan besar. Gemma 4 melonjak ke 89,2% di AIME 2026 dari 20,8% (Gemma 3). Benchmark pemrograman naik dari 110 ELO ke 2150 di Codeforces. Ada native function calling, mode berpikir configurable, dan jendela konteks 256K untuk varian besar—semua berjalan di hardware Anda sendiri.

Jika Anda membangun aplikasi berbasis API, menjalankan Gemma 4 lokal memungkinkan AI privat, cepat, dan efisien untuk menghasilkan mock data, menulis skenario pengujian, serta memvalidasi respons API tanpa mengirim data ke cloud.

💡 Setelah Gemma 4 berjalan lokal, Smart Mock Apidog dapat menghasilkan data respons API realistis dari skema Anda menggunakan inferensi AI yang sama. Anda cukup menentukan bentuk API sekali; Apidog menangani mock-nya. Cocok untuk eksperimen model lokal agar data uji konsisten dan sesuai skema tanpa fixture manual.

Panduan ini membahas instalasi hingga panggilan API lokal pertama Anda.

Apa yang Baru di Gemma 4

Gemma 4 hadir dalam empat varian model dengan kemampuan berbeda.

Perbedaan utama dengan Gemma 3:

Penalaran & Coding: Model 31B mencapai 80% di LiveCodeBench v6, jauh di atas 29,1% (Gemma 3 27B).
Mixture-of-Experts (MoE): Varian 26B menggunakan MoE dengan hanya 4B parameter aktif per inferensi—kualitas flagship, biaya komputasi rendah.
Konteks Panjang: E2B dan E4B: 128K token. 26B dan 31B: 256K—cukup untuk basis kode besar atau file API specs dalam satu prompt.
Function Calling Native: Semua model mendukung function calling terstruktur langsung, return JSON valid sesuai skema tanpa prompt engineering.
Input Audio & Gambar: E2B dan E4B mendukung input audio/gambar variabel + teks.
Mode Berpikir: Chain-of-thought reasoning bisa diaktifkan per permintaan; aktifkan untuk coding/matematika kompleks, matikan untuk permintaan sederhana.

Varian Model Gemma 4 Dijelaskan

Sebelum pull, pilih model sesuai hardware:

Model	Ukuran di disk	Konteks	Arsitektur	Terbaik untuk
`gemma4:e2b`	7.2 GB	128K	Dense	Laptop, edge, audio/gambar
`gemma4:e4b`	9.6 GB	128K	Dense	Sebagian besar developer
`gemma4:26b`	18 GB	256K	MoE (4B aktif)	Kualitas terbaik per GB
`gemma4:31b`	20 GB	256K	Dense	Kualitas maksimal

Model e4b adalah default saat menjalankan ollama run gemma4 — cocok untuk GPU konsumer VRAM 10+ GB atau Apple Silicon 16 GB unified memory.

Varian MoE 26b sangat efisien: 4B aktif per token, kecepatan mirip model 4B, kualitas setara 13B. Coba jika punya RAM 20+ GB.

Prasyarat

Ollama v0.20.0+ (versi lama belum mendukung Gemma 4).
Cek versi:

  ollama --version

Jika perlu update:

  # macOS
  brew upgrade ollama

  # Linux
  curl -fsSL https://ollama.com/install.sh | sh

Windows: unduh installer terbaru dari ollama.com.

Persyaratan hardware:

gemma4:e2b: RAM minimal 8 GB (disarankan 16 GB)
gemma4:e4b: VRAM 10 GB / unified memory 16 GB
gemma4:26b: RAM/unified memory 20+ GB
gemma4:31b: VRAM 24 GB / unified memory 32 GB

Instalasi dan Menjalankan Gemma 4

Tarik dan jalankan model default e4b:

ollama run gemma4

Unduhan pertama ±9.6 GB, lalu Anda masuk sesi interaktif. Coba prompt:

>>> What are the HTTP status codes for client errors?

Jalankan varian lain:

# Model Edge
ollama run gemma4:e2b

# Model MoE
ollama run gemma4:26b

# Flagship
ollama run gemma4:31b

Pull tanpa run:

ollama pull gemma4
ollama pull gemma4:26b

Cek model yang tersedia:

ollama list

Menggunakan API Gemma 4 Secara Lokal

Ollama expose API REST lokal di http://localhost:11434. Setelah model di-pull, Anda bisa panggil via HTTP tanpa CLI interaktif.

Generate Completion

curl http://localhost:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "prompt": "Write a JSON response for a user profile API endpoint",
    "stream": false
  }'

Chat Completion (OpenAI-Compatible)

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "messages": [
      {
        "role": "user",
        "content": "Generate a realistic JSON mock for an e-commerce order API response"
      }
    ]
  }'

Klien Python

import requests

def ask_gemma4(prompt: str, model: str = "gemma4") -> str:
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False
        }
    )
    response.raise_for_status()
    return response.json()["response"]

result = ask_gemma4("List the fields a payment API response should include")
print(result)

Menggunakan OpenAI Python SDK

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # required by the SDK but unused by Ollama
)

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {
            "role": "system",
            "content": "You generate realistic API response data in JSON format."
        },
        {
            "role": "user",
            "content": "Generate a sample response for a GET /users/{id} endpoint"
        }
    ]
)

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

Menggunakan Function Calling dengan Gemma 4

Gemma 4 mendukung function calling native. Definisikan skema fungsi, model akan mengembalikan JSON terstruktur sesuai signature Anda.

Contoh implementasi dengan OpenAI SDK:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_user",
            "description": "Retrieve a user by ID from the API",
            "parameters": {
                "type": "object",
                "properties": {
                    "user_id": {
                        "type": "integer",
                        "description": "The unique user ID"
                    },
                    "include_orders": {
                        "type": "boolean",
                        "description": "Whether to include order history"
                    }
                },
                "required": ["user_id"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {"role": "user", "content": "Get user 42 with their order history"}
    ],
    tools=tools,
    tool_choice="auto"
)

tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.function.name)       # get_user
print(tool_call.function.arguments)  # {"user_id": 42, "include_orders": true}

Model secara otomatis mengekstrak parameter dari input natural language dan return JSON valid sesuai skema.

Mengaktifkan Mode Berpikir

Untuk tugas kompleks seperti membuat skenario pengujian atau analisis spesifikasi API, aktifkan chain-of-thought reasoning:

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {
            "role": "user",
            "content": "Design a complete test scenario for a payment processing API with edge cases"
        }
    ],
    extra_body={"think": True}
)

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

Untuk permintaan sederhana, lewati mode berpikir agar latensi tetap rendah.

Menguji Respons API Gemma 4 dengan Apidog

Setelah Gemma 4 lokal berjalan, Anda bisa menguji endpoint API secara otomatis dengan Apidog.

Langkah-langkah:

Impor Spesifikasi API Ollama:

Buat project baru di Apidog, tambahkan base URL http://localhost:11434.
Definisikan Endpoint:
- POST /api/generate untuk completion
- POST /v1/chat/completions untuk chat
- GET /api/tags untuk daftar model
Siapkan Skenario Pengujian:
- Langkah 1: GET /api/tags — pastikan gemma4 tersedia
- Langkah 2: POST /api/generate — pastikan field response tidak kosong
- Langkah 3: POST /v1/chat/completions — validasi format balasan

Gunakan Extract Variable Apidog untuk menangkap value respons dan diteruskan antar langkah.

Validasi Skema Respons:

Uji contract Apidog terhadap OpenAPI spec Anda. Definisikan bentuk respons tiap endpoint, jalankan contract test setelah update model untuk deteksi breaking change.
Smart Mock untuk Pengembangan Paralel:

Backend tergantung Gemma 4? Frontend bisa lanjut kerja tanpa harus tunggu model lokal—Smart Mock Apidog hasilkan respons sesuai skema otomatis.

Pelajari lebih lanjut tentang Apidog.

Input Multimodal dengan Gemma 4

Model E2B dan E4B menerima gambar bersama teks. Kirim gambar sebagai base64 string:

import base64

with open("api_diagram.png", "rb") as f:
    image_data = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="gemma4:e4b",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{image_data}"
                    }
                },
                {
                    "type": "text",
                    "text": "Describe the API flow shown in this diagram and identify potential error paths"
                }
            ]
        }
    ]
)

Sangat berguna untuk analisis diagram arsitektur, review screenshot API docs, atau ekstraksi data dari gambar.

Masalah Umum dan Solusi

Model tidak ditemukan:

Jalankan ollama pull gemma4 atau cek dengan ollama list.
Inferensi lambat di CPU:

Gemma 4 dioptimalkan untuk GPU. Untuk CPU, gunakan gemma4:e2b (paling ringan).
Out-of-memory error:

Cek VRAM/unified memory dengan ollama ps. Jika terlalu besar, gunakan gemma4:e2b.
Model tidak mau load di Apple Silicon:

Ollama 0.20.0 sudah dukung MLX (Apple Silicon). Update Ollama jika belum.
Port sudah digunakan:

Jalankan dengan port custom:

OLLAMA_HOST=0.0.0.0:11435 ollama serve
Respons terpotong:

Tambahkan opsi konteks di request:

"options": {"num_ctx": 8192}

Gemma 4 vs Model Lokal Lainnya

Model	Ukuran Terbaik	Konteks	Function Calling	Benchmark Coding
Gemma 4	e4b (9.6 GB)	128K-256K	Native	80% LiveCodeBench
Llama 3.3	70B-Q4 (40 GB)	128K	Native	~60% LiveCodeBench
Qwen3.6-Plus	72B-Q4 (44 GB)	128K	Native	Kuat
Mistral Small	24B (14 GB)	128K	Native	Sedang

Kelebihan Gemma 4 ada di varian MoE 26B: 18 GB, kualitas flagship, hanya 4B parameter aktif per inferensi = throughput lebih tinggi dari model dense besar.

Untuk coding, model 31B bersaing dengan model jauh lebih besar. Untuk laptop/edge, e2b berjalan di bawah 8 GB.

Kesimpulan

Gemma 4 + Ollama adalah setup lokal AI paling powerful saat ini. Instalasi hanya dua command. Model default berjalan di hampir semua mesin developer. Kenaikan kualitas reasoning dan coding dibanding Gemma 3 sangat terasa.

Mulai dengan ollama run gemma4, uji API Anda dengan Apidog untuk validasi endpoint, lalu pilih varian model sesuai workload (lihat tabel model).

Untuk tim yang membangun fitur API di atas Gemma 4, kombinasi inferensi lokal, Smart Mock, dan Skenario Pengujian Apidog memberi Anda siklus dev lengkap tanpa tergantung cloud.

FAQ

Bagaimana cara memperbarui Gemma 4 di Ollama saat versi baru keluar?

Jalankan ollama pull gemma4 lagi. Ollama otomatis cek versi terbaru dan hanya unduh yang berubah.

Dapatkah saya menjalankan Gemma 4 di mesin tanpa GPU?

Bisa, walau lambat. 1-3 token/detik di CPU. Gunakan model e2b untuk CPU-only.

Apa beda gemma4:e2b dan gemma4:e4b?

Keduanya dense, optimasi untuk edge hardware. E4B lebih besar, lebih baik untuk reasoning. E2B lebih kecil, bisa input audio. Untuk tugas teks, e4b biasanya lebih baik.

Apakah Gemma 4 bekerja dengan LangChain dan LlamaIndex?

Ya. Arahkan provider Ollama ke http://localhost:11434 dan gunakan nama model gemma4.

Apakah API Gemma 4 lokal kompatibel dengan kode OpenAI API?

Sebagian besar, ya. Endpoint /v1/chat/completions kompatibel format OpenAI. Ganti base_url ke http://localhost:11434/v1 dan api_key ke string apa saja.

Bagaimana cara menggunakan mode berpikir Gemma 4?

Tambahkan "think": true di parameter extra_body (OpenAI SDK) atau di body JSON request API. Matikan untuk task sederhana untuk latensi rendah.

Dapatkah saya menyajikan Gemma 4 ke mesin lain di jaringan?

Ya. Jalankan dengan:

OLLAMA_HOST=0.0.0.0:11434 ollama serve

Mesin lain akses via IP Anda dan port 11434.

Model Gemma 4 terbaik untuk tugas pengembangan API?

Untuk mock data dan test case: e4b seimbang antara kecepatan/kualitas. Untuk analisis spesifikasi kompleks: model MoE 26b lebih baik tanpa overhead 31B.

Pelajari lebih lanjut tentang Apidog

Cara Menjalankan Gemma 4 sebagai Backend API

Walse — Fri, 03 Apr 2026 02:40:08 +0000

Singkatnya: Google merilis Gemma 4 pada April 2026, menghadirkan empat model terbuka berlisensi Apache 2.0 yang mampu mengungguli model 20x lebih besar pada tolok ukur standar. Anda dapat mengakses API Gemma 4 via Google AI Studio, Vertex AI, atau menjalankan secara lokal melalui Ollama dan vLLM. Padukan dengan Smart Mock Apidog untuk menghasilkan respons API realistis dari skema OpenAPI Anda secara otomatis tanpa menulis aturan mock manual.

Coba Apidog hari ini

Pendahuluan

Sebagian besar model AI open source biasanya memaksa Anda memilih antara kemampuan mentah atau kemudahan penerapan. Sering kali, model terlalu besar untuk laptop atau terlalu kecil untuk penalaran multi-langkah. Gemma 4 mematahkan kompromi ini.

Gemma 4 adalah keluarga model open source Google DeepMind terkuat sejauh ini. Model Dense 31B menempati urutan ke-3 di Arena AI, mengalahkan model 20x lebih besar. Model MoE 26B menempati posisi ke-6 dan keduanya berjalan di satu GPU 80GB. Model ringan E2B dan E4B dapat berjalan offline di perangkat edge dan ponsel.

Bagi pengembang API, Gemma 4 mendukung pemanggilan fungsi native, output JSON terstruktur, dan jendela konteks 256K. Ini menjadikannya pilihan praktis untuk membangun alat API berbasis AI seperti generator data uji, penulis mock, hingga analisa respons API.

💡Jika Anda membangun dengan Gemma 4 dan perlu memvalidasi respons AI terhadap spesifikasi OpenAPI, mesin Smart Mock Apidog bisa otomatis menghasilkan respons mock sesuai skema API Anda. Tidak perlu menulis aturan mock manual—cukup hubungkan dan data akan dihasilkan sesuai konteks secara instan. Unduh Apidog gratis dan integrasikan ke workflow API Gemma 4 Anda.

Apa itu Gemma 4 dan Apa yang Baru

Gemma 4 adalah generasi keempat model bahasa terbuka Google DeepMind. Nama "Gemma" berasal dari Latin untuk batu permata. Dimulai awal 2024, model Gemma telah diunduh lebih dari 400 juta kali dan komunitas telah merilis 100.000+ varian di ekosistem "Gemmaverse".

Gemma 4 dirilis dengan lisensi Apache 2.0, berbeda dari generasi sebelumnya yang memakai kebijakan kustom. Artinya, Anda bebas menggunakan, memodifikasi, dan mendistribusikan Gemma 4 secara komersial tanpa batasan.

Peningkatan utama Gemma 4 ada pada "kecerdasan-per-parameter". Model Dense 31B menawarkan performa terdepan dengan biaya komputasi jauh lebih efisien daripada GPT-4 atau Claude 3 Sonnet. Di Arena AI (per April 2026), Gemma 4 31B mengalahkan model dengan 600B+ parameter.

Fitur baru Gemma 4 dibanding Gemma 3:

Input multimodal native: Semua model Gemma 4 memproses gambar & video. Model edge E2B/E4B juga mengolah audio untuk pengenalan suara.
Jendela konteks lebih panjang: E2B/E4B mendukung 128K token; 26B/31B hingga 256K token—cukup untuk seluruh repo kode dalam satu prompt.
Dukungan alur kerja agen: Fungsi native, output JSON terstruktur, dan instruksi sistem—memudahkan pembuatan agen API.
Penalaran tingkat lanjut: Model 31B lebih baik pada matematika dan instruksi multi-langkah, ideal untuk generasi uji API.
Dukungan 140+ bahasa: Gemma 4 dilatih native di 140+ bahasa, langsung siap untuk API global.
Lisensi Apache 2.0: Hilangkan ambiguitas hukum untuk penggunaan komersial.

Varian dan Kemampuan Model Gemma 4

Empat ukuran model—setiap varian untuk segmen hardware berbeda:

Model	Parameter	Parameter aktif (inferensi)	Konteks	Terbaik untuk
E2B	Efektif 2B	~2B	128K	Seluler, IoT, edge offline
E4B	Efektif 4B	~4B	128K	Ponsel, Raspberry Pi, Jetson Orin
26B MoE	Total 26B	~3.8B aktif	256K	Server latency-sensitif
31B Dense	31B	31B	256K	Kualitas tertinggi, riset, fine-tuning

E2B/E4B memakai arsitektur Mixture of Experts (MoE), hanya mengaktifkan sebagian kecil parameter tiap token, hemat baterai & RAM, bisa berjalan offline di Android (AICore Developer Preview).

26B MoE hanya mengaktifkan 3.8B parameter saat inferensi, jadi rendah latensi tapi tetap berkualitas.

31B Dense adalah model tertinggi—pilihan tepat untuk fine-tuning domain spesifik atau output kompleks. Semua model tersedia dalam varian instruction-tuned (IT) dan base.

Untuk API, 26B MoE adalah sweet spot kecepatan vs kualitas. Pilih 31B Dense jika butuh output JSON terstruktur atau logika multi-langkah.

Semua model mendukung fungsi native dan mode JSON.

Menyiapkan API Gemma 4: Langkah Praktis

Ada tiga cara utama untuk memanggil Gemma 4: Google AI Studio (prototipe cepat), Vertex AI (enterprise), atau lokal (Ollama/vLLM).

Opsi 1: Google AI Studio (Prototipe Cepat)

Buka Google AI Studio, buat akun gratis, lalu buat API key.
Install SDK Google Generative AI:
```
pip install google-genai
```

Contoh panggilan API:

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")
model = genai.GenerativeModel("gemma-4-31b-it")

response = model.generate_content(
    "Generate a JSON object for a user account with id, email, and created_at fields."
)

print(response.text)

Output JSON terstruktur dengan response_mime_type:

import google.generativeai as genai
import json

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel(
    "gemma-4-31b-it",
    generation_config={"response_mime_type": "application/json"}
)

prompt = '''
Generate 3 sample user objects for an e-commerce API. 
Each user should have: id (integer), email (string), username (string), 
created_at (ISO 8601 timestamp), and subscription_tier (free|pro|enterprise).
Return as a JSON array.
'''

response = model.generate_content(prompt)
users = json.loads(response.text)
print(json.dumps(users, indent=2))

Opsi 2: Lokal dengan Ollama

Install Ollama.
Tarik model:
```
ollama pull gemma4
```
Jalankan server:
```
ollama serve
```

Panggil model via API OpenAI-compatible:

import requests
import json

response = requests.post(
    "http://localhost:11434/api/chat",
    json={
        "model": "gemma4",
        "messages": [
            {
                "role": "user",
                "content": "Generate a valid JSON response for a REST API /products endpoint. Include id, name, price, and stock fields."
            }
        ],
        "stream": False
    }
)

result = response.json()
print(result["message"]["content"])

Opsi 3: Pemanggilan Fungsi API

Untuk membangun pipeline API agen, manfaatkan pemanggilan fungsi native:

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

tools = [
    {
        "function_declarations": [
            {
                "name": "get_api_schema",
                "description": "Retrieve the OpenAPI schema for a given endpoint path",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "endpoint_path": {
                            "type": "string",
                            "description": "The API endpoint path, e.g. /users/{id}"
                        },
                        "method": {
                            "type": "string",
                            "enum": ["GET", "POST", "PUT", "DELETE", "PATCH"]
                        }
                    },
                    "required": ["endpoint_path", "method"]
                }
            }
        ]
    }
]

model = genai.GenerativeModel("gemma-4-31b-it", tools=tools)

response = model.generate_content(
    "I need to test the GET /users/{id} endpoint. What schema should the response follow?"
)

if response.candidates[0].content.parts[0].function_call:
    fc = response.candidates[0].content.parts[0].function_call
    print(f"Model called function: {fc.name}")
    print(f"With args: {dict(fc.args)}")

Pemanggilan fungsi ini sangat berguna untuk pipeline pengujian API otomatis.

Mock API Otomatis dengan Gemma 4

Untuk pengembang API, Gemma 4 sangat efektif dalam menghasilkan data mock. Cocok untuk prototyping frontend, pengujian edge case, hingga validasi skema.

Contoh prompt data mock dari skema OpenAPI:

import google.generativeai as genai
import json

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel(
    "gemma-4-31b-it",
    generation_config={"response_mime_type": "application/json"}
)

schema = {
    "type": "object",
    "properties": {
        "id": {"type": "integer"},
        "order_number": {"type": "string", "pattern": "^ORD-[0-9]{6}$"},
        "status": {"type": "string", "enum": ["pending", "shipped", "delivered", "cancelled"]},
        "total": {"type": "number", "minimum": 0},
        "items": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "product_id": {"type": "integer"},
                    "quantity": {"type": "integer", "minimum": 1},
                    "unit_price": {"type": "number"}
                }
            }
        },
        "created_at": {"type": "string", "format": "date-time"}
    }
}

prompt = f"""
Generate 5 realistic mock responses for an order management API.
Each response must conform exactly to this JSON Schema:
{json.dumps(schema, indent=2)}

Make the data realistic: use realistic prices, product IDs, and varied statuses.
Return as a JSON array of 5 order objects.
"""

response = model.generate_content(prompt)
mock_orders = json.loads(response.text)
print(json.dumps(mock_orders, indent=2))

Gemma 4 memahami constraint JSON Schema—enum, pola string, rentang numerik—dan akan menghasilkan data sesuai kontrak API, bukan sekadar string acak.

Workflow praktis: ekspor koleksi Apidog Anda sebagai OpenAPI, tempel ke prompt, lalu generate 10 kasus uji realistis per endpoint. Hemat waktu—tidak perlu manual mocking.

Menguji Respons API Gemma 4 dengan Apidog

Setelah Gemma 4 menghasilkan data, Anda perlu memastikan output-nya valid sesuai skema. Berikut langkah implementasi di Apidog:

Langkah 1: Impor endpoint API Gemma 4 Anda ke Apidog.

Buat endpoint baru di proyek Apidog Anda, arahkan ke API wrapper Gemma 4 (atau endpoint Google AI Studio). Definisikan skema respons di Apidog.

Langkah 2: Gunakan Smart Mock untuk prototipe respons.

Smart Mock otomatis menghasilkan data realistis berdasarkan skema. Properti seperti email otomatis diisi dengan email valid, created_at dengan timestamp ISO8601.

Smart Mock mengutamakan: nilai custom, inferensi nama properti, lalu default schema JSON.

Langkah 3: Buat Skenario Pengujian pipeline Gemma 4.

Di modul Pengujian Apidog, buat Skenario Pengujian baru. Tambahkan panggilan API Gemma 4, lalu langkah asersi validasi respons.

Panggil endpoint autentikasi (jika ada)
Kirim prompt ke Gemma 4 beserta token auth
Ekstrak JSON dari body respons
Validasi JSON terhadap skema
Lanjutkan data ke endpoint POST berikutnya

Langkah 4: Setup asersi.

Validasi kode status, header, dan field JSON. Untuk Gemma 4, cek candidates[0].content.parts[0].text dan parsing JSON-nya sesuai skema.

Gunakan prosesor Ekstrak Variabel Apidog untuk menarik output ke variabel, lalu gunakan di permintaan berikutnya.

Langkah 5: Jalankan pengujian berbasis data.

Apidog mendukung file data uji CSV/JSON. Definisikan banyak variasi prompt, jalankan sekaligus. Integrasi mudah ke pipeline CI/CD via Apidog CLI.

Pipeline dari definisi skema hingga eksekusi pengujian bisa disiapkan dalam 15 menit.

Kasus Penggunaan Nyata

Generasi data uji API: Dengan Gemma 4 mode output JSON + skema OpenAPI, generate ratusan data uji dalam menit. Input skema, tentukan edge case, biarkan model buat datanya.
Mocking API cerdas: Mock statis diganti dengan respons dinamis berbasis konteks. Contoh: API pencarian produk mengembalikan hasil berbeda sesuai query tanpa hardcoded case.
Otomatisasi dokumentasi API: Jendela konteks 256K memungkinkan seluruh kode base masuk prompt. Generate dokumentasi OpenAPI otomatis, bahkan generate spesifikasi dari file route.
Validasi skema respons: Analisis respons API pihak ketiga dengan Gemma 4, tandai pelanggaran skema lebih akurat dari validator JSON Schema sederhana.
Penulisan uji regresi otomatis: Beri model spesifikasi API & bug report, minta generate test case untuk mendeteksi bug tersebut. Gemma 4 memahami dependency & status transition antar field.

Gemma 4 vs Model Terbuka Lain untuk API

Model	Parameter	Konteks	Output JSON	Pemanggilan fungsi	Lisensi
Gemma 4 31B	31B	256K	Native	Native	Apache 2.0
Gemma 4 26B MoE	26B (3.8B aktif)	256K	Native	Native	Apache 2.0
Llama 3.3 70B	70B	128K	Via prompt	Via prompt	Lisensi Komunitas Llama
Mistral 7B	7B	32K	Via prompt	Terbatas	Apache 2.0
Qwen 2.5 72B	72B	128K	Native	Native	Apache 2.0

Fitur kritikal API: output JSON native, fungsi native, konteks panjang. Gemma 4 31B & 26B punya ketiganya.

Llama 3.3 70B setara performa tapi butuh 2x GPU dibanding Gemma 4 31B. Qwen 2.5 72B juga kuat, tapi lebih berat secara hardware.

Lisensi Apache 2.0 Gemma 4 lebih jelas untuk produk komersial dibanding Llama Community License.

Rekomendasi: 26B MoE untuk API latency-sensitif, 31B Dense untuk kualitas/output kompleks.

Kesimpulan

Gemma 4 adalah alternatif terbuka kredibel untuk API AI proprietary dalam pengembangan alat API. Lisensi Apache 2.0 menghilangkan friksi legal. Fungsi native & output JSON membuat integrasi API sederhana tanpa prompt engineering rumit.

Empat ukuran model mencakup semua kebutuhan hardware. 26B MoE adalah opsi seimbang untuk sebagian besar workflow API. Integrasikan dengan Apidog untuk workflow validasi otomatis: Gemma 4 untuk data uji/mock, Apidog Smart Mock untuk prototipe skema, dan Skenario Pengujian untuk validasi output AI. Alur kerja ini mempercepat pembangunan & pengujian API berbasis AI.

FAQ

Apa itu Gemma 4? Gemma 4 adalah keluarga model bahasa terbuka terbaru Google DeepMind, dirilis April 2026, dalam 4 ukuran (E2B, E4B, 26B MoE, 31B Dense) dengan lisensi Apache 2.0.

Apakah Gemma 4 gratis digunakan? Bobot model gratis (Apache 2.0). Biaya hanya pada komputasi. Google AI Studio menyediakan tier gratis terbatas, Vertex AI berbayar sesuai tarif Google Cloud.

Bisakah Gemma 4 menghasilkan JSON terstruktur? Ya, dengan parameter response_mime_type: "application/json" di SDK Google Generative AI. Output selalu valid JSON.

Bagaimana perbandingan Gemma 4 dengan GPT-4o untuk API? GPT-4o proprietary, tanpa opsi lokal dan biaya API lebih tinggi. Gemma 4 31B gratis untuk deploy lokal dan punya skor benchmark kompetitif. Cocok untuk tim yang butuh privasi data/kontrol biaya.

Bisakah saya fine-tune Gemma 4 dengan data API sendiri? Ya, via Google AI Studio, Vertex AI, atau tools pihak ketiga (Hugging Face TRL). Fine-tuning pada skema/pola respons API akan tingkatkan output.

Perangkat keras apa yang dibutuhkan untuk menjalankan Gemma 4 lokal? 31B & 26B muat di satu NVIDIA H100 80GB bfloat16. Versi kuantisasi bisa jalan di GPU consumer VRAM 16-24GB. E4B/E2B berjalan di ponsel/edge.

Apakah Gemma 4 mendukung fungsi native? Ya, semua model Gemma 4 support pemanggilan fungsi native. Definisikan alat sebagai JSON, model akan memanggil sesuai instruksi.

Bagaimana cara menguji respons API Gemma 4 otomatis? Gunakan Skenario Pengujian Apidog—impor endpoint, setup permintaan, tambahkan asersi validasi struktur respons. Jalankan lokal, via CLI, atau otomatis di pipeline CI/CD pada setiap push kode.

API Qwen3.6-Plus: Ungguli Claude dalam Benchmark Terminal

Walse — Thu, 02 Apr 2026 09:33:34 +0000

Inti Singkat

Qwen3.6-Plus resmi diluncurkan. Model ini mencapai skor 78,8% pada SWE-bench Verified dan 61,6% pada Terminal-Bench 2.0, melampaui Claude Opus 4.5. Dengan jendela konteks 1 juta token, parameter preserve_thinking baru untuk loop agen, serta kompatibilitas API OpenAI, model ini siap digunakan di berbagai skenario automasi pengembangan.

Coba Apidog hari ini

Dari Pratinjau ke Rilis

Jika Anda sudah mengikuti panduan Qwen 3.6 Plus Preview di OpenRouter, Anda pasti paham kemampuannya. Versi pratinjau rilis diam-diam pada 30 Maret, tanpa daftar tunggu, gratis lewat OpenRouter. Dalam dua hari, model ini memproses 400 juta token dari 400.000 permintaan.

Kini, rilis resmi membawa versi produksi penuh: tersedia di Alibaba Cloud Model Studio, API stabil, SLA uptime, dan parameter baru untuk tugas agen multi-langkah.

Panduan ini membahas perubahan utama, cara pemanggilan API yang benar, serta pengujian integrasi dengan Apidog sebelum deployment.

Apa itu Qwen3.6-Plus

Qwen3.6-Plus adalah model mixture-of-experts dari tim Qwen Alibaba. Seperti Qwen3.5, model ini memakai sparse activation—hanya sebagian parameter aktif per token—sehingga performa tinggi bisa dicapai tanpa biaya komputasi besar seperti dense model.

Spesifikasi utama:

Jendela konteks 1 juta token
Chain-of-thought wajib
Parameter preserve_thinking untuk tugas agensi
Dukungan multimodal: penglihatan, video, dokumen
API kompatibel OpenAI, Anthropic, dan OpenAI Responses

Varian open-source ukuran kecil akan segera tersedia. Jika butuh model self-hosted, tunggu update-nya.

Hasil Benchmark

Agen Pengkodean

Qwen3.6-Plus sedikit di belakang Claude Opus 4.5 pada SWE-bench, tapi memimpin operasi terminal.

Terminal-Bench 2.0 menguji operasi shell nyata: manajemen file, kontrol proses, alur kerja terminal multi-langkah dalam 3 jam, 32 inti CPU, 48GB RAM. Skor 61,6% vs 59,3% (Claude Opus 4.5) adalah selisih signifikan untuk tugas developer.

Agen Umum & Penggunaan Alat

Benchmark	Claude Opus 4.5	Qwen3.6-Plus
TAU3-Bench	70,2%	70,7%
DeepPlanning	33,9%	41,5%
MCPMark	42,3%	48,2%
MCP-Atlas	71,8%	74,1%
WideSearch	76,4%	74,3%

MCPMark menguji pemanggilan alat GitHub MCP v0.30.3. Qwen3.6-Plus unggul di MCP dan DeepPlanning, penting untuk workflow berbasis MCP dan perencanaan jangka panjang.

Penalaran & Pengetahuan

Benchmark	Claude Opus 4.5	Qwen3.6-Plus
GPQA	87,0%	90,4%
LiveCodeBench v6	84,8%	87,1%
IFEval strict	90,9%	94,3%
MMLU-Pro	89,5%	88,5%

Qwen3.6-Plus memimpin pada GPQA dan IFEval strict—krusial untuk output terstruktur dan tugas agensi dengan instruksi kompleks.

Multimodal

Benchmark	Qwen3.6-Plus	Catatan
OmniDocBench 1.5	91,2%	Teratas di tabel
RefCOCO avg	93,5%	Teratas di tabel
We-Math	89,0%	Teratas di tabel
CountBench	97,6%	Teratas di tabel
OSWorld-Verified	62,5%	Di bawah Claude (66,3%)

Qwen3.6-Plus unggul di tugas pemahaman dokumen dan deteksi objek, namun sedikit di bawah Claude pada OSWorld-Verified (desktop automation).

Cara Memanggil API

Qwen3.6-Plus tersedia di Alibaba Cloud Model Studio. Dapatkan API key di modelstudio.alibabacloud.com.

Endpoint regional:

Singapura: https://dashscope-intl.aliyuncs.com/compatible-mode/v1
Beijing: https://dashscope.aliyuncs.com/compatible-mode/v1
US Virginia: https://dashscope-us.aliyuncs.com/compatible-mode/v1

Panggilan Dasar dengan Streaming

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["DASHSCOPE_API_KEY"],
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
    model="qwen3.6-plus",
    messages=[{"role": "user", "content": "Tinjau fungsi Python ini dan temukan bug."}],
    extra_body={"enable_thinking": True},
    stream=True
)

reasoning = ""
answer = ""
is_answering = False

for chunk in completion:
    if not chunk.choices:
        continue
    delta = chunk.choices[0].delta
    if hasattr(delta, "reasoning_content") and delta.reasoning_content:
        if not is_answering:
            reasoning += delta.reasoning_content
    if delta.content:
        if not is_answering:
            is_answering = True
        answer += delta.content
        print(delta.content, end="", flush=True)

Parameter `preserve_thinking`

Pada versi pratinjau, penalaran hanya disimpan untuk giliran saat ini. Rilis resmi menambahkan preserve_thinking.

Aktifkan preserve_thinking: true untuk mempertahankan chain-of-thought seluruh giliran percakapan, ideal untuk loop agen multi-langkah.

completion = client.chat.completions.create(
    model="qwen3.6-plus",
    messages=conversation_history,
    extra_body={
        "enable_thinking": True,
        "preserve_thinking": True, # pertahankan penalaran di semua giliran
    },
    stream=True
)

Qwen3.6-Plus dengan Claude Code

API Qwen kompatibel dengan protokol Anthropic. Jalankan Claude Code di Qwen3.6-Plus hanya dengan mengubah env variable.

npm install -g @anthropic-ai/claude-code

export ANTHROPIC_MODEL="qwen3.6-plus"
export ANTHROPIC_SMALL_FAST_MODEL="qwen3.6-plus"
export ANTHROPIC_BASE_URL=https://dashscope-intl.aliyuncs.com/apps/anthropic
export ANTHROPIC_AUTH_TOKEN=your_dashscope_api_key

claude

Qwen3.6-Plus dengan OpenClaw

OpenClaw (eks Moltbot/Clawdbot) adalah agen pengkodean open source yang bisa self-hosted.

# Instal (Node.js 22+)
curl -fsSL https://molt.bot/install.sh | bash

export DASHSCOPE_API_KEY=your_key
openclaw dashboard

Edit ~/.openclaw/openclaw.json:

{
  "models": {
    "providers": [{
      "name": "alibaba-coding-plan",
      "baseUrl": "https://coding-intl.dashscope.aliyuncs.com/v1",
      "apiKey": "${DASHSCOPE_API_KEY}",
      "models": [{"id": "qwen3.6-plus", "reasoning": true}]
    }]
  },
  "agents": {
    "defaults": {"models": ["qwen3.6-plus"]}
  }
}

Qwen3.6-Plus dengan Qwen Code

Qwen Code adalah agen terminal open source dari Alibaba, khusus untuk seri Qwen. Dapatkan 1.000 API call gratis/hari dengan Qwen Code OAuth.

npm install -g @qwen-code/qwen-code@latest
qwen
# Ketik /auth untuk login & aktifkan quota gratis

Mengapa `preserve_thinking` Penting untuk Agen

Mayoritas API LLM memperlakukan setiap giliran secara independen. Pada loop agen multi-langkah, model tanpa preserve_thinking bisa kehilangan konteks penalaran sebelumnya sehingga keputusan jadi kurang konsisten.

Aktifkan preserve_thinking agar model melihat seluruh chain-of-thought:

conversation = []

def agent_step(user_message, preserve=True):
    conversation.append({"role": "user", "content": user_message})

    response = client.chat.completions.create(
        model="qwen3.6-plus",
        messages=conversation,
        extra_body={
            "enable_thinking": True,
            "preserve_thinking": preserve,
        },
        stream=False
    )

    message = response.choices[0].message
    conversation.append({"role": "assistant", "content": message.content})
    return message.content

# Contoh: agen tinjauan kode multi-langkah
result = agent_step("Analisis modul otentikasi untuk masalah keamanan.")
result = agent_step("Sekarang sarankan perbaikan untuk 3 masalah teratas yang Anda temukan.")
result = agent_step("Tulis tes yang memvalidasi setiap perbaikan.")

Tanpa preserve_thinking, pada langkah ke-3 model tidak tahu masalah yang sudah diidentifikasi di langkah 1. Dengan parameter ini, chain-of-thought tetap utuh di semua giliran.

Use Case Terbaik

Perbaikan bug tingkat repositori: SWE-bench Verified 78,8% dan SWE-bench Pro 56,6%. Cocok untuk automasi perbaikan kode atau code review pipeline.
Otomatisasi terminal: Skor Terminal-Bench 2.0 tertinggi di kelasnya. Cocok untuk operasi shell, manajemen proses, pipeline build.
Pemanggilan alat MCP: MCPMark 48,2%—terbaik untuk workflow berbasis MCP.
Analisis dokumen konteks panjang: Jendela 1 juta token, skor LongBench v2 tinggi. Untuk codebase besar, spesifikasi panjang, analisis multi-file.
Pembuatan kode frontend: Skor QwenWebBench internal 1501,7 vs Claude Opus 4.5 (1517,9), setara untuk kualitas frontend generation.
Multibahasa: WMT24++ 84,3% (teratas), MAXIFE 88,2% di 23 bahasa. Kuat untuk use case non-Inggris.

Menguji API Qwen3.6-Plus dengan Apidog

Endpoint Qwen3.6-Plus kompatibel OpenAI. Impor langsung ke Apidog dan lakukan pengujian seperti API lainnya.

Endpoint: https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions
Header: Authorization: Bearer {{DASHSCOPE_API_KEY}}

Contoh Assertion

pm.test("Respons berisi pilihan", () => {
  const body = pm.response.json();
  pm.expect(body).to.have.property("choices");
  pm.expect(body.choices[0].message.content).to.be.a("string").and.not.empty;
});

pm.test("Tidak ada penalaran kosong saat pemikiran diaktifkan", () => {
  const choice = pm.response.json().choices[0];
  if (choice.message.reasoning_content !== undefined) {
    pm.expect(choice.message.reasoning_content).to.not.be.empty;
  }
});

Gunakan Smart Mock Apidog untuk generate respons pengujian selama development, menghemat token dan mempercepat siklus pengujian.

Jika membangun agen multi-turn, buat Skenario Pengujian di Apidog dengan beberapa request berurutan. Validasi bahwa preserve_thinking membawa penalaran antar giliran dengan cek struktur respons di setiap langkah sebelum production.

Unduh Apidog gratis untuk menyiapkan pengujian ini.

Apa yang Akan Datang

Tim Qwen mengonfirmasi varian open-source ukuran kecil akan dirilis dalam beberapa hari, mengikuti pola MoE Qwen3.5 dengan bobot Apache 2.0 publik.

Roadmap:

Tugas tingkat repositori jangka panjang: penyelesaian masalah multi-file yang makin kompleks
Pengembangan agen multimodal: GUI agent & pengkodean visual sebagai core feature

Varian open-source Qwen3.5 menjadi model self-host paling populer dalam beberapa minggu. Jika Qwen3.6 mengikuti pola ini, varian kecilnya akan jadi pilihan utama agen pengkodean self-hosted.

Kesimpulan

Qwen3.6-Plus menutup gap dengan Claude Opus 4.5 pada tugas pengkodean dan unggul pada operasi terminal, pemanggilan alat MCP, serta perencanaan jangka panjang. Dukungan konteks 1 juta token, kompatibilitas protokol Anthropic, dan parameter preserve_thinking menjadikannya pilihan praktis untuk sistem agensi produksi modern.

Pratinjau gratis di OpenRouter cocok untuk evaluasi model. API resmi memberikan stabilitas, SLA, dan parameter baru yang mengoptimalkan workflow multi-turn.

Apidog menangani pengujian: impor endpoint kompatibel OpenAI, tulis assertion respons, mock saat development, dan jalankan regresi testing setiap update model/API.

FAQ

Apa perbedaan Qwen3.6-Plus dan pratinjau?

Pratinjau (qwen/qwen3.6-plus-preview) diluncurkan di OpenRouter pada 30 Maret 2026. Rilis resmi menambah parameter preserve_thinking, SLA uptime, dan dukungan penuh Model Studio. Varian open-source kecil segera hadir.

Apa itu preserve_thinking dan kapan digunakan?

Default: hanya penalaran giliran saat ini yang disimpan. Dengan preserve_thinking: true, model mempertahankan chain-of-thought seluruh percakapan. Gunakan untuk loop agen multi-step.

Bagaimana Qwen3.6-Plus dibanding Claude Opus 4.5?

Claude Opus 4.5 unggul di SWE-bench Verified (80,9% vs 78,8%) dan OSWorld-Verified (66,3% vs 62,5%). Qwen3.6-Plus unggul di Terminal-Bench 2.0 (61,6% vs 59,3%), MCPMark (48,2% vs 42,3%), DeepPlanning (41,5% vs 33,9%), dan GPQA (90,4% vs 87,0%).

Bisakah Qwen3.6-Plus dipakai dengan Claude Code?

Ya. Set ANTHROPIC_BASE_URL ke endpoint Dashscope, ANTHROPIC_MODEL ke qwen3.6-plus, dan ANTHROPIC_AUTH_TOKEN ke API key Dashscope Anda.

Apakah Qwen3.6-Plus open source?

Model hosted API bukan open-weight. Varian kecil dengan bobot publik akan dirilis dalam beberapa hari.

Bagaimana cara mendapatkan akses gratis?

Instal Qwen Code (npm install -g @qwen-code/qwen-code@latest), jalankan qwen, lalu /auth. Login dengan Qwen Code OAuth untuk 1.000 API call gratis/hari.

Jendela konteks yang didukung?

1 juta token default. Beberapa benchmark memakai 256K untuk standar, tapi default API 1M.

Bagaimana menguji integrasi API sebelum deployment?

Impor endpoint ke Apidog, tambahkan API key sebagai variabel lingkungan, tulis assertion respons, gunakan Smart Mock untuk development offline, dan rangkai request ke Skenario Pengujian untuk validasi agen multi-giliran.

Holo3: Model Penggunaan Komputer Terbaik?

Walse — Thu, 02 Apr 2026 08:54:30 +0000

Intinya

H Company meluncurkan Holo3 pada 31 Maret 2026, sebuah model mixture-of-experts yang mencetak 78,85% pada OSWorld-Verified, angka tertinggi yang pernah tercatat pada benchmark penggunaan komputer desktop terkemuka. Ini mengalahkan GPT-5.4 dan Opus 4.6 dengan biaya yang jauh lebih rendah. API sudah tersedia sekarang, dan varian 35B bersifat open-weight di HuggingFace di bawah lisensi Apache 2.0.

Coba Apidog hari ini

Kesenjangan penggunaan komputer yang belum dipecahkan sebagian besar pengembang

Anda sudah mengotomatisasi API Anda. Pipeline CI/CD berjalan lancar. Tapi, masih ada tugas yang sulit diotomatisasi: perangkat lunak perusahaan lama tanpa API, aplikasi desktop sebelum era REST, dan alur kerja multi-langkah yang harus melintasi banyak UI berbeda.

Alat RPA tradisional (UiPath, Automation Anywhere) biasanya menggunakan skrip koordinat layar yang mudah rusak ketika UI berubah. Solusi lain: kerja manual.

Model AI penggunaan komputer mengubah pendekatan ini. Model yang bisa membaca tangkapan layar dan mengeluarkan tindakan klik, ketik, atau gulir dapat menavigasi GUI tanpa perlu API. Holo3, dirilis 31 Maret 2026 oleh H Company, saat ini adalah model publik terkuat untuk tugas-tugas ini.

💡 Jika Anda membangun workflow otomatisasi atau pipeline pengujian yang berhubungan dengan perangkat lunak desktop, API Holo3 layak dipelajari. Jika Anda menggunakan Apidog untuk desain dan pengujian API, bagian di bawah menjelaskan cara mengintegrasikan Holo3 ke workflow Anda dengan langkah praktis.

Apa itu Holo3?

Holo3 adalah model AI penggunaan komputer: berikan tangkapan layar desktop atau browser, beri tahu tugasnya, dan model akan mengembalikan aksi (klik, ketik, scroll) yang bisa dieksekusi di layar tersebut. Loop: tangkap hasil, screenshot ulang, ulangi sampai selesai.

H Company menawarkan dua varian:

Holo3-122B-A10B — 122B parameter (10B aktif, sparse MoE). Hanya tersedia via API hcompany.ai/holo-models-api. Rekor benchmark saat ini.
Holo3-35B-A3B — 35B (3B aktif). Open-weight di HuggingFace (Apache 2.0). Ada tier gratis di API. Bisa di-host sendiri.

Arsitektur MoE memastikan hanya sebagian kecil parameter aktif per token, membuat model jauh lebih efisien dijalankan. H Company menyatakan Holo3-122B-A10B lebih murah dari GPT-5.4 dan Opus 4.6 per tugas.

OSWorld-Verified: Apa yang Diukur

OSWorld-Verified adalah benchmark utama untuk AI penggunaan komputer. Berbeda dengan benchmark berbasis teks, OSWorld menilai eksekusi nyata: agen harus menyelesaikan tugas di komputer sungguhan, diverifikasi dengan memeriksa status sistem akhir.

Tugas meliputi:

Satu aplikasi (membuka file, isi form, copy antar sel)
Lintas aplikasi (ambil data dari PDF, update spreadsheet, kirim email)
Urutan multi-aplikasi jangka panjang

Holo3-122B-A10B mendapatkan 78,85% pada OSWorld-Verified. Sebelumnya, skor >40% dianggap state-of-the-art. Model Anthropic dan OpenAI sebelumnya berkisar 60-65%.

Performa terbaik Holo3 ada di tugas multi-aplikasi yang membutuhkan koordinasi data di beberapa aplikasi secara bersamaan.

Cara Holo3 Dilatih: Agentic Learning Flywheel

Kebanyakan model penggunaan komputer dilatih dengan demonstrasi statis. H Company menggunakan pendekatan Agentic Learning Flywheel:

Data Navigasi Sintetis — Kombinasi instruksi manusia & AI untuk contoh navigasi skenario.
Augmentasi di Luar Domain — Ekspansi skenario ke status UI tak terduga & edge case.
Pembelajaran Penguatan Terkurasi — Data difilter & dipakai pada pipeline RL, langsung memaksimalkan tingkat penyelesaian tugas.

Data berasal dari Synthetic Environment Factory: sistem di mana agen membangun aplikasi web perusahaan dari nol, sehingga pelatihan dilakukan pada workflow bisnis realistis.

Hasil: Holo3 mengungguli model Qwen3.5 yang lebih besar pada tugas benchmark yang sama – bukan semata-mata soal arsitektur, tapi metodologi training.

Cara Memanggil API Holo3

API Holo3 menggunakan pola loop screenshot-action. Berikut implementasi step-by-step:

1. Siapkan Autentikasi

# API Inferensi H Company
https://api.hcompany.ai/v1

# Header
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

Dapatkan API key di hcompany.ai/holo-models-api. Tier gratis tersedia untuk Holo3-35B-A3B.

2. Kirim Screenshot dan Tugas

import base64
import httpx
import pyautogui

screenshot = pyautogui.screenshot()
screenshot.save("/tmp/screen.png")

with open("/tmp/screen.png", "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode()

response = httpx.post(
    "https://api.hcompany.ai/v1/computer-use",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "model": "holo3-122b-a10b",
        "task": "Open the invoice folder and find the most recent PDF",
        "screenshot": image_b64,
        "screen_width": 1920,
        "screen_height": 1080
    }
)

action = response.json()
print(action)

3. Uraikan & Eksekusi Tindakan

API mengembalikan aksi terstruktur, misal:

{
  "action_type": "click",
  "coordinate": [245, 380],
  "reasoning": "Ikon folder faktur terlihat pada posisi ini"
}

Jenis aksi: click, double_click, right_click, type, key, scroll, screenshot_request, task_complete.

4. Ulangi Sampai Selesai

def run_computer_use_task(task: str, max_steps: int = 20):
    for step in range(max_steps):
        screenshot = capture_screen()
        response = call_holo3_api(task, screenshot)
        action = response["action"]

        if action["action_type"] == "task_complete":
            print(f"Selesai dalam {step + 1} langkah")
            return response["result"]

        execute_action(action)

    raise TimeoutError("Tugas tidak selesai dalam batas langkah")

Menguji Panggilan API Holo3 dengan Apidog

Setelah memanggil API Holo3, pastikan integrasi Anda andal, terutama untuk otomatisasi produksi. Apidog sangat membantu.

Impor endpoint:

Buat permintaan HTTP baru di Apidog ke https://api.hcompany.ai/v1/computer-use. Tambahkan header Authorization sebagai variabel environment agar aman.

Setup validasi respons (assertion):

// Di skrip post-response Apidog
pm.test("Jenis tindakan valid", () => {
    const validActions = ["click", "type", "key", "scroll", "task_complete", "screenshot_request"];
    pm.expect(validActions).to.include(pm.response.json().action.action_type);
});

pm.test("Koordinat dalam batas layar", () => {
    const action = pm.response.json().action;
    if (action.coordinate) {
        pm.expect(action.coordinate[0]).to.be.within(0, 1920);
        pm.expect(action.coordinate[1]).to.be.within(0, 1080);
    }
});

Mock API selama pengembangan:

Gunakan fitur Smart Mock Apidog untuk mensimulasikan respons Holo3 realistis tanpa memanggil API asli. Hemat kuota dan percepat pengembangan frontend/orchestration.

Jalankan skenario pengujian:

Rangkai beberapa permintaan Holo3 dalam Skenario Pengujian Apidog untuk mensimulasikan loop tugas multi-langkah sebelum dijalankan di mesin nyata.

Holo3 vs Claude Computer Use vs OpenAI Operator

	Holo3-122B	Holo3-35B	Claude Computer Use	OpenAI Operator
OSWorld-Verified	78.85%	~55% (est.)	~65%	~62%
Akses API	Ya	Ya (tingkat gratis)	Ya	Ya
Bobot terbuka	Tidak	Ya (Apache 2.0)	Tidak	Tidak
Dapat di-host sendiri	Tidak	Ya	Tidak	Tidak
Biaya vs GPT-5.4	Lebih rendah	Jauh lebih rendah	Setara	Harga GPT-5.4
Terbaik untuk	Perusahaan produksi	Dev/pengujian/OSS	Ekosistem Anthropic	Ekosistem OpenAI

Rekomendasi praktis:

Holo3-122B: Akurasi maksimal untuk workflow multi-aplikasi kompleks, biaya jadi pertimbangan kedua.
Holo3-35B: Pengembangan, testing, open source, atau ingin self-host.
Claude Computer Use: Sudah deep di ekosistem Anthropic dan ingin billing terpadu.
OpenAI Operator: Sudah pakai GPT-5.4 dan ingin vendor tunggal.

Kasus Penggunaan Perusahaan

Holo3 sangat tepat untuk workflow tanpa solusi API bersih:

Entri data sistem lama: ERP/CRM lawas tanpa API REST. Holo3 bisa navigasi UI desktop dan input/ekstrak data tanpa modernisasi besar.
Rekonsiliasi lintas platform: Ambil angka dari PDF, cek ke spreadsheet, update dashboard pihak ketiga — semua otomatis.
Testing regresi aplikasi web: Gantikan Selenium rapuh. Berikan deskripsi tugas ke Holo3, adaptasi otomatis ke perubahan UI.
Intelijen kompetitif: Scrape data struktur dari web yang memblokir scraping tradisional.

Benchmark internal H Company menunjukkan Holo3 unggul di E-commerce, Business Software, Collaboration, dan Multi-Application Workflow. Kesenjangan terbesar pada tugas multi-aplikasi – penalaran di beberapa aplikasi sekaligus.

Apa Selanjutnya: Agensi Adaptif

Langkah berikutnya dari H Company adalah Agensi Adaptif — model yang bisa belajar menavigasi perangkat lunak perusahaan yang benar-benar baru secara real-time.

Model saat ini (termasuk Holo3) masih dilatih pada set lingkungan terbatas. Untuk alat internal kustom yang belum pernah dilihat, tingkat keberhasilan lebih rendah. Agensi Adaptif bertujuan menutup celah: model bernalar tentang struktur perangkat lunak pada kontak pertama, membangun pemahaman kerja, dan menjalankan tugas tanpa data pelatihan sebelumnya.

Jika berhasil, ini akan menghapus batas utama AI penggunaan komputer di perusahaan.

Kesimpulan

Holo3 menetapkan standar baru untuk AI penggunaan komputer desktop. Dengan 78,85% pada OSWorld-Verified, ini mengungguli model berbasis Claude dan GPT dalam workflow multi-langkah kompleks. Tier gratis Holo3-35B-A3B dan bobot Apache 2.0 memungkinkan developer mencoba tanpa biaya awal.

Integrasi sederhana: screenshot, POST ke API, eksekusi aksi, ulangi. Di sinilah Apidog membantu: validasi respons, mocking saat development, dan menjalankan skenario pengujian sebelum go live.

Jika Anda membangun workflow yang menyentuh GUI desktop, coba Apidog gratis dan pastikan integrasi Holo3 Anda stabil sebelum produksi.

FAQ

Apa itu Holo3?

Holo3 adalah model AI penggunaan komputer dari H Company yang menerima screenshot dan mengembalikan aksi (klik, ketik, scroll) untuk menyelesaikan tugas di desktop/browser. Skor 78,85% di OSWorld-Verified, rekor tertinggi saat ini.

Apakah Holo3 open source?

Holo3-35B-A3B bersifat open-weight (Apache 2.0) dan bisa diunduh dari HuggingFace. Holo3-122B hanya tersedia via API. Keduanya ada di API inferensi H Company, dengan tier gratis untuk model 35B.

Bagaimana benchmark OSWorld bekerja?

OSWorld menguji AI pada tugas komputer nyata: web navigation, file management, workflow lintas aplikasi. Verifikasi dengan memeriksa status sistem setelah aksi, bukan evaluasi teks output.

Bagaimana Holo3 dibandingkan Claude Computer Use?

Holo3-122B mencetak skor lebih tinggi pada OSWorld-Verified (78,85% vs ~65% untuk Claude) dan lebih murah per tugas. Claude tetap opsi kuat bagi tim dengan ekosistem Anthropic dan billing tunggal.

Bisakah saya menjalankan Holo3 lokal?

Ya, jika memakai Holo3-35B-A3B. Bobot tersedia di HuggingFace (Apache 2.0). Model 122B hanya via API.

Apa saja kasus penggunaan utama API penggunaan komputer?

Otomatisasi sistem lama tanpa API, workflow data lintas aplikasi, regression testing web tanpa selector rapuh, scraping intelijen kompetitif, dan workflow desktop yang selama ini mengandalkan manusia.

Bagaimana menguji integrasi API Holo3?

Gunakan Apidog untuk impor endpoint, set assertion validasi respons, mock API, dan merangkai permintaan jadi skenario pengujian. Ini mendeteksi masalah integrasi sebelum otomatisasi dijalankan di mesin nyata.

Apa itu "Agensi Adaptif" di roadmap Holo3?

H Company mengembangkan model yang bisa menavigasi perangkat lunak perusahaan yang belum pernah dilihat, belajar struktur UI secara real-time tanpa data pelatihan sebelumnya. Ini akan menghapus batas utama AI penggunaan komputer untuk deployment enterprise.

Serangan Rantai Pasokan axios@1.14.1: Cara Mengatasi Sekarang

Walse — Thu, 02 Apr 2026 08:49:40 +0000

Intinya

Pada tanggal 30–31 Maret 2026, axios versi 1.14.1 dan 0.30.4 disusupi di npm dengan dependensi berbahaya yang menjatuhkan trojan akses jarak jauh (RAT) pada mesin yang terinfeksi. Kedua versi tersebut telah dihapus publikasinya. Versi yang aman adalah 1.14.0. Jika Anda menginstal axios@1.14.1 atau 0.30.4, anggap mesin tersebut telah disusupi dan segera ubah semua kredensial.

Coba Apidog hari ini

Apa itu axios dan Mengapa Ini Penting

axios memiliki 100 juta unduhan mingguan di npm. Ini adalah klien HTTP di banyak framework frontend, layanan Node.js backend, dan aplikasi perusahaan. Ketika paket yang begitu fundamental ini disusupi, dampaknya sangat besar — pengembang yang menjalankan npm install dalam jendela waktu 30–31 Maret tanpa sadar menarik malware ke mesin mereka.

Ini adalah risiko rantai pasokan nyata dan telah dikonfirmasi: trojan akses jarak jauh multi-tahap yang bisa mengeksekusi perintah arbitrer, mengekstrak data sistem, dan bertahan di mesin terinfeksi.

Jika tim Anda menggunakan axios, dan Anda memakai Apidog untuk mendesain dan menguji integrasi klien HTTP, baca ini sebelum deployment berikutnya.

Kronologi Serangan

30 Maret 2026 — 23:59:12 UTC: Paket berbahaya plain-crypto-js@4.2.1 diterbitkan ke npm oleh akun nrwise@proton.me. Versi 4.2.0 sebelumnya adalah typosquat dari pustaka crypto-js yang sah.

31 Maret 2026 — 00:05:41 UTC: Deteksi otomatis Socket menandai plain-crypto-js@4.2.1 sebagai berbahaya — enam menit setelah publikasi.

31 Maret 2026 — tak lama setelah tengah malam: axios@1.14.1 diterbitkan ke npm, menarik plain-crypto-js@4.2.1 sebagai dependensi. Rilis ini tidak muncul di tag resmi GitHub; tag sah terbaru tetap v1.14.0.

31 Maret 2026 — pagi: Isu GitHub #10604 dibuka, melaporkan axios@1.14.1 dan axios@0.30.4 telah disusupi. Pemelihara Axios tidak dapat langsung mencabut akses penyerang karena akun yang disusupi punya izin npm lebih tinggi.

31 Maret 2026: Baik axios@1.14.1 maupun axios@0.30.4 dihapus dari npm. Pemelihara mencabut token, memperketat kontrol publikasi, dan menyelidiki eksploitasi token npm berumur panjang.

Bagaimana Serangan Bekerja

Serangan ini memanfaatkan token npm berumur panjang pada alur publikasi axios. Penyerang, kemungkinan setelah mendapatkan kredensial pemelihara, menggunakan token tersebut untuk menerbitkan versi baru di luar proses rilis normal.

Versi baru menambahkan dependensi plain-crypto-js@4.2.1 (dengan versi 4.2.0 yang bersih untuk menurunkan kecurigaan).

Payload dalam plain-crypto-js@4.2.1:

Tahap 1 — Eksekusi: Skrip instalasi npm menjalankan kode untuk menjatuhkan payload sekunder.
Tahap 2 — Deployment RAT: Payload menginstal trojan akses jarak jauh yang membuka backdoor persisten.
Tahap 3 — Eksfiltrasi: RAT dapat mengeksekusi perintah shell, membaca env/secret, dan mengirim data ke server C2.

RAT tetap ada setelah reboot, sehingga mesin tetap berisiko walau paket npm sudah dihapus — RAT harus dicari dan dihapus manual.

Apakah Saya Terkena Dampak?

Anda berpotensi terdampak jika:

Menjalankan npm install axios atau npm install (axios di package.json) antara 30 Maret, 23:59 UTC dan 31 Maret 2026 tengah hari UTC.
node_modules/axios/package.json menunjukkan versi 1.14.1 atau 0.30.4.
package-lock.json atau yarn.lock mengunci axios ke 1.14.1 atau 0.30.4.

Cek dengan cepat:

# Periksa versi yang terinstal
npm list axios

# Periksa file kunci
grep '"axios"' package-lock.json | head -5

# Periksa keberadaan plain-crypto-js
npm list plain-crypto-js
ls node_modules/plain-crypto-js 2>/dev/null && echo "INFECTED" || echo "Tidak ditemukan"

Jika plain-crypto-js ada di node_modules, Anda menjalankan versi berbahaya.

Apa yang Harus Dilakukan Sekarang

1. Perbarui axios segera

npm install axios@1.14.0
# atau kunci ke versi aman terbaru
npm install axios@latest

Verifikasi:

npm list axios
# Pastikan versi 1.14.0 atau lebih tinggi (setelah versi bersih dirilis)

2. Jika Anda menginstal versi yang disusupi

Anggap mesin telah disusupi, lakukan langkah berikut:

Ubah semua rahasia (API key, kredensial DB, SSH key, token cloud, variabel .env).
Periksa variabel lingkungan — RAT menargetkan env proses dan sistem file.
Audit koneksi jaringan keluar pada periode terdampak — cek koneksi ke IP mencurigakan.
Pindai persistensi — cek cron, skrip startup, systemd service yang muncul di waktu kompromi.
Buat ulang citra mesin jika itu CI runner / server produksi. Untuk laptop developer, anggap semua kredensial telah bocor dan ganti sebelum digunakan lagi.

3. Audit alur CI/CD Anda

Jika pipeline build menjalankan npm install pada jendela waktu tersebut, CI Anda mungkin terinfeksi. Lakukan:

# Cek log build pada periode terdampak
# Cari axios@1.14.1 di output instalasi

# Pastikan node_modules CI saat ini bersih
npm list axios plain-crypto-js

Ganti semua rahasia yang diakses pipeline CI: kunci deployment, token cloud, token registry.

4. Verifikasi file kunci Anda

File kunci (package-lock.json, yarn.lock) harus mengunci versi tepat. Jika ada 1.14.1, buat ulang:

rm package-lock.json
npm install

Pastikan file kunci baru mengunci axios ke versi aman sebelum commit.

Menggunakan Apidog untuk Mengaudit Panggilan API axios Anda

Jika Anda memakai axios sebagai klien HTTP untuk memanggil API, Apidog dapat membantu memverifikasi integrasi Anda tetap benar setelah update dependensi.

Setelah update ke axios@1.14.0, impor endpoint API ke Apidog dan jalankan regresi untuk konfirmasi perilaku tidak berubah. Ini penting jika Anda khawatir versi berbahaya pernah mengubah muatan request/response. Gunakan penegasan respons Apidog untuk validasi field, header, dan status code:

// Penegasan pasca-respons Apidog
pm.test("Respons bersih — tidak ada bidang yang disuntikkan", () => {
    const body = pm.response.json();
    pm.expect(body).to.not.have.property('__injected');
    pm.expect(pm.response.headers.get('X-Injected-Header')).to.be.null;
});

Jalankan seluruh pengujian pada axios versi baru di Apidog untuk dokumentasi baseline sebelum push ke produksi.

Coba Apidog gratis untuk setup regresi testing klien HTTP Anda.

Mengapa Serangan Rantai Pasokan di npm Sulit Dihentikan

Serangan axios bukan anomali, ini pola yang berulang:

event-stream (2018): Pemelihara menambahkan payload yang menargetkan dompet bitcoin. 8 juta unduhan/minggu.
ua-parser-js (2021): Disusupi untuk menjatuhkan crypto miner & pencuri password.
node-ipc (2022): Pemelihara menambahkan kode destruktif untuk IP Rusia/Belarusia.
xz utils (2024): Rekayasa sosial selama dua tahun untuk menyuntik backdoor ke pustaka Linux inti.
axios (2026): Kredensial pemelihara disusupi, RAT diterbitkan melalui dependensi berbahaya.

Inti masalah: kepercayaan pada akun publikasi, bukan pada kode itu sendiri. Model npm mengandalkan trust pada pemelihara; jika kredensial mereka bocor, penyerang mewarisi kepercayaan itu.

Mitigasi yang sangat membantu:

Tindakan	Apa yang Dilakukan
File kunci (`package-lock.json`)	Mengunci versi tepat, cegah upgrade diam-diam
`npm audit` di CI	Tandai kerentanan sebelum deployment
Socket.dev / Snyk	Analisis perilaku — tandai paket mencurigakan sebelum ada CVE
2FA di npm	Sulitkan kompromi kredensial
`npm publish` dengan token berumur pendek	Batasi jendela paparan jika token bocor
Review file kunci di PR	Tangkap perubahan dependensi tidak terduga di code review

Tim axios kini beralih ke kontrol publikasi lebih ketat dan token pendek. Tapi perbaikan harus datang dari ekosistem, bukan hanya paket individu.

Indikator Kompromi (IOC)

Menurut analisis Socket:

Paket berbahaya: plain-crypto-js@4.2.1, axios@1.14.1, axios@0.30.4
Email penerbit: nrwise@proton.me
Perilaku: Koneksi jaringan saat instalasi npm, persistensi RAT, eksfiltrasi env
Versi axios aman: 1.14.0 ke bawah (kecuali 0.30.4), 1.13.x, 1.12.x

Jika Anda curiga terinfeksi, laporkan ke security@npmjs.com dan simpan log.

Kesimpulan

Kompromi axios 1.14.1 adalah pengingat bahwa keamanan dependensi adalah proses berkelanjutan. Kunci versi, jalankan alat analisis perilaku seperti Socket di CI, ubah kredensial saat ada anomali, dan pantau file kunci di code review.

Jika Anda perlu rebuild kepercayaan pada integrasi API setelah update axios, Apidog menyediakan skenario testing, penegasan, dan mocking untuk memverifikasi klien HTTP Anda sebelum release.

FAQ

Versi axios mana yang disusupi?

axios@1.14.1 dan axios@0.30.4. Keduanya sudah dihapus dari npm. Versi aman: 1.14.0 (atau 1.13.x, 1.12.x).

Apa yang dilakukan muatan axios berbahaya?

Menarik plain-crypto-js@4.2.1 yang men-deploy RAT multi-tahap. RAT dapat mengeksekusi perintah jarak jauh, eksfiltrasi env dan secret, serta bertahan setelah reboot.

Bagaimana tahu kalau saya menginstal versi berbahaya?

Jalankan npm list axios — jika 1.14.1 atau 0.30.4, Anda terdampak. Cek juga npm list plain-crypto-js — jika ada, kode berbahaya sudah berjalan.

Apakah cukup hanya update axios?

Tidak cukup. Update hanya menghapus dependensi ke depan, tapi RAT bisa sudah terinstal dan bertahan. Jika pernah install versi berbahaya, ganti semua rahasia dan audit mesin untuk persistensi.

Bagaimana penyerang bisa publish ke npm tanpa jadi pemelihara?

Penyerang kemungkinan mendapatkan kredensial pemelihara dan mengeksploitasi token npm berumur panjang. Tim axios kini perketat kontrol publikasi.

Apa beda ini dengan kerentanan biasa?

Kerentanan = bug pada kode sah. Supply chain attack = kode berbahaya masuk lewat publikasi tepercaya. Kode jahat tidak pernah ada di repo GitHub axios — disuntikkan langsung ke npm.

Bagaimana melindungi proyek dari supply chain attack kedepan?

Gunakan file kunci, jalankan npm audit di CI, gunakan Socket.dev untuk analisis perilaku, aktifkan 2FA npm, token publish pendek, dan audit perbedaan file kunci di code review.