OpenRouter: Satu API untuk Ratusan LLM (OpenAI, Anthropic, Google, Meta, Mistral)

Halo temen-temen, ketemu lagi sama aku, Ruby Abdullah. Kali ini aku mau bahas satu tool yang menurut aku wajib banget kalian kenalin kalau kalian lagi serius bangun aplikasi berbasis LLM. Namanya OpenRouter. Buat aku pribadi, OpenRouter itu semacam "colokan universal" buat semua model bahasa besar yang ada di dunia sekarang. Bayangin aja, biasanya kalau mau pakai GPT dari OpenAI kalian harus daftar ke OpenAI, dapetin API key sendiri, pakai SDK-nya sendiri. Terus kalau mau coba Claude dari Anthropic, kalian harus daftar lagi ke Anthropic, API key lagi, SDK lagi. Mau coba Gemini dari Google? Sama, daftar lagi. Belum lagi kalau mau coba model open source kayak Llama dari Meta atau Mistral. Ribet banget kan?

Nah, OpenRouter datang buat nyelesain masalah itu. Dengan satu API key dan satu endpoint yang formatnya kompatibel sama OpenAI, kalian bisa akses ratusan model dari berbagai provider. Jadi kode kalian nggak berubah, cuma ganti nama model doang, kalian udah bisa lompat dari GPT ke Claude ke Gemini ke Llama semudah ganti string. Ini game changer banget buat aku, apalagi kalau kalian lagi eksperimen cari model mana yang paling cocok buat use case tertentu, atau kalian mau bikin sistem yang punya fallback otomatis kalau satu model lagi down.

Di tutorial ini aku bakal ajak kalian dari nol. Mulai dari cara dapetin API key, cara pakai lewat OpenAI SDK, cara pilih model pakai slug, streaming, routing dan fallback antar model, atur preferensi provider, tracking biaya sama rate limit, sampai cara bandingin harga model. Semua contoh aku kasih pakai Python biar gampang diikutin. Yuk kita mulai.

Introduction

Sebelum masuk ke teknis, aku pengen kalian paham dulu kenapa OpenRouter ini penting dan apa sebenarnya yang dia lakuin di belakang layar. Jadi gini, OpenRouter itu posisinya sebagai gateway atau perantara. Ketika kalian kirim request ke OpenRouter, dia bakal nerusin request itu ke provider model yang kalian pilih, nunggu jawabannya, terus balikin lagi ke kalian. Semua ini terjadi dengan format yang seragam, yaitu format OpenAI Chat Completions yang udah jadi semacam standar de facto di industri.

Kenapa format OpenAI penting? Karena hampir semua library, framework, dan tool di ekosistem LLM sekarang udah support format itu. Jadi kalau kalian udah punya kode yang jalan pakai OpenAI SDK, kalian cukup ganti baseurl sama apikey, dan kode kalian langsung bisa akses ratusan model lewat OpenRouter tanpa perlu nulis ulang apa-apa. Ini yang bikin migrasi jadi gampang banget.

Ada beberapa keuntungan konkret yang aku rasain waktu pakai OpenRouter. Pertama, satu tagihan buat semua. Kalian nggak perlu ngurusin billing di banyak tempat, cukup top up saldo di OpenRouter, terus dari situ kalian bisa pakai model apa aja. Kedua, kalian bisa bandingin harga dan performa model dengan mudah karena semuanya ada di satu tempat. Ketiga, ada fitur routing dan fallback yang bikin aplikasi kalian lebih tahan banting. Kalau satu provider lagi error atau rate limit, OpenRouter bisa otomatis pindah ke provider lain. Keempat, kalian dapet akses ke model-model yang mungkin susah didaftar langsung, termasuk model open source yang di-host sama berbagai penyedia infrastruktur.

Buat aku, use case paling kena itu waktu bikin prototype. Aku sering banget mau nyobain, misalnya, apakah tugas summarization ini lebih bagus dikerjain sama Claude atau GPT atau model yang lebih murah kayak Llama. Tanpa OpenRouter, aku harus setup tiga akun, tiga API key, dan mungkin nulis tiga versi kode. Dengan OpenRouter, aku cukup ganti satu string nama model dan langsung bisa bandingin hasilnya. Hemat waktu, hemat tenaga, hemat pikiran.

