Rust ویب سکریپنگ: Devs کے لیے ایک مرحلہ وار گائیڈ

Rust ویب سکریپنگ سے مراد Rust پروگرامنگ زبان اور اس کے کریٹس کے ماحولیاتی نظام کی مدد سے ویب صفحات حاصل کرنا اور ان کا تجزیہ کرنا ہے۔ Rust ان ڈویلپرز کے لیے پرکشش ہے جو گاربیج کلیکٹر کے بغیر قابل پیش گوئی کارکردگی اور میموری کی حفاظت چاہتے ہیں، اس لیے یہ مسلسل یا زیادہ حجم پر چلنے والے کرالرز کے لیے موزوں انتخاب ہے۔

یہ ایک عملی اور کوڈ پر مبنی رہنما ہے، جو reqwest HTTP کلائنٹ اور scraper پارسنگ کریٹ کے گرد ترتیب دیا گیا ہے۔ اس میں پروجیکٹ سیٹ اپ، CSS سلیکٹرز، ساخت یافتہ ڈیٹا ماڈلز، JSON اور CSV ایکسپورٹ، صفحہ بندی، بیک آف کے ساتھ ایرر ہینڈلنگ اور دوبارہ کوششیں، tokio کے ذریعے async کنکرنسی، پراکسی کنفیگریشن، اور JavaScript سے بھرپور سائٹس کے لیے headless-browser متبادل شامل ہیں۔ ہر مثال کو مرتب اور چلانے کے قابل بنایا گیا ہے۔

DataImpulse ایک اخلاقی پراکسی فراہم کنندہ ہے جو 195 ممالک میں 90 ملین سے زیادہ رہائشی، موبائل، اور ڈیٹا سینٹر IP ایڈریس پیش کرتا ہے۔ یہ 1 ڈالر فی GB سے شروع ہونے والا پے-ایز-یو-گو ماڈل فراہم کرتا ہے، جس میں ٹریفک کی میعاد ختم نہیں ہوتی۔ اسے ویب سکریپنگ، اشتہارات کی تصدیق، قیمتوں کی نگرانی، مارکیٹ ریسرچ اور متعدد اکاؤنٹس کے انتظام کے لیے استعمال کیا جاتا ہے۔

ویب سکریپنگ کے لیے Rust کیوں استعمال کریں؟

جب رفتار، کم میموری استعمال اور قابل اعتماد عمل فوری پروٹو ٹائپنگ سے زیادہ اہم ہوں تو Rust ویب سکریپنگ کے لیے موزوں ہے۔ اس کی کمپائل شدہ بائنریز ہارڈ ویئر کے قریب چلتی ہیں، اور borrow checker کنکرنسی بگز کی پوری اقسام کو پروڈکشن کے بجائے کمپائل کے وقت پکڑ لیتا ہے۔

یہ خصوصیات چند عام صورتوں میں خاص فائدہ دیتی ہیں:

• تھرو پٹ: کمپائل شدہ Rust کرالر تشریحی زبان کے مقابلے میں کم CPU اور میموری اوورہیڈ کے ساتھ صفحات کی بڑی تعداد پراسیس کر سکتا ہے، جس سے طویل کاموں کے بنیادی ڈھانچے کی لاگت گھٹتی ہے۔
• محفوظ ہم آہنگی: async رن ٹائم tokio آپ کو ہزاروں کنکرنٹ درخواستیں چلانے دیتا ہے، جبکہ ٹائپ سسٹم ان کاموں میں ڈیٹا کی دوڑ کو روکتا ہے۔
• متوقع وسائل کا استعمال: گاربیج کلیکٹر نہ ہونے سے تاخیر زیادہ مستحکم رہتی ہے، جو گھنٹوں یا دنوں تک چلنے والے کاموں کے لیے مفید ہے۔

اس کا بدلہ نسبتاً دشوار سیکھنے کا مرحلہ اور زیادہ کمپائل وقت ہے، اس لیے Rust ان پروجیکٹس میں زیادہ فائدہ دیتا ہے جو یک بار چلنے والی اسکرپٹ کے بجائے بڑے پیمانے پر چلنے ہوں۔ زبان کچھ بھی ہو، ایک ہی بنیادی اصول لاگو ہوتے ہیں: robots.txt کا احترام کریں، اپنی درخواستوں کی رفتار محدود رکھیں، اور ان عمومی ہدایات پر عمل کریں: ویب سکریپنگ کے بہترین طریقے تاکہ آپ کا کرالر ایک اچھا شہری رہے۔

