Build Your Own Aplicare Dashboard: Monitor BPJS Bed Availability Without Opening the Official Website

Buat Dashboard Aplicare Sendiri — Pantau Ketersediaan Tempat Tidur BPJS Tanpa Buka Website Resmi

Pernahkah kamu merasa jengkel harus bolak-balik buka situs Aplicare BPJS sepanjang hari cuma untuk ngecek ketersediaan tempat tidur?

Koneksi lemot. Session timeout. Tampilan yang nggak ramah buat monitor besar. Belum lagi harus login berulang kali. Capek, kan?

Kalau kamu bekerja di fasilitas kesehatan — rumah sakit, klinik, atau puskesmas — pasti tahu betul rasanya. Setiap beberapa jam, atau bahkan setiap jam, kamu harus membuka browser, mengetik alamat, login, navigasi ke menu, dan mencari data yang sama. Ribet dan buang-buang waktu.

Nah, di artikel ini, kita bakal bangun dashboard sendiri. Sebuah aplikasi web kecil yang berjalan di komputer lokal, mengambil data dari Aplicare secara otomatis, dan menampilkannya dalam tampilan yang bersih, selalu diperbarui, tanpa perlu login berulang.

Kita akan buat:

• Sebuah scraper Python yang mengambil data dari endpoint BPJS
• Sebuah server Flask yang nyimpen data di memori dan menyajikannya ke browser
• Sebuah dashboard HTML yang menampilkan data secara real-time
• Otomatisasi biar dashboard bisa jalan terus di monitor tanpa intervensi manual

⚠️ Disclaimer Penting:

Metode ini menggunakan reverse engineering dari API yang nggak didokumentasikan secara publik. Gunakan dengan bijak, interval polling yang wajar (3–5 menit), dan sadari bahwa BPJS bisa mengubah endpoint sewaktu-waktu. Juga ingat bahwa data Aplicare bersifat indikatif — selalu konfirmasi langsung ke faskes sebelum mengambil keputusan medis.

🔍 Langkah 1: Menemukan Endpoint API (Reverse Engineering)

Aplicare adalah aplikasi AngularJS SPA (Single Page Application). Artinya, data nggak ada di HTML statis, tapi diambil melalui panggilan AJAX setelah halaman dimuat. Jadi kita harus "mengintip" komunikasi antara browser dan server.

Berikut cara menemukan endpoint yang kita butuhkan:

1. Buka https://faskes.bpjs-kesehatan.go.id/aplicares/ di browser (Chrome/Firefox).
2. Tekan F12 untuk membuka DevTools, lalu pilih tab Network.
3. Filter request dengan tipe XHR atau Fetch.
4. Lakukan aksi di web — misalnya cari rumah sakit, atau buka detail ketersediaan kamar.
5. Perhatikan request yang muncul. Biasanya ada endpoint seperti:

POST https://faskes.bpjs-kesehatan.go.id/aplicares/Pencarian/getData
Body: {"kdppk": "000xxxxnx", "jnsppk": "R"}

Cara tercepat untuk mendapatkan semua detail (URL, method, headers, payload) adalah dengan klik kanan pada request → "Copy as cURL". Ini akan memberi kamu satu blok perintah yang bisa langsung diubah menjadi kode Python.

Endpoint kunci yang kita temukan untuk dashboard ini adalah /aplicares/Pencarian/getData dengan parameter kdppk (kode faskes) dan jnsppk (jenis faskes, misal R untuk rumah sakit).

🔐 Langkah 2: Menangani Autentikasi dan Session

Server BPJS menggunakan proteksi WAF (Web Application Firewall) dan BIG-IP yang membutuhkan cookie session tertentu. Kamu nggak bisa langsung memanggil endpoint data tanpa terlebih dahulu membuka halaman utama.

Pola yang kita gunakan di scraper.py adalah "warm up session":

• Buka GET /aplicares/ terlebih dahulu buat dapetin cookie.
• Setelah cookie ada, baru panggil endpoint data dengan payload yang sudah disiapkan.
• Kalau di tengah jalan cookie expired, script bakal otomatis refresh dengan ngulang langkah 1.

Kita bakal pake library requests di Python dan memanfaatkan requests.Session() untuk nyimpen cookie otomatis.

🏗️ Langkah 3: Arsitektur Aplikasi

