Gambaran Umum

mitmproxy adalah proxy pencegat open-source yang dapat diskrip yang berjalan sebagai proses macOS normal. Dalam mode upstream, ia menerima koneksi dari klien lokal pada satu port (127.0.0.1:8080) dan meneruskan lalu lintas tersebut ke proxy kedua — dalam hal ini, endpoint residensial atau seluler Dataimpulse Anda.

Keuntungannya adalah sentralisasi: Anda mengonfigurasi proxy sekali, lalu browser, alat CLI, skrip Python, atau emulator seluler apa pun di mesin dapat diarahkan melalui Dataimpulse tanpa mengubah pengaturan proxy alat itu sendiri. Semuanya melewati satu titik penyempitan tempat Anda dapat membatasi konkurensi, memantau kegagalan, dan memastikan IP keluar mana yang sebenarnya Anda gunakan.

Dataimpulse cukup cocok untuk pola ini karena menawarkan endpoint residensial dan seluler melalui HTTP dan SOCKS5, dengan penagihan bayar sesuai pemakaian dan kumpulan IP yang besar — berguna untuk pengumpulan data bervolume tinggi yang bersifat bursty, di mana komitmen bulanan tidak diperlukan. Anda dapat membandingkannya dengan penyedia proxy lain sebelum berkomitmen.

Kapan pendekatan ini masuk akal

Pendekatan	Yang Anda konfigurasi	Paling cocok untuk
mode upstream mitmproxy (panduan ini)	Satu port lokal untuk semua klien	Beberapa alat sekaligus, throttling dan logging terpusat
flag proxy per alat (`curl -x`, `requests` `proxies=`)	Setiap alat secara terpisah	Satu skrip dengan bagian bergerak minimal
manajer proxy desktop (misalnya Proxifier)	Aturan per aplikasi	Aplikasi GUI yang mengabaikan pengaturan proxy sistem

Apa yang akan Anda bangun

Listener mitmproxy lokal pada 127.0.0.1:8080
Koneksi upstream ke Dataimpulse melalui HTTP atau SOCKS5
Intersepsi TLS opsional untuk host tertentu yang ingin Anda periksa
Addon gerbang konkurensi yang menjaga tekanan permintaan tetap terprediksi
Contoh yang berfungsi untuk curl, requests, Playwright, dan emulator Android

Prasyarat

macOS 13 atau lebih baru dengan Homebrew terpasang
Akun Dataimpulse, plus nama pengguna, kata sandi, host gateway, dan port HTTP/SOCKS5 yang ditampilkan di dasbor Anda
Python 3.9 atau lebih baru untuk contoh klien (python3 --version)
Nyaman dengan Terminal dan pemahaman dasar tentang proxy HTTP dan TLS

Cara Penyiapan Bekerja

mitmproxy mendengarkan pada 127.0.0.1:8080.
Klien Anda mengirim permintaannya ke mitmproxy alih-alih langsung ke situs target.
mitmproxy membuka koneksi ke gateway Dataimpulse.
Dataimpulse menetapkan IP keluar dari kumpulannya.
Respons melakukan perjalanan kembali melalui mitmproxy ke klien Anda.

Ada dua mode yang penting, dan memilih di antara keduanya sejak awal menghemat waktu:

Pass-through (tunneling): mitmproxy meneruskan byte TLS tanpa mendekripsinya. Tidak ada perubahan sertifikat yang diperlukan di mana pun. Diaktifkan dengan --ignore-hosts '.*'.
Intersepsi: mitmproxy mengakhiri TLS sehingga dapat membaca atau menulis ulang permintaan dan respons. Memerlukan kepercayaan pada sertifikat CA mitmproxy di macOS dan di setiap runtime klien.

Untuk scraping yang hanya membutuhkan IP keluar berbeda, pass-through lebih sederhana dan cepat, dan sama sekali menghindari urusan sertifikat. Aktifkan intersepsi hanya untuk host yang benar-benar perlu Anda periksa.

Langkah-langkah

Pasang mitmproxy.

brew install mitmproxy
mitmdump --version

Ekspor kredensial Dataimpulse Anda sebagai variabel lingkungan agar tidak pernah muncul di riwayat shell atau file yang di-commit.

export DI_USER='your-dataimpulse-username'
export DI_PASS='your-dataimpulse-password'
export DI_HOST='gateway-host-from-your-dashboard'
export DI_HTTP_PORT='http-port-from-your-dashboard'
export DI_SOCKS_PORT='socks5-port-from-your-dashboard'
export DI_SESSION='scrape-macos-01'

Tambahkan baris yang sama ke ~/.zshrc jika Anda ingin agar tersedia di setiap shell baru, dan konfirmasi host dan port tanpa menampilkan kata sandi:

echo "${DI_HOST}:${DI_HTTP_PORT}"