آپ Rust سکریپنگ پروجیکٹ کیسے ترتیب دیتے ہیں؟

نیا Cargo پیکج بنا کر اور Cargo.toml میں مطلوبہ کریٹس درج کر کے Rust سکریپنگ پروجیکٹ ترتیب دیں۔ Cargo Rust کا بلڈ ٹول اور پیکیج مینیجر ہے، لہذا یہ انحصار کو حل کرتا ہے اور آپ کے لیے پروجیکٹ کو مرتب کرتا ہے۔

پروجیکٹ کا ڈھانچا بنانے کے لیے cargo new rust-scraper چلائیں، پھر بننے والی Cargo.toml میں ترمیم کریں۔ ذیل کے dependencies اس رہنما کی تمام ضروریات پوری کرتے ہیں: HTTP، پارسنگ، async، سیریلائزیشن، CSV آؤٹ پٹ، streams اور آسان ایرر ہینڈلنگ۔

[package]
name = "rust-scraper"
version = "0.1.0"
edition = "2021"

[dependencies]
reqwest = { version = "0.12", features = ["json", "socks"] }
scraper = "0.20"
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
csv = "1.3"
futures = "0.3"
anyhow = "1"
thiserror = "1"

یہاں reqwest درخواستیں سنبھالتا ہے (socks فیچر SOCKS5 پراکسیز فعال کرتا ہے اور json فیچر JSON ہیلپرز شامل کرتا ہے)، scraper CSS سلیکٹرز سے HTML پارس کرتا ہے، tokio async رن ٹائم فراہم کرتا ہے، serde اور serde_json ڈیٹا سیریلائز کرتے ہیں، csv CSV فائلیں لکھتا ہے، جبکہ anyhow اور thiserror ایرر ہینڈلنگ آسان بناتے ہیں۔ پہلی درخواست لکھنے سے پہلے سب کچھ ڈاؤن لوڈ اور کمپائل کرنے کے لیے ایک بار cargo build چلائیں۔

آپ reqwest اور scraper کے ساتھ کسی صفحہ کو کیسے حاصل اور تجزیہ کرتے ہیں؟

reqwest سے GET درخواست بھیج کر صفحہ حاصل کریں، پھر CSS سلیکٹرز کے ذریعے استفسار کے لیے response body کو scraper میں لوڈ کریں۔ ذیل کی مثال tokio پر async انداز میں چلتی ہے، ایک صفحہ حاصل کرتی ہے اور ہر H1 عنصر کا متن پرنٹ کرتی ہے۔

use scraper::{Html, Selector};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let url = "https://example.com";
    let body = reqwest::get(url).await?.text().await?;

    let document = Html::parse_document(&body);
    let heading = Selector::parse("h1").unwrap();

    for element in document.select(&heading) {
        let text: String = element.text().collect();
        println!("{}", text.trim());
    }
    Ok(())
}

عمل کا بہاؤ ہمیشہ ایک جیسا ہے: reqwest::get response لاتا ہے، .text() اس کی body کو string کے طور پر پڑھتا ہے، اور Html::parse_document اسے قابل استفسار درخت میں بدل دیتا ہے۔ ? آپریٹر کسی بھی نیٹ ورک یا decoding کی خرابی کو main تک پہنچا دیتا ہے۔ کسی مماثل عنصر پر .text() اس کے text nodes جمع کرتا ہے، جنہیں پھر trim کر کے استعمال کیا جاتا ہے۔ یہ raw HTML طریقہ تیز ہے، مگر یہ صرف سرور سے آنے والا markup دیکھتا ہے، وہ مواد نہیں جو براؤزر بعد میں JavaScript سے render کرے۔

آپ CSS سلیکٹرز کے ساتھ عناصر کو کیسے نشانہ بناتے ہیں؟

عناصر کو نشانہ بنانے کے لیے معیاری CSS selector string Selector::parse کو دیں، بالکل ویسے ہی جیسے براؤزر کنسول میں دیتے ہیں۔ scraper کریٹ tags، classes، IDs، attribute matches، descendant paths اور structural pseudo-classes سپورٹ کرتا ہے۔