Aplikasi kita terdiri dari tiga komponen utama:

Komponen	Fungsi
scraper.py	Client HTTP yang handle session, fetch data dari BPJS, dan parsing JSON
app.py	Server Flask dengan background thread yang refresh data tiap interval, simpan di memori global
templates/index.html	Dashboard yang melakukan polling ke endpoint /api/data (lokal) tiap 30 detik

Poin penting: Browser nggak pernah langsung kontak ke BPJS — cuma server kamu yang kontak ke BPJS (tiap 5 menit). Browser cuma nanya ke server lokal kamu (tiap 30 detik). Ini menjaga beban ke BPJS tetap rendah, nggak peduli berapa banyak monitor atau browser yang membuka dashboard.

📦 Langkah 4: Persiapan Folder dan File

Buat folder proyek, misalnya D:\aplicare_dashboard. Di dalamnya, buat struktur berikut:

aplicare_dashboard/
├── scraper.py
├── app.py
├── requirements.txt
└── templates/
    └── index.html

⚠️ Perhatikan: Folder templates/ harus persis seperti itu — Flask bakal mencari file HTML di dalam folder ini secara otomatis.

File requirements.txt

Flask==2.2.3
requests==2.31.0

Install dependensi dengan perintah: pip install -r requirements.txt

File scraper.py

import requests
import json
import time

BASE_URL = "https://faskes.bpjs-kesehatan.go.id/aplicares"
ENDPOINT_DATA = BASE_URL + "/Pencarian/getData"

def fetch_data(kdppk="000xxxxnx", jnsppk="R"):
    """
    Ambil data dari endpoint BPJS.
    Parameter default bisa disesuaikan dengan kode faskes Anda.
    """
    session = requests.Session()

    # Langkah 1: warm up session - buka halaman utama
    try:
        session.get(BASE_URL + "/", timeout=10)
    except Exception as e:
        print("Gagal warm-up session:", e)
        return None

    # Langkah 2: panggil endpoint data
    payload = {
        "kdppk": kdppk,
        "jnsppk": jnsppk
    }
    headers = {
        "Content-Type": "application/json",
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
    }

    try:
        response = session.post(ENDPOINT_DATA, json=payload, headers=headers, timeout=15)
        if response.status_code == 200:
            data = response.json()
            return data
        else:
            print("HTTP Error:", response.status_code)
            return None
    except Exception as e:
        print("Error saat fetch:", e)
        return None

if __name__ == "__main__":
    hasil = fetch_data()
    if hasil:
        print(json.dumps(hasil, indent=2))
    else:
        print("Gagal mengambil data.")

File app.py

from flask import Flask, render_template, jsonify
import threading
import time
import logging
from scraper import fetch_data

app = Flask(__name__)

cached_data = {
    "last_update": None,
    "data": None,
    "status": "Belum ada data"
}

REFRESH_INTERVAL = 300 # 5 menit

def background_refresh():
    global cached_data
    while True:
        try:
            logging.info("Mengambil data dari BPJS...")
            raw = fetch_data()
            if raw:
                cached_data["data"] = raw
                cached_data["last_update"] = time.strftime("%Y-%m-%d %H:%M:%S")
                cached_data["status"] = "OK"
                logging.info("Data berhasil diupdate.")
            else:
                cached_data["status"] = "Gagal mengambil data"
                logging.warning("Gagal mengambil data.")
        except Exception as e:
            cached_data["status"] = f"Error: {str(e)}"
            logging.error("Exception di background thread:", exc_info=True)

        time.sleep(REFRESH_INTERVAL)

thread = threading.Thread(target=background_refresh, daemon=True)
thread.start()

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/api/data')
def api_data():
    return jsonify(cached_data)

if __name__ == '__main__':
    logging.basicConfig(level=logging.INFO)
    app.run(host='0.0.0.0', port=5000, debug=False)

File templates/index.html

(Kode HTML lengkap untuk dashboard. Karena panjang, saya sertakan dalam bentuk link ke bagian sebelumnya atau bisa kamu salin dari repositori contoh.)

Intinya, dashboard ini akan menampilkan:

• Status koneksi dan waktu update terakhir
• Statistik utama: total tempat tidur, tersedia, terpakai
• Tabel detail ketersediaan per ruang/kelas

💡 Catatan IQROTECH: Menyesuaikan Struktur Data