Satu hal yang perlu kalian tau, OpenRouter itu bukan gratis dalam artian kalian tetap bayar per token sesuai harga model yang kalian pakai. OpenRouter ambil sedikit margin atau kadang mereka pass-through harga aslinya. Tapi ada juga beberapa model yang punya tier gratis dengan rate limit tertentu, cocok banget buat eksperimen awal. Jadi kalian bisa mulai tanpa keluar duit dulu buat belajar.

Instalasi

Oke sekarang kita masuk ke bagian praktik. Yang pertama harus kalian lakuin adalah bikin akun di OpenRouter. Caranya gampang banget. Buka situs https://openrouter.ai, terus sign up. Kalian bisa daftar pakai akun Google, GitHub, atau email biasa. Setelah masuk, cari menu Keys atau langsung ke https://openrouter.ai/keys. Di situ kalian klik tombol buat bikin API key baru. Kasih nama yang jelas, misalnya "eksperimen-lokal" atau "produksi-app-A", biar gampang ngatur kalau nanti kalian punya banyak key. Setelah dibuat, salin key-nya dan simpan baik-baik. Formatnya biasanya diawali sk-or-v1- diikuti string panjang. Ingat ya, key ini cuma ditampilin sekali, jadi kalau kalian ilang harus bikin ulang.

Sebelum bisa pakai model berbayar, kalian perlu top up saldo dulu. Masuk ke halaman Credits atau Billing, terus isi saldo pakai kartu kredit atau metode pembayaran lain yang tersedia. Nggak perlu banyak, buat belajar cukup beberapa dolar aja udah bisa jalan lama karena harga per token itu murah banget. Kalau kalian cuma mau coba model gratis, kalian bisa langsung lewatin langkah top up ini dulu, tapi rate limit-nya lebih ketat.

Nah, karena OpenRouter itu kompatibel sama OpenAI, kita cukup install library OpenAI resmi. Buka terminal kalian dan jalanin perintah ini.

pip install openai

Kalau kalian mau pakai streaming atau fitur lain, library ini udah cukup. Tapi kadang aku juga install requests buat kasus di mana aku mau akses endpoint OpenRouter yang di luar format chat completions, misalnya buat ngecek daftar model atau cek saldo. Jadi sekalian aja.

pip install openai requests

Setelah itu, praktik terbaik yang selalu aku lakuin adalah nyimpen API key di environment variable, bukan di-hardcode langsung di kode. Ini penting banget biar key kalian nggak keceplosan ke-commit ke Git terus kelihatan orang. Kalian bisa bikin file .env atau langsung export di terminal.

export OPENROUTERAPIKEY="sk-or-v1-xxxxxxxxxxxxxxxxxxxx"

Kalau kalian mau pakai file .env, install juga python-dotenv.

pip install python-dotenv

Terus di kode kalian tinggal load kayak gini.

import os
from dotenv import loaddotenv


loaddotenv()

apikey = os.environ["OPENROUTERAPIKEY"]

print("API key kebaca:", apikey[:12], "...")

Kalau outputnya nunjukin potongan awal key kalian, berarti setup-nya udah beres dan kita siap lanjut ke bagian yang seru.

Basic Usage

Sekarang bagian yang paling ditunggu, gimana cara manggil model lewat OpenRouter. Karena kompatibel OpenAI, kita pakai class OpenAI dari library-nya, tapi kita arahin baseurl-nya ke endpoint OpenRouter, yaitu https://openrouter.ai/api/v1. Ini kunci utamanya. Coba lihat kode paling dasar ini.

import os
from openai import OpenAI

client = OpenAI(
    baseurl="https://openrouter.ai/api/v1",
    apikey=os.environ["OPENROUTERAPIKEY"],

)

response = client.chat.completions.create(
    model="openai/gpt-4o-mini",
    messages=[
        {"role": "system", "content": "Kamu asisten yang ramah dan menjawab dalam Bahasa Indonesia."},
        {"role": "user", "content": "Jelaskan apa itu OpenRouter dalam satu kalimat."},
    ],
)

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

import requests

resp = requests.get("https://openrouter.ai/api/v1/models")
data = resp.json()

for m in data["data"][:10]:
    print(m["id"], "->", m.get("name"))