use scraper::Selector;

// Match by tag
let links = Selector::parse("a").unwrap();

// Match by class
let prices = Selector::parse(".price").unwrap();

// Match by id
let main = Selector::parse("#main-content").unwrap();

// Match by attribute value
let external = Selector::parse("a[rel=\"nofollow\"]").unwrap();

// Descendant path (a title inside a product card)
let titles = Selector::parse("div.product h2.title").unwrap();

// Direct child plus pseudo-class
let first_row = Selector::parse("table > tbody > tr:first-child").unwrap();

ہر selector کو ایک بار compile کریں اور loop کے اندر بار بار parse کرنے کے بجائے دوبارہ استعمال کریں۔ جب selector match نہ کرے تو غائب فیلڈ کے باعث پورا عمل panic ہونے سے بچانے کے لیے .unwrap() کے بجائے fallback کے ساتھ .next() استعمال کریں۔ براؤزر کے element picker سے target page کا معائنہ کرنا مستحکم class names اور attributes ڈھونڈنے کا تیز ترین طریقہ ہے۔

آپ سکریپ شدہ ڈیٹا کو JSON اور CSV میں کیسے برآمد کرتے ہیں؟

ہر record کو Serialize derive کرنے والے struct کے طور پر ماڈل کریں، پھر ان structs کی slice کو serde_json سے JSON یا csv کریٹ سے CSV میں لکھ کر سکریپ شدہ ڈیٹا ایکسپورٹ کریں۔ typed model extraction اور output کو ہم آہنگ رکھتا ہے اور کوڈ کو خود وضاحتی بناتا ہے۔

سب سے پہلے، ریکارڈ کا نمونہ بنائیں اور ہر کنٹینر عنصر سے فیلڈز نکالیں:

use scraper::{Html, Selector};
use serde::Serialize;

#[derive(Debug, Serialize)]
struct Product {
    name: String,
    price: String,
    url: String,
}

fn parse_products(html: &str) -> Vec<Product> {
    let document = Html::parse_document(html);
    let card = Selector::parse("div.product").unwrap();
    let name_sel = Selector::parse("h2.title").unwrap();
    let price_sel = Selector::parse("span.price").unwrap();
    let link_sel = Selector::parse("a").unwrap();

    let mut products = Vec::new();
    for card_el in document.select(&card) {
        let name = card_el
            .select(&name_sel)
            .next()
            .map(|e| e.text().collect::<String>().trim().to_string())
            .unwrap_or_default();
        let price = card_el
            .select(&price_sel)
            .next()
            .map(|e| e.text().collect::<String>().trim().to_string())
            .unwrap_or_default();
        let url = card_el
            .select(&link_sel)
            .next()
            .and_then(|e| e.value().attr("href"))
            .unwrap_or_default()
            .to_string();

        products.push(Product { name, price, url });
    }
    products
}

چونکہ Product میں Serialize derive کیا گیا ہے، ایک ہی struct بغیر اضافی کام کے دونوں exporters کو ڈیٹا دیتا ہے:

use std::fs::File;
use std::io::Write;

fn export_json(products: &[Product]) -> anyhow::Result<()> {
    let json = serde_json::to_string_pretty(products)?;
    let mut file = File::create("products.json")?;
    file.write_all(json.as_bytes())?;
    Ok(())
}

fn export_csv(products: &[Product]) -> anyhow::Result<()> {
    let mut writer = csv::Writer::from_path("products.csv")?;
    for product in products {
        writer.serialize(product)?;
    }
    writer.flush()?;
    Ok(())
}

serde_json کا to_string_pretty انسانی پڑھنے کے قابل JSON بناتا ہے، جبکہ csv کریٹ کا serialize فیلڈ ناموں سے بنے header کے ساتھ ہر struct کو ایک قطار میں لکھتا ہے۔ سکریپنگ، JSON اور CSV کے لیے ایک typed model دوبارہ استعمال کرنے سے target site کی تبدیلی کے ساتھ Rust پائپ لائن کو برقرار رکھنا آسان ہوتا ہے۔

آپ صفحہ بندی لوپ کے ساتھ متعدد صفحات کو کیسے کھرچتے ہیں؟