Struktur JSON yang dikembalikan oleh BPJS bisa berbeda-beda tergantung endpoint dan parameter. Langkah terbaik untuk menyesuaikan adalah:

1. Jalankan scraper.py secara terpisah dan lihat output JSON-nya.
2. Perhatikan field apa saja yang tersedia (misal: total, tersedia, items, dsb).
3. Ubah fungsi renderStats() dan renderTable() di index.html sesuai dengan field yang kamu temukan.

Jangan khawatir kalau nggak langsung berhasil — ini bagian dari proses reverse engineering. Yang penting kamu tahu di mana harus menyesuaikan.

🚀 Langkah 5: Menjalankan Aplikasi di Windows

Setelah semua file siap, buka Command Prompt atau PowerShell di folder proyek, lalu jalankan:

python app.py

Kalau berhasil, kamu bakal lihat pesan * Running on http://0.0.0.0:5000. Buka browser di komputer yang sama dan akses http://localhost:5000.

Otomatisasi dengan Task Scheduler (Biar Jalan Terus)

Supaya dashboard bisa otomatis menyala saat Windows boot tanpa perlu manual menjalankan python app.py, gunakan Task Scheduler:

1. Buat file start_dashboard.bat di folder proyek dengan isi:

@echo off
cd /d D:\aplicare_dashboard
python app.py >> logs.txt 2>&1

2. Buka Task Scheduler → Create Basic Task → beri nama "Aplicare Dashboard".
3. Trigger: When the computer starts.
4. Action: Start a program → Program: python.exe (cari di C:\Users\...\AppData\Local\Programs\Python\Python311\python.exe) → Arguments: app.py → Start in: D:\aplicare_dashboard.
5. Centang "Run whether user is logged on or not" dan "Run with highest privileges".

Dengan ini, server bakal jalan di latar belakang meskipun belum login Windows.

🖥️ Langkah 6: Tampilan Kiosk dengan Firefox

Buat nampilin dashboard di monitor ruangan (misal TV), gunakan Firefox Kiosk Mode:

"C:\Program Files\Mozilla Firefox\firefox.exe" -kiosk http://localhost:5000

Perhatikan: tanda kutip cuma membungkus path firefox.exe, bukan parameter -kiosk-nya.

Kalau mau otomatis terbuka saat startup, buat shortcut dari perintah di atas dan letakkan di folder shell:startup.

⚖️ Etika dan Risiko

Sebelum kamu pake dashboard ini, pahami hal-hal berikut:

• Endpoint ini tidak resmi — ditemukan lewat DevTools, bukan API publik BPJS.
• BPJS dapat mengubah endpoint atau menambahkan proteksi sewaktu-waktu tanpa pemberitahuan.
• Polling terlalu sering (misal tiap detik) berisiko IP kamu diblokir oleh WAF mereka. Gunakan interval 3–5 menit.
• Data yang ditampilkan adalah indikatif — tidak menjamin ketersediaan sebenarnya sampai pasien tiba di faskes.

Saya sangat menyarankan untuk tetap membuka halaman Aplicare asli setidaknya sekali sehari untuk memverifikasi bahwa data yang di-scrape masih sesuai.

✅ Best Practice untuk Implementasi

• Simpan log error — dengan redirect >> logs.txt 2>&1, kamu bisa ngecek kalau ada masalah di kemudian hari.
• Gunakan parameter kdppk yang benar — sesuaikan dengan kode faskes kamu (bisa dilihat di URL Aplicare saat login).
• Setel waktu refresh di app.py — REFRESH_INTERVAL = 300 untuk 5 menit. Jangan kurang dari 120 detik.
• Pastikan Python terinstal dengan "Add to PATH" — ini kesalahan paling umum saat menjalankan python di command prompt.
• Gunakan host='0.0.0.0' biar dashboard bisa diakses dari perangkat lain di jaringan lokal (misal tablet atau HP untuk monitoring).

🔚 Kesimpulan

Dengan kurang dari 150 baris kode, kamu sekarang punya dashboard Aplicare sendiri yang berjalan di komputer lokal, update otomatis, dan bisa ditampilkan di monitor besar tanpa harus membuka situs BPJS berulang kali. Ini menghemat waktu, mengurangi frustrasi, dan memberikan tampilan yang lebih bersih dan fokus pada data yang benar-benar kamu butuhkan.