response = client.chat.completions.create(
    model="anthropic/claude-3.5-sonnet",
    messages=[
        {"role": "user", "content": "Tuliskan pantun tentang belajar coding."},
    ],
)

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

Lihat kan? Aku nggak ganti client, nggak ganti apikey, nggak ganti apa-apa selain nama model. Inilah kekuatan sebenarnya dari OpenRouter. Buat aku ini benar-benar mengubah cara aku eksperimen karena aku jadi bisa fokus ke logika aplikasi, bukan ke urusan integrasi tiap provider.

Ada satu hal tambahan yang aku saranin kalian tambahin waktu pakai OpenRouter, yaitu header opsional buat identifikasi aplikasi kalian. Header ini nggak wajib, tapi berguna kalau kalian mau aplikasi kalian muncul di leaderboard OpenRouter atau sekadar buat tracking. Kalian bisa tambahin lewat parameter extraheaders.

response = client.chat.completions.create(
    model="openai/gpt-4o-mini",
    messages=[{"role": "user", "content": "Halo, apa kabar?"}],
    extraheaders={
        "HTTP-Referer": "https://aplikasiku.com",
        "X-Title": "Aplikasi Belajar Ruby",
    },
)

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

Sekarang kita udah bisa manggil model dasar. Selanjutnya kita bahas fitur-fitur yang lebih canggih yang bikin OpenRouter jadi lebih dari sekadar proxy biasa.

Advanced Usage

Di bagian ini aku bakal bahas fitur-fitur yang menurut aku bikin OpenRouter benar-benar layak dipakai di produksi. Mulai dari streaming, routing dan fallback, preferensi provider, sampai tracking biaya dan rate limit. Kita bahas satu-satu ya.

Streaming Response

Kalau kalian bikin aplikasi chat, kalian pasti mau jawabannya muncul kata demi kata kayak ChatGPT, bukan nunggu diem terus tiba-tiba muncul semua. Nah, itu namanya streaming. Di OpenRouter, streaming ini gampang banget karena lagi-lagi kompatibel OpenAI. Kalian cukup tambahin parameter stream=True.

stream = client.chat.completions.create(
    model="openai/gpt-4o-mini",
    messages=[
        {"role": "user", "content": "Ceritakan sejarah singkat bahasa Python dalam 3 paragraf."},
    ],
    stream=True,
)

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

print()

Dengan streaming, tiap potongan teks langsung dicetak begitu diterima. Ini bikin pengalaman pengguna jauh lebih enak karena mereka nggak perlu nunggu lama. Buat aplikasi yang responsif, streaming ini hampir wajib menurut aku.

Model Routing dan Fallback

Ini fitur favorit aku di OpenRouter. Bayangin skenario ini, kalian pakai satu model utama, tapi kadang model itu lagi down, lagi kena rate limit, atau lagi lambat. Daripada request kalian gagal total, OpenRouter bisa otomatis coba model lain sebagai cadangan. Caranya pakai parameter models (jamak) yang isinya daftar model urut prioritas. Karena ini parameter khusus OpenRouter yang di luar spec OpenAI standar, kita kirim lewat extrabody.

response = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[
        {"role": "user", "content": "Ringkas ide utama dari konsep microservices."},
    ],
    extrabody={
        "models": [
            "openai/gpt-4o",
            "anthropic/claude-3.5-sonnet",
            "google/gemini-2.0-flash-001",
        ],
    },
)

print("Model yang dipakai:", response.model)
print(response.choices[0].message.content)

Di sini OpenRouter bakal coba gpt-4o dulu. Kalau gagal, dia pindah ke claude-3.5-sonnet, terus kalau masih gagal, ke gemini-2.0-flash-001. Perhatiin aku cetak response.model biar tau model mana yang akhirnya kepakai. Ini berguna banget buat debugging dan buat mastiin fallback-nya jalan. Buat aplikasi produksi yang butuh uptime tinggi, fitur ini benar-benar penyelamat.

Selain fallback manual, OpenRouter juga punya model spesial bernama openrouter/auto. Kalau kalian pakai model ini, OpenRouter bakal otomatis milihin model yang paling cocok buat prompt kalian berdasarkan heuristik mereka. Cocok kalau kalian males mikir dan pengen dia yang atur.