page numbers یا اگلے صفحے کے URL پر loop چلا کر متعدد صفحات سکریپ کریں۔ درخواستوں کے درمیان connections دوبارہ استعمال کرنے کے لیے ایک ہی reqwest client استعمال کریں۔ ہر URL بنائیں، اسے حاصل کریں، پچھلے حصے کے function سے parse کریں، اور جب کسی صفحے سے نتائج نہ آئیں تو رک جائیں۔

use scraper::Html;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = reqwest::Client::new();
    let mut all_products = Vec::new();

    for page in 1..=10 {
        let url = format!("https://example.com/products?page={}", page);
        let body = client.get(&url).send().await?.text().await?;
        let products = parse_products(&body);

        // Stop when a page returns no results
        if products.is_empty() {
            break;
        }
        all_products.extend(products);

        // Pause between requests to stay polite
        tokio::time::sleep(std::time::Duration::from_millis(500)).await;
    }

    println!("Collected {} products", all_products.len());
    Ok(())
}

loop کے باہر ایک بار reqwest::Client::new() سے client بنانا اسے TCP connections دوبارہ استعمال کرنے دیتا ہے، جو ہر درخواست کے لیے نیا client بنانے سے نمایاں طور پر تیز ہے۔ آخری صفحے پر خالی results کا check loop کو فطری طور پر ختم کر دیتا ہے، اور مختصر وقفے سرور کو بوجھ سے بچاتے ہیں۔ ان سائٹس کے لیے جو نمبر والے صفحات کے بجائے اگلا لنک استعمال کرتی ہیں، ہر تکرار پر اگلے صفحے کے اینکر کا href نکالیں اور اس کی پیروی کریں جب تک کہ لنک غائب نہ ہوجائے۔

آپ بیک آف کے ساتھ غلطیوں اور دوبارہ کوششوں کو کیسے ہینڈل کرتے ہیں؟

fetch functions سے typed errors واپس کر کے غلطیاں سنبھالیں، پھر عارضی ناکامیوں پر exponential backoff کے ساتھ دوبارہ کوشش کریں۔ نیٹ ورک timeout ہو سکتے ہیں اور سرور عارضی status codes لوٹا سکتے ہیں، اس لیے مضبوط scraper ایک ناکامی کو مہلک واقعے کے بجائے متوقع صورت سمجھتا ہے۔

thiserror کریٹ آپ کو ایک مختصر error enum بنانے دیتا ہے، جس میں reqwest error خود بخود تبدیل ہو جاتا ہے:

use thiserror::Error;

#[derive(Error, Debug)]
enum ScrapeError {
    #[error("request failed: {0}")]
    Request(#[from] reqwest::Error),

    #[error("unexpected status code: {0}")]
    Status(reqwest::StatusCode),

    #[error("selector matched no elements")]
    Empty,
}

async fn fetch_page(client: &reqwest::Client, url: &str) -> Result<String, ScrapeError> {
    let response = client.get(url).send().await?;
    if !response.status().is_success() {
        return Err(ScrapeError::Status(response.status()));
    }
    Ok(response.text().await?)
}

#[from] attribute کا مطلب ہے کہ ? آپریٹر reqwest failure کو خود بخود ScrapeError::Request میں بدل دیتا ہے۔ typed errors کے اوپر، درخواست کو ایسے retry loop میں لپیٹیں جس کا انتظار ہر کوشش کے بعد بڑھتا ہو:

use std::time::Duration;

async fn fetch_with_backoff(client: &reqwest::Client, url: &str) -> anyhow::Result<String> {
    let max_attempts = 5;
    for attempt in 1..=max_attempts {
        match client.get(url).send().await {
            Ok(resp) if resp.status().is_success() => {
                return Ok(resp.text().await?);
            }
            Ok(resp) => {
                eprintln!("attempt {attempt}: status {}", resp.status());
            }
            Err(err) => {
                eprintln!("attempt {attempt}: {err}");
            }
        }
        // Exponential backoff: 0.5s, 1s, 2s, 4s, 8s
        let backoff = Duration::from_millis(500 * 2u64.pow(attempt - 1));
        tokio::time::sleep(backoff).await;
    }
    anyhow::bail!("giving up on {url} after {max_attempts} attempts")
}

exponential backoff (یہاں 0.5s, 1s, 2s, 4s, 8s) بار بار ضرب لگانے کے بجائے rate-limited یا عارضی طور پر overloaded server کو سنبھلنے کا وقت دیتا ہے۔ روٹیٹنگ پراکسیز کے ساتھ retries ملانا مزید مضبوط طریقہ ہے: ایک IP پر block یا throttle ہونے والی درخواست اگلی کوشش میں دوسرے exit IP سے کامیاب ہو سکتی ہے۔

آپ tokio کے ساتھ کنکرنٹ درخواستیں کیسے چلاتے ہیں؟

اپنی URLs کی فہرست کو async stream میں بدلیں اور buffer_unordered سے بیک وقت جاری درخواستوں کی تعداد محدود کر کے concurrent requests چلائیں۔ Rust scraper میں یہ کارکردگی بہتر بنانے کا سب سے مؤثر طریقہ ہے، اور tokio کے ساتھ futures کریٹ اسے محفوظ بناتا ہے۔

use futures::stream::{self, StreamExt};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = reqwest::Client::new();
    let urls: Vec<String> = (1..=50)
        .map(|n| format!("https://example.com/item/{}", n))
        .collect();