Ingat, teknologi hanyalah alat — bijaksanalah dalam menggunakannya. Jangan lupa verifikasi data secara berkala melalui sumber resmi, dan selalu utamakan keselamatan pasien di atas kenyamanan administrasi.

❓ FAQ

1. Apakah aplikasi ini melanggar aturan BPJS?
Secara teknis, scraping endpoint yang tidak didokumentasikan berada di area abu-abu. Gunakan untuk kebutuhan internal, dengan frekuensi wajar, dan tidak untuk komersial. BPJS berhak memblokir akses jika dianggap mengganggu.

2. Bagaimana jika endpoint berubah?
Kamu perlu mengulangi proses reverse engineering (langkah 1) untuk menemukan endpoint baru dan menyesuaikan scraper.py.

3. Bisakah dashboard diakses dari HP/tablet?
Ya, selama perangkat terhubung ke jaringan yang sama, akses http://[IP_KOMPUTER]:5000.

4. Data tidak muncul, hanya "Belum ada data". Kenapa?
Coba jalankan scraper.py langsung untuk melihat error-nya. Kemungkinan kode faskes (kdppk) salah atau cookie session tidak valid.

5. Apakah harus pakai Flask? Bisa pakai yang lain?
Bisa, misalnya FastAPI atau bahkan Node.js. Prinsipnya tetap sama: ada background scraper dan server web yang menyajikan data.

— Mengubah rutinitas yang melelahkan menjadi dashboard yang menenangkan. Itulah kekuatan kode sederhana.

Build Your Own Aplicare Dashboard — Monitor BPJS Bed Availability Without Opening the Official Website

Have you ever felt annoyed having to open the BPJS Aplicare site repeatedly throughout the day just to check bed availability?

Slow connections. Session timeouts. An interface that's not designed for large monitors. Not to mention having to log in over and over. Exhausting, right?

If you work in a healthcare facility — a hospital, clinic, or community health center — you know this feeling all too well. Every few hours, or even every hour, you open your browser, type the address, log in, navigate through menus, and search for the same data. Tedious and time-wasting.

In this article, we're going to build our own dashboard. A small web app that runs on a local computer, automatically pulls data from Aplicare, and displays it in a clean, always-updated view — without repeated logins.

What we'll build:

• A Python scraper that fetches data from the BPJS endpoint
• A Flask server that stores data in memory and serves it to the browser
• An HTML dashboard that displays data in real-time
• Automation so the dashboard runs continuously on a monitor without manual intervention

⚠️ Important Disclaimer:

This method uses reverse engineering of an undocumented API. Use it wisely, keep a reasonable polling interval (3–5 minutes), and be aware that BPJS may change endpoints at any time. Also remember that Aplicare data is indicative — always confirm directly with the facility before making medical decisions.

🔍 Step 1: Finding the API Endpoint (Reverse Engineering)

Aplicare is an AngularJS SPA (Single Page Application). That means data isn't in the static HTML — it's loaded via AJAX calls after the page loads. So we need to "eavesdrop" on the communication between the browser and the server.

Here's how to find the endpoint we need:

1. Open https://faskes.bpjs-kesehatan.go.id/aplicares/ in your browser (Chrome/Firefox).
2. Press F12 to open DevTools, then go to the Network tab.
3. Filter requests by XHR or Fetch type.
4. Perform an action on the site — e.g., search for a hospital or open room availability details.
5. Watch for the request that appears. Typically, you'll see something like:

POST https://faskes.bpjs-kesehatan.go.id/aplicares/Pencarian/getData
Body: {"kdppk": "000xxxxnx", "jnsppk": "R"}

The fastest way to capture all details (URL, method, headers, payload) is to right-click the request → "Copy as cURL". This gives you a single command block that you can easily convert into Python code.

The key endpoint for this dashboard is /aplicares/Pencarian/getData with parameters kdppk (facility code) and jnsppk (facility type, e.g., R for hospital).

🔐 Step 2: Handling Authentication and Session

The BPJS server uses WAF (Web Application Firewall) and BIG-IP protections that require specific session cookies. You can't directly call the data endpoint without first visiting the main page.

The pattern used in scraper.py is called "warm up session":

• First, open GET /aplicares/ to obtain cookies.
• Once cookies are set, call the data endpoint with the prepared payload.
• If the cookie expires midway, the script automatically refreshes by repeating step 1.

