Integration Guides

import requests

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.zentislabs.com/api"
headers = {"X-API-Key": API_KEY, "Content-Type": "application/json"}

# Generate a residential proxy
res = requests.post(f"{BASE_URL}/v1/proxy/generate", headers=headers, json={
    "type": "RESIDENTIAL",
    "country": "US",
    "sessionType": "rotating",
})
proxy = res.json()["data"]["proxy"]
proxy_url = f"http://{proxy['username']}:{proxy['password']}@{proxy['host']}:{proxy['port']}"

# Use the proxy
response = requests.get("https://httpbin.org/ip", proxies={"http": proxy_url, "https": proxy_url})
print(f"Proxy IP: {response.json()['origin']}")

import requests

# Use proxy credentials from the dashboard
PROXY = "http://USERNAME:PASSWORD@gate.zentislabs.com:8080"
proxies = {"http": PROXY, "https": PROXY}

response = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=30)
print("Your IP:", response.json()["origin"])

import asyncio
import aiohttp

PROXY = "http://USERNAME:PASSWORD@gate.zentislabs.com:8080"

async def scrape_urls(urls: list[str]):
    results = []
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, url) for url in urls]
        results = await asyncio.gather(*tasks, return_exceptions=True)

    success = sum(1 for r in results if not isinstance(r, Exception))
    print(f"Completed: {success}/{len(urls)}")
    return results

async def fetch(session, url):
    async with session.get(url, proxy=PROXY, timeout=aiohttp.ClientTimeout(total=30)) as resp:
        return await resp.text()

urls = [f"https://example.com/page/{i}" for i in range(100)]
asyncio.run(scrape_urls(urls))

# Check your proxy list
proxies = requests.get(f"{BASE_URL}/v1/proxies", headers=headers)
data = proxies.json()["data"]
print(f"Active proxies: {len(data)}")

import axios from "axios";
import { HttpsProxyAgent } from "https-proxy-agent";

const API_KEY = process.env.ZENTISLABS_API_KEY!;
const BASE_URL = "https://api.zentislabs.com/api";

// Generate a proxy via API
const { data: result } = await axios.post(
  `${BASE_URL}/v1/proxy/generate`,
  { type: "RESIDENTIAL", country: "DE", sessionType: "rotating" },
  { headers: { "X-API-Key": API_KEY } }
);

const proxy = result.data.proxy;
const agent = new HttpsProxyAgent(
  `http://${proxy.username}:${proxy.password}@${proxy.host}:${proxy.port}`
);

const { data: ip } = await axios.get("https://httpbin.org/ip", { httpsAgent: agent });
console.log(`Proxy IP: ${ip.origin}`);

import axios from "axios";
import { HttpsProxyAgent } from "https-proxy-agent";

// Use proxy credentials from the dashboard
const proxyUrl = "http://USERNAME:PASSWORD@gate.zentislabs.com:8080";
const agent = new HttpsProxyAgent(proxyUrl);

const { data } = await axios.get("https://httpbin.org/ip", {
  httpsAgent: agent,
  timeout: 30000,
});
console.log("Proxy IP:", data.origin);

import { HttpsProxyAgent } from "https-proxy-agent";
import pLimit from "p-limit";

const makeAgent = (session: string) =>
  new HttpsProxyAgent(
    `http://customer-USERNAME-cc-US-sessid-${session}:PASSWORD@gate.zentislabs.com:8080`
  );

const limit = pLimit(20);
const urls = Array.from({ length: 200 }, (_, i) => `https://example.com/page/${i}`);

const results = await Promise.allSettled(
  urls.map((url, i) =>
    limit(async () => {
      const agent = makeAgent(`batch-${i}`);
      const res = await fetch(url, { agent } as any);
      return res.text();
    })
  )
);

const success = results.filter((r) => r.status === "fulfilled").length;
console.log(`Success: ${success}/${urls.length}`);

package main

import (
    "fmt"
    "io"
    "net/http"
    "net/url"
)

func main() {
    proxyURL, _ := url.Parse(
        "http://USERNAME:PASSWORD@gate.zentislabs.com:8080",
    )

    httpClient := &http.Client{
        Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)},
    }

    resp, err := httpClient.Get("https://httpbin.org/ip")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Response:", string(body))
}