    let bodies = stream::iter(urls)
        .map(|url| {
            let client = client.clone();
            async move {
                let text = client.get(&url).send().await?.text().await?;
                Ok::<_, reqwest::Error>((url, text))
            }
        })
        .buffer_unordered(10); // at most 10 requests in flight

    bodies
        .for_each(|result| async {
            match result {
                Ok((url, body)) => println!("{}: {} bytes", url, body.len()),
                Err(err) => eprintln!("error: {}", err),
            }
        })
        .await;

    Ok(())
}

یہاں stream::iter URL فہرست کو stream میں بدلتا ہے، .map ہر URL کے لیے async request بناتا ہے، اور buffer_unordered(10) بیک وقت زیادہ سے زیادہ دس درخواستیں چلاتا ہے، جن کے مکمل ہوتے ہی نتائج ملتے ہیں۔ ہر کام کے لیے client کو clone کرنا سستا ہے، کیونکہ reqwest کا Client مشترک connection pool کے گرد ایک Arc ہے۔ ہدف پر بوجھ کے مقابلے میں رفتار متوازن رکھنے کے لیے concurrency limit کو tune کریں: دس سے بیس مناسب نقطۂ آغاز ہے، اور proxy pool کے ساتھ زیادہ concurrency ان درخواستوں کو بہت سے IPs میں پھیلا دیتی ہے۔

آپ Rust سکریپنگ ٹریفک کو پراکسی کے ذریعے کیسے روٹ کرتے ہیں؟

reqwest::Proxy کے ساتھ reqwest client بنا کر، اور gateway و اسناد کو .basic_auth سے شامل کر کے ٹریفک کو پراکسی کے ذریعے route کریں۔ روٹیٹنگ IPs سے درخواستیں بھیجنا بوجھ بانٹتا ہے، جغرافیائی مخصوص مواد تک رسائی دیتا ہے اور rate limit ہونے کے امکانات کم کرتا ہے۔ IPs کو روٹیٹ کرنا ان مؤثر طریقوں میں سے ایک ہے: بلاک کیے بغیر سکریپ کرنا.

use reqwest::Proxy;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Authenticated gateway; rotates the exit IP on each request
    let proxy = Proxy::all("http://gw.dataimpulse.com:823")?
        .basic_auth("login", "password");

    let client = reqwest::Client::builder()
        .proxy(proxy)
        .timeout(std::time::Duration::from_secs(30))
        .build()?;

    let body = client
        .get("https://httpbin.org/ip")
        .send()
        .await?
        .text()
        .await?;

    println!("{}", body);
    Ok(())
}

login اور password کو اپنی اسناد سے بدلیں اور مطلوبہ نیٹ ورک کے لیے port ایڈجسٹ کریں۔ اگر پراکسی 407 status کے ساتھ درخواست مسترد کرے تو عموماً اس کی وجہ غلط یا غائب اسناد ہوتی ہیں۔ HTTP غلطی 407 اور پراکسی کی توثیق میں اسے درست کرنے کا طریقہ بتایا گیا ہے۔ DataImpulse رہائشی پراکسی, ڈیٹا سینٹر پراکسیز، اور موبائل پراکسی کو HTTP، HTTPS اور SOCKS5 پر روٹیٹنگ اور sticky sessions کے ساتھ فراہم کرتا ہے۔ ملک کی ہدف بندی شامل ہے، جبکہ ریاست، شہر، ZIP اور ASN کی ہدف بندی paid add-ons ہیں۔

