Integration Guides

import requests

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.zentislabs.com/api"
headers = {"X-API-Key": API_KEY}

# Generate a rotating Basic residential proxy in the US
res = requests.post(f"{BASE_URL}/v1/proxies/generate", headers=headers, json={
    "provider": "basic",
    "country": "US",
    "sessionType": "rotating",
    "count": 1,
})
res.raise_for_status()
line = res.json()["proxies"][0]  # "host:port:username:password"
host, port, user, password = line.split(":", 3)
proxy_url = f"http://{user}:{password}@{host}:{port}"

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

import requests

# Use proxy credentials from the dashboard
PROXY = "http://USERNAME:PASSWORD@basic.resi.zentislabs.com:12321"
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@basic.resi.zentislabs.com:12321"

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))

import requests

headers = {"X-API-Key": "YOUR_API_KEY"}

# Remaining bandwidth for each product
usage = requests.get("https://api.zentislabs.com/api/v1/usage", headers=headers).json()
for plan, bw in usage["products"].items():
    print(f"{plan}: {bw['remainingGb']:.2f} of {bw['totalGb']:.2f} GB left")

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/proxies/generate`,
  { provider: "basic", country: "DE", sessionType: "rotating", count: 1 },
  { headers: { "X-API-Key": API_KEY } }
);

// Each line is host:port:username:password
const [host, port, user, ...rest] = result.proxies[0].split(":");
const agent = new HttpsProxyAgent(
  `http://${user}:${rest.join(":")}@${host}:${port}`
);

const { data: ip } = await axios.get("https://httpbin.org/ip", { httpsAgent: agent, proxy: false });
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@basic.resi.zentislabs.com:12321";
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 axios from "axios";
import { HttpsProxyAgent } from "https-proxy-agent";
import pLimit from "p-limit";

// Rotating Basic proxy: every request gets a fresh IP
const agent = new HttpsProxyAgent(
  "http://USERNAME:PASSWORD_country-us@basic.resi.zentislabs.com:12321"
);

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

const results = await Promise.allSettled(
  urls.map((url) =>
    limit(async () => {
      const res = await axios.get(url, { httpsAgent: agent, proxy: false, timeout: 30000 });
      return res.data;
    })
  )
);

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@basic.resi.zentislabs.com:12321",
    )

    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))
}