We'll use Python's requests library with requests.Session() to handle cookies automatically.

🏗️ Step 3: Application Architecture

Our application consists of three main components:

Component	Function
scraper.py	HTTP client that handles sessions, fetches data from BPJS, and parses JSON
app.py	Flask server with a background thread that refreshes data at intervals and stores it in global memory
templates/index.html	Dashboard that polls the local /api/data endpoint every 30 seconds

Key point: The browser never talks to BPJS directly — only your server does (every 5 minutes). The browser only asks your local server (every 30 seconds). This keeps the load on BPJS low, regardless of how many monitors or browsers open the dashboard.

📦 Step 4: Preparing the Folder Structure and Files

Create a project folder, e.g., D:\aplicare_dashboard. Inside it, set up this structure:

aplicare_dashboard/
├── scraper.py
├── app.py
├── requirements.txt
└── templates/
    └── index.html

⚠️ Note: The templates/ folder must be named exactly that — Flask will look for HTML files inside it automatically.

File requirements.txt

Flask==2.2.3
requests==2.31.0

Install dependencies with: pip install -r requirements.txt

File scraper.py

import requests
import json
import time

BASE_URL = "https://faskes.bpjs-kesehatan.go.id/aplicares"
ENDPOINT_DATA = BASE_URL + "/Pencarian/getData"

def fetch_data(kdppk="000xxxxnx", jnsppk="R"):
    """
    Fetch data from the BPJS endpoint.
    Default parameters can be adjusted to your facility code.
    """
    session = requests.Session()

    # Step 1: warm up session - open the main page
    try:
        session.get(BASE_URL + "/", timeout=10)
    except Exception as e:
        print("Warm-up failed:", e)
        return None

    # Step 2: call the data endpoint
    payload = {
        "kdppk": kdppk,
        "jnsppk": jnsppk
    }
    headers = {
        "Content-Type": "application/json",
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
    }

    try:
        response = session.post(ENDPOINT_DATA, json=payload, headers=headers, timeout=15)
        if response.status_code == 200:
            data = response.json()
            return data
        else:
            print("HTTP Error:", response.status_code)
            return None
    except Exception as e:
        print("Error during fetch:", e)
        return None

if __name__ == "__main__":
    result = fetch_data()
    if result:
        print(json.dumps(result, indent=2))
    else:
        print("Failed to fetch data.")

File app.py

from flask import Flask, render_template, jsonify
import threading
import time
import logging
from scraper import fetch_data

app = Flask(__name__)

cached_data = {
    "last_update": None,
    "data": None,
    "status": "No data yet"
}

REFRESH_INTERVAL = 300 # 5 minutes

def background_refresh():
    global cached_data
    while True:
        try:
            logging.info("Fetching data from BPJS...")
            raw = fetch_data()
            if raw:
                cached_data["data"] = raw
                cached_data["last_update"] = time.strftime("%Y-%m-%d %H:%M:%S")
                cached_data["status"] = "OK"
                logging.info("Data updated successfully.")
            else:
                cached_data["status"] = "Failed to fetch data"
                logging.warning("Failed to fetch data.")
        except Exception as e:
            cached_data["status"] = f"Error: {str(e)}"
            logging.error("Exception in background thread:", exc_info=True)

        time.sleep(REFRESH_INTERVAL)

thread = threading.Thread(target=background_refresh, daemon=True)
thread.start()

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/api/data')
def api_data():
    return jsonify(cached_data)

if __name__ == '__main__':
    logging.basicConfig(level=logging.INFO)
    app.run(host='0.0.0.0', port=5000, debug=False)

File templates/index.html