آپ JavaScript سے بھرپور صفحات کیسے سکریپ کرتے ہیں، اور Rust کب درست انتخاب ہے؟

حقیقی headless browser چلا کر JavaScript سے بھرپور صفحات سکریپ کریں، کیونکہ reqwest اور scraper صرف سرور کا raw HTML دیکھتے ہیں اور scripts کبھی چلاتے نہیں۔ جب مواد صرف client-side rendering کے بعد ظاہر ہو تو thirtyfour جیسے browser automation crate کا استعمال کریں، جو WebDriver protocol استعمال کرتا ہے، یا chromiumoxide کا، جو DevTools Protocol کے ذریعے Chrome کو کنٹرول کرتا ہے۔

use thirtyfour::prelude::*;

#[tokio::main]
async fn main() -> WebDriverResult<()> {
    let caps = DesiredCapabilities::chrome();
    let driver = WebDriver::new("http://localhost:9515", caps).await?;

    driver.goto("https://example.com").await?;

    // Wait for client-side content to render, then read it
    let heading = driver.find(By::Css("h1")).await?;
    println!("{}", heading.text().await?);

    driver.quit().await?;
    Ok(())
}

thirtyfour کی مثال چلتے ہوئے chromedriver سے جڑتی ہے، صفحہ لوڈ کرتی ہے، render شدہ عنصر کا انتظار کرتی ہے اور اس کا متن پڑھتی ہے۔ یہ طریقہ سادہ HTTP fetch سے کہیں زیادہ بھاری ہے، اس لیے اسے صرف ان صفحات کے لیے استعمال کریں جنہیں واقعی اس کی ضرورت ہو، اور باقی کے لیے تیز reqwest راستہ رکھیں۔ اس فرق کو مزید سمجھنے کے لیے یہ رہنما دیکھیں: متحرک ویب صفحات کو سکریپ کرنا اور JavaScript کے ساتھ ویب سکریپنگ. نیچے کی جدول دکھاتی ہے کہ بنیادی کریٹس آپس میں کیسے کام کرتے ہیں:

زبان کے انتخاب میں، جب مستقل کارکردگی اور بڑے پیمانے پر کم وسائل درکار ہوں تو Rust منتخب کریں۔ جب تیز ترقی اور Scrapy یا Playwright جیسے وسیع scraping ecosystem کو ترجیح ہو تو Python بہتر ہے۔ ایک عام طریقہ یہ ہے کہ extraction rules پہلے Python میں prototype کیے جائیں، پھر منطق مستحکم اور حجم بڑھنے پر hot path کو Rust میں منتقل کر دیا جائے۔ انتخاب کوئی بھی ہو، network layer parser جتنی ہی اہم ہے، اور اخلاقی طور پر حاصل کردہ پراکسیز بڑے کاموں کو قابل اعتماد بناتی ہیں۔

اکثر پوچھے گئے سوالات

متعلقہ گائیڈز

• JavaScript کے ساتھ ویب سکریپنگ
• متحرک ویب صفحات کی سکریپنگ
• ویب سکریپنگ کے بہترین طریقے

اخلاقی پراکسیوں کے ساتھ قابل اعتماد طریقے سے کھرچنا

جب آپ کا Rust scraper ڈیٹا حاصل، تجزیہ اور صاف طور پر ایکسپورٹ کرنے لگے، تو قابل اعتماد پراکسی نیٹ ورک اسے بڑے پیمانے پر چلانے میں مدد دیتا ہے۔ DataImpulse 1 ڈالر فی GB سے اخلاقی طور پر حاصل کردہ IPs اور بغیر میعاد ختم ہونے والی ٹریفک کے ساتھ پے-ایز-یو-گو سروس دیتا ہے، تاکہ آپ ایک اکاؤنٹ بنائیں اور چند منٹ میں اپنی پہلی درخواستیں route کر سکیں۔