Use Helodata with the tools your team already uses

How Helodata works with your stack

Drop-in compatible (today)

Helodata exposes a standard HTTP/SOCKS5 endpoint with username:password authentication. Any client that speaks these protocols — which is essentially every modern HTTP library, scraping framework, and headless browser — works without modification.

You don’t need a Helodata-specific library. You don’t need to rewrite your scraper. Point your existing client at our gateway, paste your credentials from the dashboard, and you’re live.

First-class support (in development)

Native libraries with auto-rotation, retry, sticky sessions, and type-safe response handling are launching Q3 2026:

• Python SDK
• Node.js SDK
• Go SDK
• Java SDK
• Open-source MCP server for AI agents

For now, the drop-in approach below covers every workflow. See the SDK roadmap for details.

AI agent and LLM frameworks

LangChain

Use Helodata as the HTTP backend for any LangChain tool that hits the web —RequestsGetTool, RequestsPostTool, or your own custom Tool.

from langchain_community.tools.requests.tool import (
    RequestsGetTool,
)
from langchain_community.utilities.requests import (
    TextRequestsWrapper,
)

# Get credentials from your Helodata dashboard
PROXY = "http://USER:PASS@gate.helodata.io:7777"

wrapper = TextRequestsWrapper(
    headers={},
    auth=None,
    proxies={"http": PROXY, "https": PROXY},
)
tool = RequestsGetTool(
    requests_wrapper=wrapper,
    allow_dangerous_requests=True,
)

LlamaIndex

LlamaIndex’s web readers use httpx under the hood. Pass proxy config when constructing the reader.

from llama_index.readers.web import SimpleWebPageReader
import httpx

PROXY = "http://USER:PASS@gate.helodata.io:7777"
client = httpx.Client(proxies=PROXY, timeout=30.0)
reader = SimpleWebPageReader(html_to_text=True, _client=client)
documents = reader.load_data(urls=["https://example.com"])

n8n

n8n’s HTTP Request node has a proxy field on the Authentication tab. Drop your Helodata gateway URL there — works for every node downstream.

For self-hosted n8n, set the env var: N8N_DEFAULT_PROXY=http://USER:PASS@gate.helodata.io:7777

MCP servers

A first-party Helodata MCP server is launching Q3 2026 — install with one command, expose proxy capabilities to Claude Desktop, Cursor, Cline, and any MCP-compatible client.

Until then, point any MCP server’s HTTP tool at the Helodata gateway using the same credentials you’d use anywhere else. Get notified when MCP server ships →

Web scraping frameworks

Scrapy

Scrapy supports proxies through the HttpProxyMiddleware (built in). Add to your settings.py:

# settings.py
DOWNLOADER_MIDDLEWARES = {
    'scrapy.downloadermiddlewares.httpproxy.'
    'HttpProxyMiddleware': 110,
}

HTTP_PROXY  = "http://USER:PASS@gate.helodata.io:7777"
HTTPS_PROXY = "http://USER:PASS@gate.helodata.io:7777"

For per-request proxy rotation, use scrapy-rotating-proxies and feed it a list of Helodata sticky-session credentials.

Playwright

Pass proxy config to the browser context (Python, Node.js, Java, .NET all use the same shape):

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(proxy={
        "server": "http://gate.helodata.io:7777",
        "username": "USER",
        "password": "PASS",
    })
    page = browser.new_page()
    page.goto("https://example.com")

Puppeteer

Puppeteer takes proxy config as a launch argument:

import puppeteer from 'puppeteer';

const browser = await puppeteer.launch({
  args: ['--proxy-server=http://gate.helodata.io:7777'],
});
const page = await browser.newPage();
await page.authenticate({ username: 'USER', password: 'PASS' });
await page.goto('https://example.com');

Selenium

Selenium 4+ supports proxies via the Capabilities object:

from selenium import webdriver
from selenium.webdriver.common.proxy import Proxy, ProxyType

proxy = Proxy()
proxy.proxy_type = ProxyType.MANUAL
proxy.http_proxy  = "USER:PASS@gate.helodata.io:7777"
proxy.ssl_proxy   = "USER:PASS@gate.helodata.io:7777"

caps = webdriver.DesiredCapabilities.CHROME.copy()
proxy.add_to_capabilities(caps)
driver = webdriver.Chrome(desired_capabilities=caps)

Apify

Apify Actors accept a proxyConfiguration input. For self-managed proxies, use:

{
  "proxyConfiguration": {
    "useApifyProxy": false,
    "proxyUrls": [
      "http://USER:PASS@gate.helodata.io:7777"
    ]
  }
}