response = client.chat.completions.create(
    model="openrouter/auto",
    messages=[
        {"role": "user", "content": "Tulis fungsi Python untuk cek bilangan prima."},
    ],
)

print("Auto memilih:", response.model)
print(response.choices[0].message.content)

Preferensi Provider

Satu model tertentu, misalnya meta-llama/llama-3.3-70b-instruct, itu bisa di-host sama beberapa penyedia infrastruktur yang beda. Tiap penyedia bisa punya harga, kecepatan, dan kebijakan privasi yang beda. Nah, OpenRouter kasih kalian kontrol buat milih provider mana yang mau dipakai lewat parameter provider di extrabody. Misalnya kalian mau prioritaskan yang paling murah, atau yang paling cepat, atau kalian mau exclude provider tertentu.

response = client.chat.completions.create(
    model="meta-llama/llama-3.3-70b-instruct",
    messages=[
        {"role": "user", "content": "Jelaskan apa itu overfitting dalam machine learning."},
    ],
    extrabody={
        "provider": {
            "sort": "price",
            "order": ["DeepInfra", "Together"],
            "allowfallbacks": True,

        },
    },
)

print("Provider dipilih via model:", response.model)
print(response.choices[0].message.content)

Di contoh ini, sort diatur ke price artinya OpenRouter bakal urutin provider dari yang paling murah. order ngasih preferensi urutan provider tertentu, dan allowfallbacks bikin OpenRouter boleh pindah ke provider lain kalau yang di daftar nggak tersedia. Kalian juga bisa pakai sort: "throughput" kalau prioritas kalian kecepatan, atau sort: "latency" kalau kalian pengen respons paling cepat mulai keluar. Ada juga opsi datacollection buat ngatur apakah kalian mau provider yang nyimpan data atau nggak, penting kalau kalian peduli sama privasi.

response = client.chat.completions.create(
    model="openai/gpt-4o-mini",
    messages=[{"role": "user", "content": "Apa ibukota Indonesia?"}],
)

usage = response.usage
print("Prompt tokens:", usage.prompttokens)
print("Completion tokens:", usage.completiontokens)

print("Total tokens:", usage.totaltokens)

Tapi kalau kalian mau tau biaya aktual dalam dolar untuk satu request, kalian bisa minta OpenRouter ngasih detail usage yang lebih lengkap lewat parameter usage di extrabody. Ini bakal ngasih kalian angka biaya yang sebenarnya.

response = client.chat.completions.create(
    model="openai/gpt-4o-mini",
    messages=[{"role": "user", "content": "Sebutkan 3 planet terdekat dari matahari."}],
    extrabody={"usage": {"include": True}},
)

print("Isi jawaban:", response.choices[0].message.content)
Detail biaya ada di response.usage, termasuk field cost bila tersedia
print("Usage lengkap:", response.usage)

Selain itu, kalian juga bisa cek sisa saldo dan total penggunaan akun kalian lewat endpoint khusus. Ini berguna buat monitoring, misalnya kalian mau kasih alert kalau saldo mau habis.

import requests
import os

headers = {"Authorization": f"Bearer {os.environ['OPENROUTERAPIKEY']}"}
resp = requests.get("https://openrouter.ai/api/v1/credits", headers=headers)
data = resp.json()

print("Data saldo:", data)

Endpoint /credits ini balikin total kredit yang udah kalian beli dan total yang udah kepakai, jadi kalian bisa hitung sisa saldo dengan gampang. Aku biasa pakai ini buat bikin dashboard sederhana yang mantau pengeluaran harian.

Membandingkan Harga Model

Nah ini yang menarik. Karena endpoint models tadi bawa info harga, kita bisa bikin script buat bandingin harga antar model secara otomatis. Harga di OpenRouter biasanya dalam satuan dolar per token, jadi angkanya kecil banget. Biar gampang dibaca, aku suka konversi ke dolar per satu juta token.

import requests

resp = requests.get("https://openrouter.ai/api/v1/models")
models = resp.json()["data"]

target = ["openai/gpt-4o", "anthropic/claude-3.5-sonnet",
          "google/gemini-2.0-flash-001", "meta-llama/llama-3.3-70b-instruct"]