(Full HTML code for the dashboard. Due to length, it's included in the code block above or you can copy it from the example repository.)

In essence, this dashboard displays:

• Connection status and last update time
• Main statistics: total beds, available, occupied
• Detailed availability table per room/class

💡 IQROTECH Note: Adapting to the Actual Data Structure

The JSON structure returned by BPJS may differ depending on the endpoint and parameters. The best way to adapt is:

1. Run scraper.py separately and look at the JSON output.
2. Note which fields are available (e.g., total, tersedia, items, etc.).
3. Adjust the renderStats() and renderTable() functions in index.html to match those fields.

Don't worry if it doesn't work perfectly on the first try — that's part of reverse engineering. The important thing is you know where to adjust.

🚀 Step 5: Running the Application on Windows

Once all files are ready, open Command Prompt or PowerShell in the project folder and run:

python app.py

If successful, you'll see * Running on http://0.0.0.0:5000. Open your browser on the same machine and go to http://localhost:5000.

Automation with Task Scheduler (For continuous running)

To make the dashboard start automatically when Windows boots, use Task Scheduler:

1. Create a start_dashboard.bat file in your project folder with:

@echo off
cd /d D:\aplicare_dashboard
python app.py >> logs.txt 2>&1

2. Open Task Scheduler → Create Basic Task → name it "Aplicare Dashboard".
3. Trigger: When the computer starts.
4. Action: Start a program → Program: python.exe (find it under C:\Users\...\AppData\Local\Programs\Python\Python311\python.exe) → Arguments: app.py → Start in: D:\aplicare_dashboard.
5. Check "Run whether user is logged on or not" and "Run with highest privileges".

With this, the server will run in the background even before anyone logs into Windows.

🖥️ Step 6: Kiosk Display with Firefox

To display the dashboard on a room monitor (e.g., a TV), use Firefox Kiosk Mode:

"C:\Program Files\Mozilla Firefox\firefox.exe" -kiosk http://localhost:5000

Note: The quotes only wrap the path to firefox.exe, not the -kiosk parameter.

If you want it to open automatically on startup, create a shortcut of the above command and place it in the shell:startup folder.

⚖️ Ethics and Risks

Before you use this dashboard, be aware of the following:

• This endpoint is unofficial — discovered through DevTools, not a public BPJS API.
• BPJS can change the endpoint or add protections at any time without notice.
• Polling too frequently (e.g., every second) risks your IP being blocked by their WAF. Use a 3–5 minute interval.
• The data displayed is indicative — it does not guarantee actual availability until the patient arrives at the facility.

I strongly recommend still opening the official Aplicare page at least once a day to verify that the scraped data is still consistent.

✅ Best Practices for Implementation

• Save error logs — with redirect >> logs.txt 2>&1, you can check for issues later.
• Use the correct kdppk parameter — adjust to your facility code (visible in the Aplicare URL when logged in).
• Set the refresh time in app.py — REFRESH_INTERVAL = 300 for 5 minutes. Do not go below 120 seconds.
• Make sure Python is installed with "Add to PATH" — this is the most common mistake when running python from the command prompt.
• Use host='0.0.0.0' so the dashboard can be accessed from other devices on the local network (e.g., tablets or phones for monitoring).

🔚 Conclusion

With fewer than 150 lines of code, you now have your own Aplicare dashboard running on a local computer, updating automatically, and displayable on a large monitor without opening the BPJS site repeatedly. This saves time, reduces frustration, and provides a cleaner view focused on the data you really need.

Remember, technology is just a tool — use it wisely. Don't forget to verify data periodically from the official source, and always prioritize patient safety over administrative convenience.

❓ FAQ

1. Does this app violate BPJS rules?
Technically, scraping undocumented endpoints exists in a grey area. Use it for internal purposes, at a reasonable frequency, and not commercially. BPJS may block access if it's considered disruptive.

2. What if the endpoint changes?
You'll need to repeat the reverse engineering process (step 1) to find the new endpoint and adjust scraper.py accordingly.

3. Can the dashboard be accessed from a phone/tablet?
Yes, as long as the device is on the same network, access http://[COMPUTER_IP]:5000.

4. Data doesn't show up — only "No data yet". Why?
Try running scraper.py directly to see the error. Likely the facility code (kdppk) is wrong or the session cookie is invalid.

5. Does it have to be Flask? Can I use something else?
You could use FastAPI or even Node.js. The principle remains the same: a background scraper and a web server that serves the data.

— Transforming a tedious routine into a calming dashboard. That's the power of simple code.

Terima kasih sudah mampir! Jika kamu menikmati konten ini dan ingin menunjukkan dukunganmu, bagaimana kalau mentraktirku secangkir kopi? 😊 Ini adalah gestur kecil yang sangat membantu untuk menjaga semangatku agar terus membuat konten-konten keren. Tidak ada paksaan, tapi secangkir kopi darimu pasti akan membuat hariku jadi sedikit lebih cerah. ☕️

☕ Buy Me Coffee