Browserless

Browserless supports custom proxies via the --proxy-server flag in the page connection params:

https://chrome.browserless.io?token=KEY&--proxy-server=http://gate.helodata.io:7777

Pass auth credentials via Page.authenticate after connection.

BeautifulSoup (with requests)

BeautifulSoup parses HTML — it doesn’t fetch. Pair it with requests or httpx to fetch through Helodata:

import requests
from bs4 import BeautifulSoup

PROXY = "http://USER:PASS@gate.helodata.io:7777"
r = requests.get(
    "https://example.com",
    proxies={"http": PROXY, "https": PROXY},
)
soup = BeautifulSoup(r.text, "html.parser")

Migrating from zyte

zyte Smart Proxy Manager and zyte API both expose proxy endpoints similar to Helodata. To migrate:

1. Replace proxy.zyte.com:8011 with gate.helodata.io:7777
2. Swap your zyte API key for Helodata credentials
3. Sticky sessions: use username-session-XXXX format (matches zyte)
4. Geo-targeting: pass country-XX in the username (matches zyte)

Most existing zyte integrations need no other code changes. Helodata’s ethical IP sourcing and KYC compliance are net additions, not replacements for zyte’s value proposition.

HTTP libraries

Python requests

import requests

PROXY = "http://USER:PASS@gate.helodata.io:7777"
r = requests.get(
    "https://api.target.com/v1/data",
    proxies={"http": PROXY, "https": PROXY},
    timeout=30,
)

Node.js axios

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

const agent = new HttpsProxyAgent(
  'http://USER:PASS@gate.helodata.io:7777'
);
const r = await axios.get('https://api.target.com', {
  httpAgent: agent,
  httpsAgent: agent,
  timeout: 30000,
});

Python httpx

import httpx

proxy = "http://USER:PASS@gate.helodata.io:7777"
with httpx.Client(proxies=proxy, timeout=30.0) as client:
    r = client.get("https://api.target.com")

Node.js Cheerio

Cheerio parses HTML on Node, like BeautifulSoup on Python. Pair with axios or got to fetch through Helodata:

import axios from 'axios';
import * as cheerio from 'cheerio';
import { HttpsProxyAgent } from 'https-proxy-agent';

const agent = new HttpsProxyAgent(
  'http://USER:PASS@gate.helodata.io:7777'
);
const r = await axios.get('https://example.com', {
  httpsAgent: agent,
});
const $ = cheerio.load(r.data);

curl

curl -x http://USER:PASS@gate.helodata.io:7777 \
     https://api.target.com/v1/data

Don’t see your tool?

If your tool supports HTTP or SOCKS5 proxies — and almost every modern data tool does — Helodata works. Common scenarios we get asked about:

• wget, lynx, w3m — standard --proxy or http_proxy env var
• Java HttpClient — System.setProperty("http.proxyHost", ...)
• .NET HttpClient — WebProxy class
• Rust reqwest — Proxy::http("...")
• PHP Guzzle — 'proxy' option in request config
• Ruby Faraday — Faraday::ProxyOptions
• Go net/http — Transport.Proxy = http.ProxyURL(...)

If your stack genuinely doesn’t support standard proxy configuration, email our support team — we’ll either document a workaround or log it as a roadmap item.

Frequently asked questions

Does Helodata have an official LangChain / LlamaIndex / n8n integration?

Helodata works with LangChain, LlamaIndex, and n8n today via standard HTTP proxy configuration — no Helodata-specific package required. First-party native integrations (with auto-rotation primitives baked in) are on our roadmap for Q3 2026.

Do I need a Helodata SDK to use Helodata?

No. Helodata is accessed over standard HTTP/SOCKS5, so any HTTP client or scraping framework works without a Helodata-specific library. SDKs launching Q3 2026 will add convenience features like auto-rotation, retries, and type-safe response handling — but they’re optional.

Can I migrate from Bright Data, Oxylabs, or zyte without rewriting code?

In most cases, yes. Helodata speaks the same HTTP/SOCKS5 protocol as those providers and supports similar username-based geo-targeting and sticky session conventions. For most customers, migration is a credentials swap. Email our support team if you’d like a migration walkthrough for your specific stack.

Does Helodata work with self-hosted scrapers like Crawlee?

Yes. Crawlee, Colly (Go), and other self-hosted scraping frameworks all support HTTP/SOCKS5 proxies via standard config. The integration pattern is identical to the Scrapy and Puppeteer examples above.