print(f"{'Model':<45} {'Input/1M':>10} {'Output/1M':>10}")
for m in models:
    if m["id"] in target:
        p = m["pricing"]
        inp = float(p["prompt"])  1000000

        out = float(p["completion"])  1000000
        print(f"{m['id']:<45} ${inp:>9.3f} ${out:>9.3f}")

Script ini bakal narik data harga untuk model yang kalian pilih dan nampilin biaya per satu juta token input dan output. Dari sini kalian bisa langsung lihat, misalnya, betapa lebih murahnya model kayak Gemini Flash atau Llama dibanding GPT-4o buat use case volume tinggi. Aku sering pakai perbandingan kayak gini buat mutusin model mana yang worth it buat fitur tertentu. Kalau tugasnya sederhana kayak klasifikasi atau ekstraksi data, aku pilih yang murah. Kalau butuh reasoning berat, baru aku keluarin model premium.

Menggabungkan Semua Fitur

Buat nutup bagian advanced, aku mau kasih contoh yang gabungin beberapa fitur sekaligus, yaitu fallback, preferensi provider, dan tracking usage dalam satu fungsi yang siap pakai. Ini mirip pola yang aku pakai di proyek nyata.

import os
from openai import OpenAI

client = OpenAI(
    baseurl="https://openrouter.ai/api/v1",

    apikey=os.environ["OPENROUTERAPIKEY"],
)

def tanyallm(prompt, modelutama="openai/gpt-4o-mini"):
    response = client.chat.completions.create(
        model=modelutama,

        messages=[{"role": "user", "content": prompt}],
        extrabody={
            "models": [modelutama, "anthropic/claude-3.5-sonnet", "google/gemini-2.0-flash-001"],

            "provider": {"sort": "throughput", "allowfallbacks": True},
            "usage": {"include": True},
        },
        extraheaders={"X-Title": "Ruby LLM Helper"},

    )
    return {
        "jawaban": response.choices[0].message.content,
        "modeldipakai": response.model,
        "totaltoken": response.usage.totaltokens,
    }

hasil = tanyallm("Jelaskan perbedaan list dan tuple di Python.")

print("Model:", hasil["modeldipakai"])
print("Token:", hasil["totaltoken"])

print(hasil["jawaban"])

Fungsi tanyallm ini udah bawa fallback ke tiga model, prioritas provider berdasarkan throughput, dan tracking token, semua dalam satu paket rapi. Kalian tinggal panggil dengan prompt apa aja dan kalian dapet jawaban plus metadata yang berguna. Pola kayak gini yang bikin kode kalian jadi lebih tangguh dan gampang dimonitor.

Best Practices

Setelah cukup lama pakai OpenRouter, ada beberapa praktik yang aku pengen banget bagiin ke kalian biar kalian nggak ngulangin kesalahan yang pernah aku buat. Yang pertama dan paling penting, jangan pernah hardcode API key di kode kalian. Selalu pakai environment variable atau secret manager. Aku udah singgung ini di bagian instalasi, tapi ini benar-benar krusial. Aku pernah lihat orang nggak sengaja commit API key ke repo publik dan saldonya kesedot habis dalam hitungan jam. Jadi tolong ya, hati-hati banget sama key kalian.

Kedua, selalu pakai model slug yang eksplisit di produksi, jangan andalin openrouter/auto untuk hal yang kritikal. auto itu enak buat eksperimen, tapi karena dia bisa milih model yang beda-beda, hasilnya jadi kurang bisa diprediksi. Buat produksi, aku lebih suka nentuin model utama yang jelas terus kasih fallback yang juga jelas, biar aku tau persis behavior dan biayanya.

Ketiga, manfaatin fitur fallback buat aplikasi yang butuh keandalan tinggi. Kombinasi model utama plus dua atau tiga cadangan itu bikin aplikasi kalian jauh lebih tahan kalau ada provider yang lagi bermasalah. Tapi hati-hati juga, pilih model cadangan yang kualitasnya nggak jauh beda dari model utama, biar pengalaman pengguna tetap konsisten. Jangan sampai model utama kalian GPT-4o tapi fallback-nya model kecil yang jawabannya jauh lebih jelek.