Lakukan percent-encode pada kredensial yang mengandung karakter terreservasi. Karakter seperti @, :, /, atau # di dalam kata sandi akan merusak URL upstream. Encode hanya nilai yang Anda tempatkan di URL.
```
python3 -c "import os, urllib.parse; print(urllib.parse.quote(os.environ['DI_PASS'], safe=''))"
```
Jalankan mitmproxy dalam mode upstream pass-through melalui HTTP. Dalam mode pass-through, mitmproxy menerowongkan lalu lintas tanpa mendekripsinya, sehingga tidak diperlukan perubahan sertifikat klien.
```
mitmdump \
  --mode "upstream:http://${DI_USER}:${DI_PASS}@${DI_HOST}:${DI_HTTP_PORT}" \
  --listen-port 8080 \
  --ignore-hosts '.*' \
  --set flow_detail=1
```
Verifikasi IP keluar. Biarkan mitmproxy berjalan di jendela terminalnya sendiri dan uji dari jendela kedua.
```
curl -s -x http://127.0.0.1:8080 https://api.ipify.org
echo
curl -s https://api.ipify.org
echo
```
Kedua alamat harus berbeda. Jika sama, permintaan tidak mencapai Dataimpulse — lihat bagian pemecahan masalah.
Ganti upstream ke SOCKS5 ketika Anda ingin proxy menyelesaikan DNS dari jarak jauh, yang sering kali lebih disukai untuk target yang sensitif secara geografis.
```
mitmdump \
  --mode "upstream:socks5://${DI_USER}:${DI_PASS}@${DI_HOST}:${DI_SOCKS_PORT}" \
  --listen-port 8080 \
  --ignore-hosts '.*'
```
Aktifkan intersepsi hanya untuk host yang Anda butuhkan. --allow-hosts membatasi dekripsi hanya pada host yang cocok; semua yang lain tetap diterowongkan dan tidak tersentuh.
```
mitmdump \
  --mode "upstream:http://${DI_USER}:${DI_PASS}@${DI_HOST}:${DI_HTTP_PORT}" \
  --listen-port 8080 \
  --allow-hosts 'example\.com' \
  -s ./gate.py
```

Percayai sertifikat CA mitmproxy sebelum melakukan scraping host HTTPS melalui intersepsi. File sertifikat dibuat saat pertama kali mitmproxy dimulai.

# First run generates ~/.mitmproxy/mitmproxy-ca-cert.pem
mitmdump --listen-port 8081 &
sleep 2
kill %1

sudo security add-trusted-cert -d -r trustRoot \
  -k /Library/Keychains/System.keychain \
  ~/.mitmproxy/mitmproxy-ca-cert.pem

Runtime baris perintah sering mengabaikan keychain macOS, jadi arahkan mereka ke bundle eksplisit:

cat "$(python3 -c 'import certifi; print(certifi.where())')" \
  ~/.mitmproxy/mitmproxy-ca-cert.pem > ~/.mitmproxy/ca-bundle.pem

export REQUESTS_CA_BUNDLE=~/.mitmproxy/ca-bundle.pem
export NODE_EXTRA_CA_CERTS=~/.mitmproxy/mitmproxy-ca-cert.pem

Tambahkan addon gerbang konkurensi agar ledakan dari scraper cepat tidak membanjiri gateway. Simpan ini sebagai gate.py di samping direktori tempat Anda menjalankan mitmproxy.

# gate.py — cap in-flight requests passing through mitmproxy
import asyncio

from mitmproxy import http


class Gate:
    def __init__(self, limit: int = 8) -> None:
        self._limit = limit
        self._sem: asyncio.Semaphore | None = None

    def running(self) -> None:
        self._sem = asyncio.Semaphore(self._limit)

    async def request(self, flow: http.HTTPFlow) -> None:
        await self._sem.acquire()
        flow.metadata["gate_held"] = True

    def _release(self, flow: http.HTTPFlow) -> None:
        if flow.metadata.pop("gate_held", False):
            self._sem.release()

    def response(self, flow: http.HTTPFlow) -> None:
        self._release(flow)

    def error(self, flow: http.HTTPFlow) -> None:
        self._release(flow)


addons = [Gate(limit=8)]

Muat dengan -s ./gate.py. Perhatikan bahwa addon hanya melihat aliran yang diintersepsi: jika Anda menjalankan dengan --ignore-hosts '.*', koneksi diterowongkan dan hook ini tidak pernah terpicu. Dalam hal ini, batasi konkurensi di dalam scraper Anda sebagai gantinya.

Arahkan alat Anda ke listener lokal. Untuk alat shell, ekspor variabel standar di terminal tempat Anda melakukan scraping — tetapi tidak di terminal yang menjalankan mitmproxy, untuk menghindari loop proxy.

export HTTP_PROXY=http://127.0.0.1:8080
export HTTPS_PROXY=http://127.0.0.1:8080
export NO_PROXY=localhost,127.0.0.1
curl -s https://httpbin.org/ip

Untuk skrip Python, tidak ada konfigurasi CA yang diperlukan selama Anda tetap dalam mode pass-through:

import requests

LOCAL_PROXY = "http://127.0.0.1:8080"
proxies = {"http": LOCAL_PROXY, "https": LOCAL_PROXY}

response = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=30)
response.raise_for_status()
print(response.json())

Untuk browser headless, berikan proxy lokal yang sama ke konteks browser:

from playwright.sync_api import sync_playwright

LOCAL_PROXY = "http://127.0.0.1:8080"

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True, proxy={"server": LOCAL_PROXY})
    page = browser.new_page()
    page.goto("https://httpbin.org/ip", wait_until="domcontentloaded")
    print(page.inner_text("body"))
    browser.close()

Jika Anda juga perlu melakukan scraping layanan yang berjalan di mesin Anda sendiri, Chromium melewati alamat loopback secara default. Menambahkan args=["--proxy-bypass-list=<-loopback>"] ke panggilan peluncuran menghapus pengecualian tersebut.

Tangkap lalu lintas emulator (opsional). Endpoint seluler Dataimpulse menyediakan IP keluar kelas operator; mereka sendiri tidak menangkap lalu lintas perangkat. Untuk mengarahkan emulator melalui kumpulan itu, arahkan emulator ke listener host.
```
# Android emulator: 10.0.2.2 is the host machine
adb shell settings put global http_proxy 10.0.2.2:8080
adb shell settings get global http_proxy

# Reset when finished
adb shell settings put global http_proxy :0
```
Untuk Simulator iOS, buka Pengaturan, pilih Wi-Fi, lalu Konfigurasi Proxy, Manual, dan atur server ke 127.0.0.1 pada port 8080. Lalu lintas simulator berbagi tumpukan jaringan Mac, jadi intersepsi memerlukan CA yang dipasang di simulator juga.
Bersihkan setelah selesai. Hapus sertifikat intersepsi dan atur ulang pengaturan klien apa pun agar lalu lintas yang tidak terkait berhenti mengalir melalui mitmproxy.
```
sudo security delete-certificate -c mitmproxy /Library/Keychains/System.keychain
unset HTTP_PROXY HTTPS_PROXY
```

Pemecahan Masalah

407 Proxy Authentication Required

URL upstream kehilangan kredensial, atau karakter terreservasi di kata sandi merusak URL. Jalankan ulang perintah percent-encoding di langkah 3 dan bangun ulang string --mode dengan nilai yang telah di-encode.

SSLCertVerificationError, CERT_AUTHORITY_INVALID, atau unable to get local issuer certificate

Anda mengaktifkan intersepsi tetapi klien tidak mempercayai CA mitmproxy. Pasang sertifikat seperti yang ditunjukkan di langkah 8, lalu atur variabel bundle khusus runtime (REQUESTS_CA_BUNDLE, NODE_EXTRA_CA_CERTS). Alternatifnya, kembalilah ke mode pass-through dengan --ignore-hosts '.*' jika Anda tidak perlu membaca lalu lintas.

Alamat sudah digunakan

Proses lain sudah memiliki port tersebut. Temukan proses itu, lalu ubah --listen-port alih-alih mematikan layanan yang tidak terkait.

lsof -nP -iTCP:8080 -sTCP:LISTEN

Semua permintaan menggantung atau timeout

Anda kemungkinan besar berada dalam loop proxy: HTTP_PROXY diekspor di shell yang sama yang menjalankan mitmproxy, sehingga koneksi upstream mitmproxy sendiri dikirim kembali ke dirinya sendiri. Jalankan mitmproxy di terminal bersih, atau unset HTTP_PROXY HTTPS_PROXY sebelum memulainya.

Permintaan berhasil tetapi IP keluar tidak pernah berubah

Mode pass-through tidak memutar apa pun dengan sendirinya. Perilaku rotasi ditentukan oleh jenis sesi yang Anda konfigurasi di dasbor dan oleh bagaimana klien Anda membuka koneksi. Pastikan Anda tidak menyematkan satu sesi sticky di seluruh proses, dan periksa IP keluar dengan perintah di langkah 5.

Emulator mengabaikan proxy

Pada emulator Android, 127.0.0.1 merujuk ke emulator itu sendiri, bukan Mac. Gunakan 10.0.2.2 dan konfirmasi nilainya dengan adb shell settings get global http_proxy.

Target mengembalikan 403 atau 429

Ini adalah pembatasan laju di tujuan, bukan kegagalan proxy. Kurangi batas gerbang di gate.py, tambahkan jeda antar permintaan, dan pastikan scraping Anda mematuhi ketentuan situs dan robots.txt.

Ringkasan

Anda sekarang memiliki satu listener mitmproxy lokal di macOS yang meneruskan klien apa pun ke proxy residensial atau seluler Dataimpulse melalui HTTP atau SOCKS5, dengan mode pass-through untuk rotasi IP sederhana dan intersepsi selektif untuk inspeksi lebih dalam. Kredensial disimpan dalam variabel lingkungan, konkurensi dibatasi oleh addon, dan kepercayaan sertifikat dapat ditambahkan atau dihapus dengan bersih saat Anda tidak lagi perlu membaca lalu lintas terenkripsi.