Keempat, selalu monitor biaya. OpenRouter kasih kalian data usage per request dan endpoint credits buat cek saldo. Manfaatin itu buat bikin monitoring. Aku saranin kalian log setiap request beserta token yang kepakai dan model yang dipilih. Dengan data ini kalian bisa analisa fitur mana yang paling boros token dan optimasi dari situ. Kadang cuma dengan mempersingkat system prompt atau ganti model ke yang lebih murah buat tugas ringan, kalian bisa hemat biaya signifikan.

Kelima, atur rate limit dan error handling dengan baik. Meskipun OpenRouter udah punya fallback, tetap ada kemungkinan semua model gagal atau kalian kena rate limit di sisi OpenRouter sendiri. Jadi bungkus panggilan kalian dengan try-except dan tambahin retry dengan backoff kalau perlu. Ini contoh sederhananya.

import time
from openai import OpenAI, APIError

def tanyadenganretry(client, prompt, model, maxretry=3):

    for percobaan in range(maxretry):
        try:
            resp = client.chat.completions.create(
                model=model,
                messages=[{"role": "user", "content": prompt}],
            )
            return resp.choices[0].message.content
        except APIError as e:
            wait = 2 ** percobaan
            print(f"Error: {e}. Coba lagi dalam {wait} detik...")
            time.sleep(wait)
    return "Gagal setelah beberapa percobaan."

Pola retry dengan exponential backoff kayak gini bikin aplikasi kalian nggak langsung nyerah begitu ada gangguan sesaat. Waktu tunggu-nya naik dua kali lipat tiap percobaan, jadi kalian nggak spam server saat lagi bermasalah.

Keenam, pertimbangin panjang konteks tiap model. Beda model punya batas konteks beda. Ada yang cuma delapan ribu token, ada yang sampai jutaan token. Kalau kalian kirim prompt yang kepanjangan ke model yang konteksnya kecil, request kalian bakal gagal. Info panjang konteks ini ada di endpoint models tadi, jadi kalian bisa cek dulu sebelum kirim. Buat dokumen panjang, pilih model yang memang punya konteks besar.

Ketujuh, perhatiin kebijakan privasi data lewat setting provider. Kalau kalian ngolah data sensitif, pakai opsi datacollection buat mastiin data kalian nggak disimpan sama provider. Ini penting banget kalau kalian di industri yang ketat soal kepatuhan kayak kesehatan atau keuangan. OpenRouter kasih kalian kontrol ini, jadi manfaatin.

Oke temen-temen, kita udah sampai di ujung tutorial ini. Kita udah bahas lumayan lengkap tentang OpenRouter mulai dari konsep dasarnya sebagai gateway universal buat ratusan LLM, cara dapetin API key, cara pakai lewat OpenAI SDK dengan cukup ganti baseurl, cara pilih model pakai slug format provider/nama-model, streaming, routing dan fallback antar model, preferensi provider, tracking biaya dan rate limit, sampai cara bandingin harga model secara otomatis. Semua itu bisa kalian lakuin dengan satu API key dan satu format yang seragam, dan menurut aku itu benar-benar menyederhanakan hidup developer yang kerja dengan LLM.

Buat aku pribadi, OpenRouter itu udah jadi tool standar tiap kali aku mulai proyek baru yang melibatkan LLM. Kemudahan buat lompat antar model tanpa ngubah kode itu bikin fase eksperimen jadi jauh lebih cepat, dan fitur fallback bikin aku tenang waktu udah masuk produksi. Kalau kalian sering gonta-ganti provider atau kalian mau bikin aplikasi yang tahan banting, aku sangat rekomendasiin kalian coba OpenRouter.

Saranku, langsung praktik aja. Ambil satu contoh kode dari tutorial ini, jalanin di mesin kalian, terus mulai eksplorasi. Coba ganti-ganti model, coba fitur fallback, coba bandingin harga. Dari situ kalian bakal cepat paham dan nemu pola yang paling cocok buat kebutuhan kalian. Jangan takut eksperimen karena biayanya murah dan kalian bisa mulai dari model gratis dulu kalau mau.

Segitu dulu dari aku. Semoga tutorial ini bermanfaat dan bikin kalian makin pede bangun aplikasi berbasis LLM. Kalau ada pertanyaan atau kalian nemu trik keren pas pakai OpenRouter, jangan sungkan buat sharing. Selamat ngoding, dan sampai ketemu di tutorial berikutnya. Salam dari aku, Ruby Abdullah.