# EProxies Documentation — full text (English)

> Source: https://www.eproxies.io/docs · Other languages: zh-cn, fr, pt, ru, vi (see https://www.eproxies.io/llms.txt)
> OpenAPI spec: https://www.eproxies.io/docs/openapi.json

---

# 👋 Quick Start
URL: https://www.eproxies.io/docs

Welcome to EProxies. This documentation is written for both human users and AI agents: every feature comes with a parameter table and copy-paste-ready code. If you are an AI agent, start with the [Agent Cheat Sheet](https://www.eproxies.io/docs/agent-reference).

## Get connected in 3 minutes

**Step 1: Create an account**

Sign up for free at [dashboard.eproxies.io](https://dashboard.eproxies.io) (one-click Google sign-in supported). New accounts include trial traffic — no credit card required.

**Step 2: Buy a plan**

Pick a plan on the [pricing page](https://www.eproxies.io/pricing). Residential Proxies are billed by traffic (GB) and can be purchased online; credentials activate instantly after payment.

**Step 3: Send your first request**

Grab your username and password from the Proxy Settings page in the dashboard, then replace `USERNAME` and `PASSWORD` in the command below:

```bash
curl -x proxy.eproxies.net:23333 -U "USERNAME-pool-flow:PASSWORD" https://ipinfo.io
```

If the `ip` field in the returned JSON shows the proxy exit IP, you are connected.

## Connection details at a glance

| Item | Value |
| --- | --- |
| Proxy gateway | `proxy.eproxies.net` |
| Port | `23333` (shared by HTTP, HTTPS, and SOCKS5) |
| Authentication | Username/password or IP whitelist ([details](https://www.eproxies.io/docs/usage/authentication)) |
| Country targeting | Append `-region-US` etc. to the username ([syntax](https://www.eproxies.io/docs/usage/username-syntax)) |
| Session control | Rotates per request by default; append `-sid-{random string}-ttl-{minutes}` to keep the same IP ([details](https://www.eproxies.io/docs/usage/session-control)) |
| Dashboard | [dashboard.eproxies.io](https://dashboard.eproxies.io) |

## Product overview

| Product | Billing | How to buy |
| --- | --- | --- |
| [Residential Proxies](https://www.eproxies.io/docs/products/residential) | By traffic (GB) | [Self-service on the website](https://www.eproxies.io/pricing) |
| [Unlimited Residential Proxies](https://www.eproxies.io/docs/products/unlimited-residential) | By bandwidth (Mbps), 7-day / 30-day | [Contact us on Telegram](https://t.me/eproxies) |
| [SOCKS5 Proxies](https://www.eproxies.io/docs/products/socks5) | By number of IPs | [Contact us on Telegram](https://t.me/eproxies) |
| [Static Residential Proxies](https://www.eproxies.io/docs/products/static-residential) | By IP, 1 / 7 / 30 days | See product page |

All products share the same pool of 72M+ real residential IPs across 195+ countries and regions, with city-level targeting. For current pricing, see the [pricing page](https://www.eproxies.io/pricing).

## Next steps

- [Username Parameter Syntax](https://www.eproxies.io/docs/usage/username-syntax)
- [Code Examples](https://www.eproxies.io/docs/usage/code-examples)
- [Antidetect Browser Integration](https://www.eproxies.io/docs/integrations/antidetect-browsers)
> EProxies is available only outside mainland China. See [Compliance & Usage Restrictions](https://www.eproxies.io/docs/compliance).

---

# FAQ
URL: https://www.eproxies.io/docs/faq

## General

**What is EProxies?**
EProxies is a global proxy network offering 72M+ residential IPs across 195+ countries, providing reliable proxy infrastructure for data collection, multi-account management, ad verification, and more.

**What types of proxies do you offer?**
Four products: Residential, Unlimited Residential, SOCKS5, and Static Residential. See the [product overview](https://www.eproxies.io/docs).

**Are the IPs ethically sourced?**
Yes. All residential IPs come from real devices with explicit user consent. We comply with applicable data protection regulations and maintain transparent data handling practices.

**Is there a free trial?**
Yes. Free accounts include a limited amount of trial traffic so you can evaluate performance, speed, and tool compatibility before buying.

**Which countries are supported?**
195+ countries and regions, with city-level targeting in major markets. See [Geo-Targeting](https://www.eproxies.io/docs/usage/geo-targeting).

## Billing & payments

**Which payment methods do you accept?**
Cryptocurrency (USDT/BTC/ETH/TRX/LTC), Alipay (CNY/HKD), and credit cards (Visa/Mastercard). See [Purchases & Payments](https://www.eproxies.io/docs/account/billing-and-payments).

**How are residential proxies billed?**
By transferred traffic (GB). Buy a traffic package and use it within its validity period; unused traffic carries over for as long as the package is valid.

**Can I upgrade or downgrade my plan?**
Upgrades take effect immediately and you only pay the difference; downgrades take effect at the next billing cycle.

**What is the refund policy?**
Refunds are available within 3 days of purchase if less than 20% of the plan has been used. See the [refund policy](https://www.eproxies.io/docs/account/billing-and-payments).

**Is there enterprise pricing?**
Yes — volume discounts, SLA guarantees, and a dedicated account manager. [Contact sales](https://www.eproxies.io/company/contact) for a quote.

## Technical

**Which protocols are supported?**
HTTP, HTTPS, and SOCKS5 on the same gateway and port (`proxy.eproxies.net:23333`). Whichever protocol your client connects with just works.

**How do I integrate?**
After purchase you get credentials (host, port, username, password) — plug them into your program or tool. We provide [code examples](https://www.eproxies.io/docs/usage/code-examples) for Python, Node.js, Java, Go, PHP, and cURL.

**What is the average response time?**
Residential proxies average under 0.6 seconds; actual times vary with the target site and geographic distance.

**Do you support sticky sessions?**
Yes — the same IP can be held for 1–120 minutes. See [Session Control](https://www.eproxies.io/docs/usage/session-control).

**How does IP rotation work?**
By default every request is automatically assigned a new IP, handled entirely by the proxy gateway. When you need a fixed IP, use the sticky session parameters.

**My proxy will not connect — how do I troubleshoot?**
Check in order: (1) verify your credentials with [cURL](https://www.eproxies.io/docs/usage/code-examples); (2) confirm your plan still has traffic (dashboard overview); (3) check the username parameters for typos (the most common one is a missing `-pool-flow`); (4) in whitelist mode, confirm your exit IP is on the whitelist. If it still fails, contact [technical support](https://www.eproxies.io/docs/support).

---

# 🔌 OpenAPI
URL: https://www.eproxies.io/docs/openapi

EProxies exposes 5 HTTP endpoints (whitelist-mode proxy extraction and whitelist management). This page is a quick reference; for detailed usage see [API Extraction (Whitelist Mode)](https://www.eproxies.io/docs/usage/api-extraction).

> Machine-readable definition: [openapi.json](https://www.eproxies.io/docs/openapi.json) — an OpenAPI 3.0 spec you can import straight into Postman / Swagger UI / Insomnia, or hand to an AI agent to call automatically.

## Basics

| Item | Value |
| --- | --- |
| Base URL | `https://api.eproxies.net` |
| Auth (extraction) | Request must originate from a **whitelisted IP**; no credentials needed |
| Auth (management) | Query params `userName` + `userKeyValue` (user key, from the dashboard) |
| Proxy gateway | `proxy.eproxies.net:23333` (HTTP/HTTPS/SOCKS5 — not part of this HTTP API) |

## Endpoints

### `GET /gateway_api/extract_ip`

Extract proxies — Extract a batch of proxy endpoints. The request must originate from a whitelisted IP; the returned proxies are used directly, without credentials.

**Request parameters**

| Field | Type | Required | Allowed values | Description |
| --- | --- | --- | --- | --- |
| `count` | integer | Yes | `1` ~ N | Number of proxies to extract |
| `country` | string | No | `US` `GB` `JP` … / `Global` | ISO 3166-1 alpha-2 country code; `Global` means any country |
| `protocol` | string | No | `http` / `socks5` | Proxy protocol |
| `format` | string | No | `txt` / `json` | Response format; `json` returns an object array, `txt` returns plain-text lines |
| `separator` | string | No | `crlf` `br` `cr` `lf` `tab` | Separator for `txt` format: `\r\n`, `</br>`, `\r`, `\n`, `\t` respectively |
| `st` | string | No | — | Custom separator; overrides `separator` when set |
| `session` | string | No | `sticky` / `random` | IP type: `sticky` reuses the same batch of IPs, `random` returns random ones |

**Response fields**

| Field | Type | Description |
| --- | --- | --- |
| `ipAddress` | string | Proxy IP address |
| `portValue` | integer | Proxy port |

With `format=json` the response is an array of the objects above; with `format=txt` it is `IP:port` text lines joined by `separator`.

**Example**

```bash
curl "https://api.eproxies.net/gateway_api/extract_ip?count=10&country=US&protocol=http&format=json&session=sticky"
```

```json
[
  { "ipAddress": "203.0.113.10", "portValue": 23333 },
  { "ipAddress": "203.0.113.11", "portValue": 23333 }
]
```

### `GET /gateway_api/country-list`

Supported countries — List every country available for whitelist-mode extraction.

**Request parameters**

No request parameters.

**Response fields**

| Field | Type | Description |
| --- | --- | --- |
| `country` | string | ISO 3166-1 alpha-2 code — use it as the `country` parameter of `extract_ip` |
| `name` | string | Country name |
| `flag_url` | string | Flag icon URL |

**Example**

```bash
curl "https://api.eproxies.net/gateway_api/country-list"
```

```json
[
  { "country": "US", "name": "United States", "flag_url": "https://file.eproxies.net/flags/us.png" }
]
```

### `GET /gateway_api/add-ip`

Add a whitelist IP — Add an exit IP to the whitelist; that IP can then extract proxies without credentials.

**Request parameters**

| Field | Type | Required | Allowed values | Description |
| --- | --- | --- | --- | --- |
| `userName` | string | Yes | — | Account username |
| `userKeyValue` | string | Yes | — | User key, from the dashboard |
| `ipAddress` | string | Yes | — | IP address to whitelist |

**Response fields**

Returns an operation-result object; refer to the actual response.

**Example**

```bash
curl "https://api.eproxies.net/gateway_api/add-ip?userName=USERNAME&userKeyValue=USER_KEY&ipAddress=203.0.113.10"
```

### `GET /gateway_api/del-ip`

Delete a whitelist IP — Remove an IP from the whitelist; it can no longer extract without credentials.

**Request parameters**

| Field | Type | Required | Allowed values | Description |
| --- | --- | --- | --- | --- |
| `userName` | string | Yes | — | Account username |
| `userKeyValue` | string | Yes | — | User key, from the dashboard |
| `ipAddress` | string | Yes | — | Whitelist IP to remove |

**Response fields**

Returns an operation-result object; refer to the actual response.

**Example**

```bash
curl "https://api.eproxies.net/gateway_api/del-ip?userName=USERNAME&userKeyValue=USER_KEY&ipAddress=203.0.113.10"
```

### `GET /gateway_api/lists-ip`

List whitelist entries — List all whitelist entries under the current account.

**Request parameters**

| Field | Type | Required | Allowed values | Description |
| --- | --- | --- | --- | --- |
| `userName` | string | Yes | — | Account username |
| `userKeyValue` | string | Yes | — | User key, from the dashboard |

**Response fields**

| Field | Type | Description |
| --- | --- | --- |
| `ipAddress` | string | Whitelisted IP |
| `remarkText` | string | Remark |

**Example**

```bash
curl "https://api.eproxies.net/gateway_api/lists-ip?userName=USERNAME&userKeyValue=USER_KEY"
```

## Quick call

```bash
# Extract 10 US HTTP proxies (JSON, sticky IPs)
curl "https://api.eproxies.net/gateway_api/extract_ip?count=10&country=US&protocol=http&format=json&session=sticky"

# Whitelist the current server IP
curl "https://api.eproxies.net/gateway_api/add-ip?userName=USERNAME&userKeyValue=USER_KEY&ipAddress=203.0.113.10"
```

## Using it from an AI agent

Point your agent at the spec URL and it can work out every parameter and response shape on its own:

```
https://www.eproxies.io/docs/openapi.json
```

Together with the [Agent Cheat Sheet](https://www.eproxies.io/docs/agent-reference) (username parameter syntax for the proxy gateway) this covers the full integration surface.

---

# Contact Support
URL: https://www.eproxies.io/docs/support

## Support channels

| Channel | Address | Hours |
| --- | --- | --- |
| Telegram | [t.me/eproxies](https://t.me/eproxies) | 24/7 |
| Discord | [discord.gg/yzZNxN75](https://discord.gg/yzZNxN75) | 24/7 |
| Email | `support@eproxies.io` | Mon–Fri 9:00–18:00 (UTC) |
| Ticket form | [Contact page](https://www.eproxies.io/company/contact) | Topics: General / Sales / Technical Support / Partnership / Billing |

For urgent issues, use **Telegram** first. For billing, refunds, invoices, and anything that needs a paper trail, use **email** and include your order number.

## Before you ask

Technical issues get resolved fastest when you include:

1. The full command or code you ran (**with the password redacted**).
2. The complete error message or response.
3. Whether you have already verified your credentials with the [basic cURL command](https://www.eproxies.io/docs/usage/code-examples).
4. Your account email and the approximate time of the issue.

## Social media

* Twitter/X: [@easy_proxies](https://x.com/easy_proxies)
* YouTube: [@eproxies](https://youtube.com/@eproxies)

## Business inquiries

For enterprise plans, the reseller program, or channel partnerships, reach out via [Telegram](https://t.me/eproxies) or the ticket form with the "Partnership" topic.

---

# Compliance & Usage Restrictions
URL: https://www.eproxies.io/docs/compliance

## Regional restriction

> EProxies is available **only outside mainland China**.

## Ethically sourced IPs

* All residential IPs come from real devices whose owners have given explicit consent.
* We comply with applicable data protection regulations (including GDPR) and maintain transparent data handling practices.
* All traffic is encrypted end to end, and we enforce a no-logs policy.

## Permitted uses

The proxy service is intended for legitimate business purposes, including but not limited to:

* Public data collection and market research
* Ad verification and brand protection
* SEO / SERP monitoring and price comparison
* Multi-account management (in compliance with the target platform's terms)
* AI / ML training data acquisition
* Security testing (within authorized scope only)

## Prohibited uses

The following will result in account termination without refund:

* Any illegal activity: intrusion, fraud, malware distribution, data theft, etc.
* Attacks against targets (DDoS, brute force, etc.)
* Harmful content involving minors
* Bulk spam
* Circumventing legally mandated access controls

We reserve the right to suspend or terminate service for violating accounts. Full terms are in the [Terms of Service](https://www.eproxies.io/legal/terms) and [Privacy Policy](https://www.eproxies.io/legal/privacy).

## User responsibilities

* When accessing third-party platforms through the proxies, comply with the target platform's terms of service and local laws.
* Keep your credentials safe. Traffic losses caused by leaked credentials are the account owner's responsibility — if you notice anything unusual, change your password immediately and contact [support](https://www.eproxies.io/docs/support).

---

# 🤖 Agent Cheat Sheet
URL: https://www.eproxies.io/docs/agent-reference

This page compresses everything you need to connect to EProxies onto one screen, for AI agents and developers who want fast lookups. Every example runs as-is once you substitute your credentials.

## Endpoints

```
Proxy gateway:   proxy.eproxies.net:23333   (one port for HTTP / HTTPS / SOCKS5)
Dashboard:       https://dashboard.eproxies.io
API extraction:  https://api.eproxies.net/gateway_api/extract_ip   (whitelist mode)
Country list:    https://api.eproxies.net/gateway_api/country-list
```

Machine-readable API definition: [OpenAPI specification](https://www.eproxies.io/docs/openapi.json)

## Username syntax (credential mode)

```
{account}-pool-flow[-region-{country code}][-state-{state}][-city-{city}][-asn-{ASN}][-sid-{8-char random}-ttl-{minutes}]
```

Rules:

* Segment order is fixed; concatenate left to right as shown. The password never changes.
* `region`: ISO 3166-1 two-letter country code, e.g. `US`, `GB`, `JP`.
* `state`: full state/province name, e.g. `California`; `city`: city name in lowercase with spaces removed, e.g. `losangeles`. **`city` requires `state`.**
* `asn`: format `AS15802`; **mutually exclusive with state / city** (combine with region only).
* `sid` + `ttl`: sticky session. `sid` is an 8-character random alphanumeric string (generate it yourself; a new sid means a new IP); `ttl` is the hold time in minutes, range **1–120**. Without `sid`, the IP rotates on every request.

Examples (simple to complex):

```
USERNAME-pool-flow                                                    # Global random, rotate per request
USERNAME-pool-flow-region-US                                          # US IP
USERNAME-pool-flow-region-US-state-California                         # California, US
USERNAME-pool-flow-region-US-state-California-city-losangeles         # Los Angeles, California, US
USERNAME-pool-flow-region-AE-asn-AS15802                              # UAE, specific ASN
USERNAME-pool-flow-region-US-sid-a1b2c3d4-ttl-30                      # US IP, held for 30 minutes
```

## Minimal working examples

```bash
# HTTP proxy
curl -x proxy.eproxies.net:23333 -U "USERNAME-pool-flow-region-US:PASSWORD" https://ipinfo.io

# SOCKS5 proxy (same port)
curl -x socks5://USERNAME-pool-flow-region-US:PASSWORD@proxy.eproxies.net:23333 https://ipinfo.io
```

```python
import requests

proxy_url = "http://USERNAME-pool-flow-region-US:PASSWORD@proxy.eproxies.net:23333"
proxies = {"http": proxy_url, "https": proxy_url}
print(requests.get("https://ipinfo.io", proxies=proxies, timeout=30).json())
```

```javascript
const { HttpsProxyAgent } = require("https-proxy-agent");
const axios = require("axios");

const agent = new HttpsProxyAgent(
  "http://USERNAME-pool-flow-region-US:PASSWORD@proxy.eproxies.net:23333"
);
axios.get("https://ipinfo.io", { httpsAgent: agent }).then((r) => console.log(r.data));
```

## Whitelist mode (no-credential extraction)

Once your exit IP is whitelisted, GET a list of `IP:port` proxies and connect directly — no credentials. The whitelist itself can also be managed via API:

```bash
# Extract: count is required; country=country code/Global; protocol=http|socks5; format=txt|json;
#          session=sticky|random; separator=crlf|br|cr|lf|tab (or st=custom separator)
curl "https://api.eproxies.net/gateway_api/extract_ip?count=10&country=US&protocol=http&format=json&session=sticky"

# Whitelist management (userKeyValue = user key, available in the dashboard)
curl "https://api.eproxies.net/gateway_api/add-ip?userName=USERNAME&userKeyValue=USER_KEY&ipAddress=203.0.113.10"
curl "https://api.eproxies.net/gateway_api/del-ip?userName=USERNAME&userKeyValue=USER_KEY&ipAddress=203.0.113.10"
curl "https://api.eproxies.net/gateway_api/lists-ip?userName=USERNAME&userKeyValue=USER_KEY"

# Supported country list
curl "https://api.eproxies.net/gateway_api/country-list"
```

See [API Extraction](https://www.eproxies.io/docs/usage/api-extraction) for details.

## Key facts

* Credentials activate immediately after purchase; when traffic runs out, top up and **keep the same credentials with zero downtime**.
* Unused traffic remains available for the rest of the plan's validity period.
* To switch IPs mid-session in sticky mode: change the `sid`.
* City-level targeting costs nothing extra.
* The service is available only outside mainland China.
* Support: [Telegram](https://t.me/eproxies) / [Discord](https://discord.gg/yzZNxN75) (24/7), email `support@eproxies.io`.

---

# SOCKS5 Proxies
URL: https://www.eproxies.io/docs/products/socks5

Dedicated IPs with full SOCKS5 protocol support (TCP + UDP), billed by IP count with no expiration — ideal for gaming, streaming, VoIP, and multi-account management where UDP or a long-term fixed exit is required.

## Specifications

| Item | Value |
| --- | --- |
| Protocol | Full SOCKS5 (TCP and UDP) |
| IPs | Dedicated, never shared with other users |
| Coverage | 195+ countries and regions |
| Billing | By number of IPs, no expiration |
| Anonymity | No traffic header modification, no application-layer parsing |

## SOCKS5 vs. HTTP proxies

HTTP proxies only handle HTTP/HTTPS traffic. SOCKS5 works at a lower network layer, can forward any TCP/UDP traffic, and adds no headers to requests, offering stronger anonymity. UDP-dependent applications (online gaming, video streaming, VoIP, DNS queries) require SOCKS5.

## Purchasing

SOCKS5 plans are arranged via [Telegram](https://t.me/eproxies), with volume discounts at scale — enterprise tiers go up to hundreds of thousands of IPs. Current tier pricing is on the [pricing page](https://www.eproxies.io/pricing).

## Usage

```bash
# cURL over SOCKS5
curl -x socks5://USERNAME:PASSWORD@proxy.eproxies.net:23333 https://ipinfo.io
```

```python
# Python requests over SOCKS5 (requires: pip install requests[socks])
import requests

proxy_url = "socks5://USERNAME:PASSWORD@proxy.eproxies.net:23333"
proxies = {"http": proxy_url, "https": proxy_url}
print(requests.get("https://ipinfo.io", proxies=proxies, timeout=30).json())
```

For GUI tools such as browsers, antidetect browsers, and Proxifier, see the [integration guides](https://www.eproxies.io/docs/integrations/antidetect-browsers).

## FAQ

**Can SOCKS5 proxies be used with any application?**
Almost any application that supports proxy configuration: browsers, download managers, gaming platforms, messaging apps, and custom software.

**Is UDP supported?**
Yes — it is one of the core strengths of the SOCKS5 product, covering UDP scenarios like gaming, video streaming, VoIP, and DNS queries.

---

# Code Examples
URL: https://www.eproxies.io/docs/usage/code-examples

All examples use credential mode. Replace `USERNAME` and `PASSWORD` with the credentials from the dashboard's Proxy Settings page and they run as-is. For username parameters, see the [syntax reference](https://www.eproxies.io/docs/usage/username-syntax).

## cURL

```bash
# HTTP proxy
curl -x proxy.eproxies.net:23333 -U "USERNAME-pool-flow-region-US:PASSWORD" https://ipinfo.io

# SOCKS5 proxy (same port)
curl -x socks5://USERNAME-pool-flow-region-US:PASSWORD@proxy.eproxies.net:23333 https://ipinfo.io
```

## Python (requests)

```python
import requests

proxy_url = "http://USERNAME-pool-flow-region-US:PASSWORD@proxy.eproxies.net:23333"
proxies = {"http": proxy_url, "https": proxy_url}

response = requests.get("https://ipinfo.io", proxies=proxies, timeout=30)
print(response.json())
```

For SOCKS5: change `http://` to `socks5://` and install the extra: `pip install "requests[socks]"`.

## Node.js (axios)

```javascript
const axios = require("axios");
const { HttpsProxyAgent } = require("https-proxy-agent");

const agent = new HttpsProxyAgent(
  "http://USERNAME-pool-flow-region-US:PASSWORD@proxy.eproxies.net:23333"
);

axios
  .get("https://ipinfo.io", { httpsAgent: agent, timeout: 30000 })
  .then((res) => console.log(res.data))
  .catch((err) => console.error(err.message));
```

## Java (OkHttp)

```java
import java.net.InetSocketAddress;
import java.net.Proxy;
import okhttp3.Credentials;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public class EProxiesDemo {
    public static void main(String[] args) throws Exception {
        Proxy proxy = new Proxy(Proxy.Type.HTTP,
                new InetSocketAddress("proxy.eproxies.net", 23333));

        OkHttpClient client = new OkHttpClient.Builder()
                .proxy(proxy)
                .proxyAuthenticator((route, response) -> {
                    String credential = Credentials.basic(
                            "USERNAME-pool-flow-region-US", "PASSWORD");
                    return response.request().newBuilder()
                            .header("Proxy-Authorization", credential)
                            .build();
                })
                .build();

        Request request = new Request.Builder().url("https://ipinfo.io").build();
        try (Response response = client.newCall(request).execute()) {
            System.out.println(response.body().string());
        }
    }
}
```

## Go

```go
package main

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

func main() {
	proxyURL, _ := url.Parse(
		"http://USERNAME-pool-flow-region-US:PASSWORD@proxy.eproxies.net:23333")

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

	resp, err := client.Get("https://ipinfo.io")
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}
```

## PHP (cURL)

```php
<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://ipinfo.io");
curl_setopt($ch, CURLOPT_PROXY, "proxy.eproxies.net:23333");
curl_setopt($ch, CURLOPT_PROXYUSERPWD, "USERNAME-pool-flow-region-US:PASSWORD");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$result = curl_exec($ch);
curl_close($ch);
echo $result;
```

> The dashboard's Code Examples page also offers C/C++ versions, plus step-by-step GUI setup guides for Chrome, Edge, Firefox, and Safari as well as Android and iOS — with your real credentials filled in automatically.

## Verification & troubleshooting

* Use `https://ipinfo.io` to confirm the exit IP and targeting match expectations.
* Getting 407: check that the username contains `-pool-flow` and the credentials are correct.
* Timeouts: strip the targeting parameters and test basic connectivity with `USERNAME-pool-flow`, then add parameters back one at a time to isolate the issue.
* For automation frameworks (Selenium / Puppeteer / Playwright / Scrapy), see [Automation Frameworks](https://www.eproxies.io/docs/integrations/automation-frameworks).

---

# Geo-Targeting
URL: https://www.eproxies.io/docs/usage/geo-targeting

EProxies supports targeting at four levels: country → state/province → city, plus independent ASN (carrier) targeting. All targeting is free of charge.

## Country targeting

Append `-region-{country code}` to the username, using ISO 3166-1 two-letter codes:

```bash
curl -x proxy.eproxies.net:23333 -U "USERNAME-pool-flow-region-JP:PASSWORD" https://ipinfo.io
```

Common country codes: `US` United States, `GB` United Kingdom, `DE` Germany, `FR` France, `JP` Japan, `CA` Canada, `AU` Australia, `BR` Brazil, `IN` India, `SG` Singapore, `VN` Vietnam, `NL` Netherlands. The full supported list is in the country selector on the dashboard's Proxy Settings page.

## State and city targeting

```bash
# State level
curl -x proxy.eproxies.net:23333 -U "USERNAME-pool-flow-region-US-state-California:PASSWORD" https://ipinfo.io

# City level (city must appear together with state)
curl -x proxy.eproxies.net:23333 -U "USERNAME-pool-flow-region-US-state-California-city-losangeles:PASSWORD" https://ipinfo.io
```

Formatting rules:

* `state` uses the full name, capitalized, e.g. `California`, `Texas`
* `city` is all lowercase with spaces removed: Los Angeles becomes `losangeles`, New York becomes `newyork`
* Use the city names listed in the dashboard's city selector — it generates the correct spelling automatically

> `city` cannot be used without `state`, or the gateway may reject the targeting. The dashboard builder avoids this class of spelling mistakes.

## ASN targeting

Target by carrier network — useful when you need exits from a specific ISP (e.g. local carrier verification):

```bash
curl -x proxy.eproxies.net:23333 -U "USERNAME-pool-flow-region-AE-asn-AS15802:PASSWORD" https://ipinfo.io
```

* Format is `AS` + digits
* ASN targeting is **mutually exclusive** with `state`/`city` and combines only with `region`

## Verifying your targeting

Request `https://ipinfo.io` and check the `country`, `region`, `city`, and `org` fields in the returned JSON:

```json
{
  "ip": "203.0.113.10",
  "city": "Los Angeles",
  "region": "California",
  "country": "US",
  "org": "AS7018 AT&T Services, Inc."
}
```

> Occasional geolocation-database mismatches are normal for residential IPs. Sample several requests to see the distribution, or use a [sticky session](https://www.eproxies.io/docs/usage/session-control) to pin an IP that meets your requirements.

---

# Residential Proxies
URL: https://www.eproxies.io/docs/products/residential

Rotating residential IPs from real devices worldwide — the go-to product for data collection, ad verification, market research, and AI training data acquisition, and currently the only product available for **self-service purchase on the website**.

## Specifications

| Item | Value |
| --- | --- |
| IP pool | 72M+ real residential IPs |
| Coverage | 195+ countries and regions, with state/city-level targeting |
| Protocols | HTTP / HTTPS / SOCKS5 (same port, `23333`) |
| Rotation | Per-request by default; sticky sessions hold the same IP for 1–120 minutes |
| Average response | < 0.6 s |
| Billing | By traffic (GB); unused traffic remains available within the validity period |

## Purchasing

Pick a traffic tier on the [pricing page](https://www.eproxies.io/pricing) or use the slider for a custom amount; credentials activate instantly after payment. Current tiers and unit prices are listed on the pricing page — larger packages get lower per-GB rates, and enterprise volumes can [contact sales](https://www.eproxies.io/company/contact) for custom quotes.

When traffic runs out, top up any time: **credentials stay the same and your workloads keep running**.

## Usage

After purchase, get your username and password from the Proxy Settings page in the dashboard, then control targeting and sessions through username parameters:

```bash
# US IP, rotating per request
curl -x proxy.eproxies.net:23333 -U "USERNAME-pool-flow-region-US:PASSWORD" https://ipinfo.io

# Los Angeles, California, same IP held for 30 minutes
curl -x proxy.eproxies.net:23333 -U "USERNAME-pool-flow-region-US-state-California-city-losangeles-sid-a1b2c3d4-ttl-30:PASSWORD" https://ipinfo.io
```

- [Username Parameter Syntax](https://www.eproxies.io/docs/usage/username-syntax)
- [Code Examples](https://www.eproxies.io/docs/usage/code-examples)
## FAQ

**How does IP rotation work?**
By default every connection request is assigned a new IP. To keep a session, use the sticky session parameters (`-sid-...-ttl-...`) to hold the same IP for 1–120 minutes. See [Session Control](https://www.eproxies.io/docs/usage/session-control).

**Can I target a specific country or city?**
Yes — country, state, and city-level targeting, plus ASN targeting, at no extra cost. See [Geo-Targeting](https://www.eproxies.io/docs/usage/geo-targeting).

**How do I switch protocols?**
HTTP, HTTPS, and SOCKS5 share the same gateway and port. Whichever protocol your client connects with takes effect — no configuration needed.

---

# API Extraction (Whitelist Mode)
URL: https://www.eproxies.io/docs/usage/api-extraction

In whitelist mode, you extract batches of `IP:port` proxies via an HTTP GET request and connect to them directly — no credentials. The whitelist itself can also be managed via API, so the entire workflow can be fully programmatic.

## Prerequisites

1. An active Residential Proxies plan.
2. Your server's exit IP added to the whitelist (via the dashboard's Whitelist page, or the whitelist management API below).

## Extraction endpoint

```
GET https://api.eproxies.net/gateway_api/extract_ip
```

| Parameter | Required | Values | Description |
| --- | --- | --- | --- |
| `count` | Yes | Number | Number of proxies per extraction |
| `country` | No | Country code / `Global` | Region, e.g. `US`; `Global` means any country |
| `protocol` | No | `http` / `socks5` | Proxy protocol |
| `format` | No | `txt` / `json` | Response format |
| `session` | No | `sticky` / `random` | IP type: `sticky` (reuses the same batch of IPs) / `random` |
| `separator` | No | `crlf` / `br` / `cr` / `lf` / `tab` | Line separator for txt format: `\r\n`, `</br>`, `\r`, `\n`, `\t` |
| `st` | No | Custom string | Custom separator (used instead of `separator`) |

Examples:

```bash
# Extract 10 US HTTP proxies, JSON format, sticky IPs
curl "https://api.eproxies.net/gateway_api/extract_ip?count=10&country=US&protocol=http&format=json&session=sticky"

# Extract 5 SOCKS5 proxies from random countries, txt format, one per line
curl "https://api.eproxies.net/gateway_api/extract_ip?count=5&protocol=socks5&format=txt&separator=lf&session=random"
```

With `format=json`, the response is an array of objects, each with an `ipAddress` and a `portValue` field:

```json
[
  { "ipAddress": "203.0.113.10", "portValue": 23333 },
  { "ipAddress": "203.0.113.11", "portValue": 23333 }
]
```

```python
import requests

resp = requests.get(
    "https://api.eproxies.net/gateway_api/extract_ip",
    params={"count": 10, "country": "US", "protocol": "http",
            "format": "json", "session": "sticky"},
    timeout=30,
)
proxy_list = resp.json()

# Connect to the extracted proxies directly, no credentials needed
first = proxy_list[0]
endpoint = f"{first['ipAddress']}:{first['portValue']}"
proxies = {"http": f"http://{endpoint}", "https": f"http://{endpoint}"}
print(requests.get("https://ipinfo.io", proxies=proxies, timeout=30).json())
```

The list of extractable countries (returns the `country` code, `name`, and `flag_url` flag icon):

```
GET https://api.eproxies.net/gateway_api/country-list
```

> Extraction requests must come from a whitelisted IP or they will be rejected. The dashboard's API Extraction page provides a visual link builder.

## Whitelist management API

Whitelist entries can be added, removed, and listed purely via API — useful for maintaining the whitelist automatically when your exit IP changes. All three endpoints authenticate with `userName` (your username) + `userKeyValue` (your user key, available in the dashboard):

```bash
# Add a whitelist IP
curl "https://api.eproxies.net/gateway_api/add-ip?userName=USERNAME&userKeyValue=USER_KEY&ipAddress=203.0.113.10"

# Remove a whitelist IP
curl "https://api.eproxies.net/gateway_api/del-ip?userName=USERNAME&userKeyValue=USER_KEY&ipAddress=203.0.113.10"

# List current whitelist entries
curl "https://api.eproxies.net/gateway_api/lists-ip?userName=USERNAME&userKeyValue=USER_KEY"
```

Typical automation flow (for environments without a fixed exit IP):

```python
import requests

BASE = "https://api.eproxies.net/gateway_api"
AUTH = {"userName": "USERNAME", "userKeyValue": "USER_KEY"}

# 1. Get this machine's current exit IP
my_ip = requests.get("https://ipinfo.io/json", timeout=30).json()["ip"]

# 2. Add it to the whitelist
requests.get(f"{BASE}/add-ip", params={**AUTH, "ipAddress": my_ip}, timeout=30)

# 3. Extract proxies and use them
proxies = requests.get(
    f"{BASE}/extract_ip",
    params={"count": 10, "country": "US", "protocol": "http",
            "format": "json", "session": "random"},
    timeout=30,
).json()
print(proxies)
```

## Credential mode vs. extraction mode

| | Credential mode | API extraction (whitelist) |
| --- | --- | --- |
| Targeting granularity | Country/state/city/ASN | Country |
| Session control | Fine-grained via sid/ttl | `session=sticky/random` per batch |
| Applicability | Software must support proxy auth | Any proxy-capable software |
| Best for | Code integrations, fine-grained collection | Legacy tools, bulk distribution, auth-free environments |

## OpenAPI Specification

A machine-readable definition of every endpoint on this page is available at [openapi.json](https://www.eproxies.io/docs/openapi.json) — import it into Postman / Swagger UI, or load it from an AI agent.

---

# Authentication
URL: https://www.eproxies.io/docs/usage/authentication

EProxies supports two authentication methods. Choose whichever fits your network environment — both can be used at the same time.

## Method 1: Username/password authentication (recommended)

Send a username and password with each proxy request. Works in any network environment and supports geo-targeting and session control via [username parameters](https://www.eproxies.io/docs/usage/username-syntax).

```bash
curl -x proxy.eproxies.net:23333 -U "USERNAME-pool-flow:PASSWORD" https://ipinfo.io
```

* Find your username and password on the dashboard's Proxy Settings page.
* The username body must be followed by the `-pool-flow` pool identifier, then any targeting/session parameters as needed.
* The password is always used as-is; all parameters are appended to the username.

## Method 2: IP whitelist authentication

Add your server's exit IP to the whitelist, then use [API extraction](https://www.eproxies.io/docs/usage/api-extraction) to fetch a list of `IP:port` proxies you can connect to directly — no username or password. Ideal for servers with a fixed exit IP and for software that cannot be configured with proxy authentication.

**Setup steps**

1. Log in to the dashboard and open the Whitelist page.
2. Click "Add current IP" (the page auto-detects your exit IP), or manually enter another server's IP.
3. Once the whitelist is active, use links generated on the API Extraction page to fetch proxy lists.

> Whitelist entries can be enabled/disabled or deleted at any time. If your server's exit IP changes, update the whitelist — otherwise the extracted proxies will refuse connections.

## Comparing the two methods

| | Username/password | IP whitelist |
| --- | --- | --- |
| Environment | Any (including dynamic exit IPs) | Servers with a fixed exit IP |
| Targeting/session control | Username parameters, finest granularity | Extraction link parameters |
| Integration effort | Requires proxy-auth support | No auth, maximum compatibility |
| Typical scenarios | Code integrations, antidetect browsers | Legacy software, tools without auth support |

---

# Session Control
URL: https://www.eproxies.io/docs/usage/session-control

Residential Proxies have two session modes: rotating (default) and sticky. You switch modes purely through username parameters — no dashboard settings involved.

## Rotating mode (default)

Without session parameters, **every connection request is assigned a new IP**:

```bash
curl -x proxy.eproxies.net:23333 -U "USERNAME-pool-flow-region-US:PASSWORD" https://ipinfo.io
# Run it twice in a row and you get two different IPs
```

Best for: data collection, price monitoring, ad verification — anywhere you want each request to come from a different IP.

## Sticky mode

Append `-sid-{8-char random}-ttl-{minutes}`; the same `sid` reuses the same IP for the duration of `ttl`:

```bash
curl -x proxy.eproxies.net:23333 -U "USERNAME-pool-flow-region-US-sid-a1b2c3d4-ttl-30:PASSWORD" https://ipinfo.io
# Repeat requests with the same sid within 30 minutes return the same IP
```

| Parameter | Description |
| --- | --- |
| `sid` | Session ID: 8 random alphanumeric characters, generated by you; each sid is an independent session |
| `ttl` | IP hold time in minutes, **1–120** |

Best for: account logins, multi-step forms, checkout flows — anything that needs session persistence.

## Session management tips

**Rotate on demand**: switch to a new `sid` to get a new IP immediately, without waiting for the ttl to expire.

**Parallel sessions**: different `sid`s are fully independent, so you can hold any number of fixed-IP sessions in parallel:

```python
import random, string, requests

def make_session_proxy(country: str) -> dict:
    sid = "".join(random.choices(string.ascii_lowercase + string.digits, k=8))
    url = (
        f"http://USERNAME-pool-flow-region-{country}-sid-{sid}-ttl-30:PASSWORD"
        "@proxy.eproxies.net:23333"
    )
    return {"http": url, "https": url}

# 10 independent sticky-IP sessions in the US
sessions = [make_session_proxy("US") for _ in range(10)]
for proxies in sessions:
    print(requests.get("https://ipinfo.io", proxies=proxies, timeout=30).json()["ip"])
```

> Residential IPs come from real devices, so a device going offline during a sticky session can cause an IP change. For reliability-critical flows, verify the exit IP at the application level.

---

# Username Parameter Syntax
URL: https://www.eproxies.io/docs/usage/username-syntax

In credential mode, all geo-targeting and session control is done by appending parameters to the username — the password never changes. This page is the complete syntax reference.

## Structure

```
{account}-pool-flow[-region-{country code}][-state-{state}][-city-{city}][-asn-{ASN}][-sid-{8-char random}-ttl-{minutes}]
```

Left to right: account body → pool identifier (always `-pool-flow`) → geo-targeting parameters → session parameters. **The order is fixed and cannot be rearranged.**

## Parameters

| Parameter | Format | Description |
| --- | --- | --- |
| `-pool-flow` | Fixed value | Residential pool identifier, required in credential mode |
| `-region-{CC}` | ISO two-letter country code | Country targeting, e.g. `US`, `GB`, `JP`, `AE`; free in all cases |
| `-state-{State}` | State/province name | Must be used together with `region`, e.g. `California` |
| `-city-{city}` | City name, lowercase, no spaces | **Must be used together with `state`**, e.g. `losangeles`, `newyork` |
| `-asn-{ASN}` | `AS` + digits | ASN (carrier network) targeting, e.g. `AS15802`; **mutually exclusive with state/city**, combine with region only |
| `-sid-{seed}` | 8 random alphanumeric characters | Sticky session ID; the same sid reuses the same IP, a new sid gets a new IP |
| `-ttl-{n}` | Integer, 1–120 | Sticky session hold time in minutes; always paired with `sid` |

## Combination rules

* Rotation only, no targeting: `USERNAME-pool-flow`
* Targeting refines step by step: region → region+state → region+state+city
* ASN targeting cannot be combined with state/city
* Sticky session parameters always come last
* Without `sid`/`ttl`, the default applies: **a new IP on every request**

## Full examples

```bash
# 1. Global random IP, rotating per request
curl -x proxy.eproxies.net:23333 -U "USERNAME-pool-flow:PASSWORD" https://ipinfo.io

# 2. Specific country (US)
curl -x proxy.eproxies.net:23333 -U "USERNAME-pool-flow-region-US:PASSWORD" https://ipinfo.io

# 3. Down to state level (California, US)
curl -x proxy.eproxies.net:23333 -U "USERNAME-pool-flow-region-US-state-California:PASSWORD" https://ipinfo.io

# 4. Down to city level (Los Angeles, California, US)
curl -x proxy.eproxies.net:23333 -U "USERNAME-pool-flow-region-US-state-California-city-losangeles:PASSWORD" https://ipinfo.io

# 5. ASN targeting (UAE, AS15802)
curl -x proxy.eproxies.net:23333 -U "USERNAME-pool-flow-region-AE-asn-AS15802:PASSWORD" https://ipinfo.io

# 6. Country + sticky session (same US IP held for 30 minutes)
curl -x proxy.eproxies.net:23333 -U "USERNAME-pool-flow-region-US-sid-a1b2c3d4-ttl-30:PASSWORD" https://ipinfo.io

# 7. City-level targeting + sticky session
curl -x proxy.eproxies.net:23333 -U "USERNAME-pool-flow-region-US-state-California-city-losangeles-sid-a1b2c3d4-ttl-30:PASSWORD" https://ipinfo.io
```

> Not sure how to compose the parameters? The dashboard's Proxy Settings page has a visual builder: pick a country/state/city/session type and it generates the complete username in real time — just copy it. The supported country and city lists are also searchable there.

## Common errors

| Symptom | Cause | Fix |
| --- | --- | --- |
| Authentication failed (407) | Username typo or missing `-pool-flow` | Verify with the dashboard builder |
| City targeting not applied | `city` used without `state` | Add `-state-{state}` |
| ASN targeting not applied | Mixed with `state`/`city` | ASN combines with `region` only |
| IP keeps changing | No sticky session in use | Append `-sid-{8 chars}-ttl-{minutes}` |

---

# Registration & Login
URL: https://www.eproxies.io/docs/account/register-and-login

## Registration

1. Open [dashboard.eproxies.io](https://dashboard.eproxies.io) and click "Sign up".
2. Register with an email address, or use **one-click Google sign-in**.
3. Registration is free with no credit card required; new accounts include trial traffic so you can validate performance and compatibility before buying.

## Login

Go to [dashboard.eproxies.io](https://dashboard.eproxies.io) and enter your email and password, or sign in with Google. The login session is shared with the main website under the `eproxies.io` domain, so you can also enter the dashboard from the top-right corner of the website.

## Dashboard overview

| Module | Features |
| --- | --- |
| Overview | Traffic usage, balance, 30-day usage chart, quick-start code |
| Proxy Settings | View credentials, visual username parameter builder, country/city lists |
| Whitelist | Whitelist IP management, API extraction link builder |
| Subscriptions/Orders | Plan management, order history |
| Sub-Accounts | Create sub-accounts, allocate traffic ([details](https://www.eproxies.io/docs/account/sub-accounts-and-cdk)) |
| My Account | Email, password, and account information |

## FAQ

**Not receiving the verification email?**
Check your spam folder; if it still has not arrived, contact us via [Telegram](https://t.me/eproxies) or `support@eproxies.io`.

**Forgot your password?**
Click "Forgot password" on the login page and reset it via your registered email.

**Can I create multiple accounts?**
For team collaboration, use [sub-accounts](https://www.eproxies.io/docs/account/sub-accounts-and-cdk) instead of registering multiple main accounts — sub-accounts get independent traffic allocations and credentials while keeping billing centralized.

---

# Other Software
URL: https://www.eproxies.io/docs/integrations/other-software

Configuration guides for browsers and common proxy tools. Every tool uses the same details: host `proxy.eproxies.net`, port `23333`, username `USERNAME-pool-flow` (targeting/session parameters optional), password unchanged.

## Browsers

### Chrome / Edge

A system-level proxy affects all traffic, so an extension (a SwitchyOmega-style proxy switcher) is recommended for on-demand switching:

1. Create a new profile; choose **HTTP** or **SOCKS5** as the protocol.
2. Server `proxy.eproxies.net`, port `23333`.
3. On your first page visit an authentication prompt appears — enter your username and password.

### Firefox

Firefox has its own independent proxy settings:

1. Go to Settings → Network Settings → Manual proxy configuration.
2. Enter `proxy.eproxies.net` as the HTTP/HTTPS proxy or SOCKS host, port `23333`; for SOCKS choose **v5**.
3. Enter your username and password when prompted while browsing.

> The dashboard's Code Examples page includes step-by-step, screenshot-based guides for Chrome (Windows/Mac), Edge, Firefox, Safari, Android, and iOS — with your credentials filled in automatically.

## Proxifier

Force software without native proxy settings through the proxy:

1. **Profile → Proxy Servers → Add**.
2. Address `proxy.eproxies.net`, Port `23333`, Protocol **SOCKS5**.
3. Enable **Authentication** and enter your username (including `-pool-flow` and any parameters) and password.
4. Once **Check** passes, save, then configure Rules to choose which programs go through the proxy.

## Clash / ClashX

Add a node to your configuration file:

```yaml
proxies:
  - name: "EProxies-US"
    type: socks5
    server: proxy.eproxies.net
    port: 23333
    username: USERNAME-pool-flow-region-US
    password: PASSWORD
```

## Telegram

1. Go to Settings → Data and Storage → Proxy → Add Proxy.
2. Choose **SOCKS5** and enter server `proxy.eproxies.net`, port `23333`, username, and password.
3. Save and connect.

> Universal troubleshooting rule: whenever configuration fails in any software, first verify credential connectivity with [cURL](https://www.eproxies.io/docs/usage/code-examples) on the same machine. If cURL works, the problem is in how the software was filled in (nine times out of ten it is a username parameter typo); if cURL fails, check your [account status](https://www.eproxies.io/docs/account/billing-and-payments) and local network.

---

# Static Residential Proxies
URL: https://www.eproxies.io/docs/products/static-residential

Fixed residential IPs allocated by real ISPs: residential-grade trust with datacenter-grade speed. The IP stays the same for the entire validity period — built for use cases that need a persistent identity.

## Specifications

| Item | Value |
| --- | --- |
| IP source | Residential IPs allocated by real ISPs, not datacenter ranges |
| Validity | 1 / 7 / 30 days, renewable to keep the same IP |
| Traffic | Unlimited; billed per IP |
| Protocols | HTTP / HTTPS / SOCKS5 |
| Coverage | 195+ countries and regions |

## Use cases

* **Multi-account management** — bind each account to a fixed residential identity and avoid risk-control triggers from changing IPs.
* **E-commerce operations** — run store backends through the same exit long-term to reduce detection.
* **Ad verification** — continuously audit ad delivery from a fixed regional identity.
* **Social media operations** — a stable login environment for account matrices across platforms.

## Purchasing & usage

Purchase entry and current pricing are on the [product page](https://www.eproxies.io/products/static-residential-proxies). Once activated, get your IP list and credentials from the dashboard and connect directly via `IP:port` over HTTP/HTTPS/SOCKS5.

> Static Residential Proxies use fixed IPs and do not use the dynamic `-pool-flow` username syntax; location is chosen by country/city at purchase time.

## FAQ

**Static or rotating residential — which should I choose?**
If you need "one identity, always online" (account warming, storefronts, ad accounts), choose static. If you need "many different rotating IPs" (scraping, verification, price comparison), choose rotating Residential Proxies.

**Does the IP change when the plan expires?**
Renew before expiration to keep the same IP; once expired without renewal, the IP is released.

---

# Purchases & Payments
URL: https://www.eproxies.io/docs/account/billing-and-payments

## Purchase flow

1. Choose a product and tier on the [pricing page](https://www.eproxies.io/pricing) (Residential Proxies support custom traffic amounts via a slider).
2. Pick a payment method at checkout; coupons are supported.
3. **Credentials activate as soon as payment is confirmed** and appear in the dashboard within seconds.

Unlimited Residential and SOCKS5 plans are arranged via [Telegram](https://t.me/eproxies) rather than online checkout.

## Payment methods

| Method | Notes |
| --- | --- |
| Cryptocurrency | USDT (TRC20 / ERC20), BTC, ETH, TRX, LTC — fast and anonymous |
| Alipay | CNY / HKD settlement, real-time confirmation via QR code |
| Credit card | Visa / Mastercard through a PCI-DSS-compliant channel, with 3-D Secure as required by the issuer |

EProxies adds no surcharge to any payment method; any network/channel fees are shown transparently at checkout before you confirm. All transactions use 256-bit SSL encryption, and no financial data is stored on our servers. Step-by-step guides per method: [Cryptocurrency](https://www.eproxies.io/buy/crypto) · [USDT](https://www.eproxies.io/buy/usdt) · [Alipay](https://www.eproxies.io/buy/alipay) · [Credit card](https://www.eproxies.io/buy/credit-card)

## Billing rules

* **Residential Proxies** are billed by traffic (GB); unused traffic remains available within the plan's validity period, and topping up after running out keeps the same credentials.
* **Upgrades** can be done in the dashboard any time — pay only the difference, effective immediately. **Downgrades** take effect at the next billing cycle.
* Enterprise customers can contact sales for volume discounts, SLA guarantees, and a dedicated account manager.

## Refund policy

* Refunds are available within **3 days** of purchase if **less than 20%** of the plan's resources have been used.
* To apply: email `support@eproxies.io` with your **order number** and the reason; review takes 3–5 business days.
* Approved refunds go back to the original payment method within 5–10 business days; crypto payments are refunded in USDT at the current exchange rate.
* Not refundable: custom enterprise plans, activation/setup fees, and orders with more than 20% usage.
* For trial accounts upgraded to paid, the policy applies from the upgrade date.

Full terms are in the [refund policy](https://www.eproxies.io/legal/refund) on the website.

## FAQ

**How long until my payment is credited?**
Cryptocurrency depends on on-chain confirmation (BTC roughly 10–30 minutes, TRX/TRC20 typically a few minutes); Alipay and credit cards confirm in real time. The plan activates as soon as payment is confirmed.

**How do I get an invoice?**
Email `support@eproxies.io` with your order number.

**Payment made but the order has not arrived?**
Check the order status on the dashboard's Orders page. If the payment platform shows success but the order is not active, send the order number to support on [Telegram](https://t.me/eproxies).

---

# Sub-Accounts & CDK
URL: https://www.eproxies.io/docs/account/sub-accounts-and-cdk

Two distribution features for teams and resellers: sub-accounts for internal allocation, and CDK for external distribution and redemption.

## Sub-accounts

A main account can create multiple sub-accounts, each with its **own proxy credentials** and its **own traffic quota**, purchased and allocated centrally by the main account.

Typical scenarios:

* **Team collaboration** — each member or business line uses its own sub-account, so usage never interferes and the main account keeps a single view of the books.
* **Client isolation** — service providers give each client independent credentials, allocate traffic on demand, and can adjust or disable them at any time.

How to: dashboard Sub-Accounts page → create a sub-account → allocate traffic → hand the sub-account credentials to the user. Sub-account usernames support the full set of [targeting and session parameters](https://www.eproxies.io/docs/usage/username-syntax).

## CDK redemption

A CDK (redemption code) is a carrier for prepaid traffic: the holder enters the code at the dashboard's CDK Redemption entry and the corresponding resources are credited instantly.

* If you bought a CDK or received one from a reseller, just log in to the dashboard and redeem it — no payment method needs to be attached.
* Codes can be tied to specific country resource types; the code's own description is authoritative.

## Balance top-up

The dashboard supports topping up a balance first and then paying for plans from that balance — convenient for one payment covering multiple purchases in your books. The top-up entry is in the dashboard's Subscriptions/Balance module.

## Reseller program

EProxies runs a reseller program (regional support + bulk CDK distribution):

* Buy traffic at wholesale prices, set your own retail price, and keep the margin.
* Generate CDKs in bulk and distribute them to your customers; they redeem on their own without ever touching your main account.

Interested? Contact business development via [Telegram](https://t.me/eproxies) or `support@eproxies.io`.

---

# Unlimited Residential Proxies
URL: https://www.eproxies.io/docs/products/unlimited-residential

Residential proxies with a fixed period fee and no traffic cap, built for large-scale data collection. They share the same 72M+ residential IP pool, with speed and geo-targeting identical to the pay-per-GB product.

## Specifications

| Item | Value |
| --- | --- |
| Traffic | Unlimited traffic and concurrency, no hidden limits |
| Billing | By bandwidth tier: 100 / 200 / 400 / 1000 Mbps |
| Period | 7 or 30 days |
| IP pool | 72M+ residential IPs, 195+ countries |
| Targeting | Country/state/city level, same as the pay-per-GB product |
| Protocols | HTTP / HTTPS / SOCKS5 |

## Purchasing

Unlimited plans are not sold through online checkout — contact us on [Telegram](https://t.me/eproxies) to get set up. Current prices for each bandwidth tier are on the [pricing page](https://www.eproxies.io/pricing).

> Choosing a bandwidth tier: 100 Mbps roughly covers medium-scale continuous collection; go for 400 Mbps or above with high concurrency or heavy responses (images/video). You can start low and upgrade — you only pay the prorated difference for the remaining period.

## Usage

Connection is identical to Residential Proxies: same gateway `proxy.eproxies.net:23333`, same [username parameter syntax](https://www.eproxies.io/docs/usage/username-syntax) (targeting and sticky sessions all available).

```bash
curl -x proxy.eproxies.net:23333 -U "USERNAME-pool-flow-region-JP:PASSWORD" https://ipinfo.io
```

## FAQ

**Any limitations compared with the pay-per-GB product?**
None. Same infrastructure, same IP pool, same geo-targeting — only the billing model differs.

**Will I be throttled?**
There is no traffic-based throttling; your bandwidth ceiling is simply the tier you purchased.

**How do I upgrade tiers?**
Contact support on Telegram. Upgrades take effect immediately and are prorated for the remaining period.

---

# Antidetect Browsers
URL: https://www.eproxies.io/docs/integrations/antidetect-browsers

EProxies is compatible with all major antidetect browsers. Giving each browser profile its own proxy identity is standard practice for multi-account operations.

## Universal configuration

Every antidetect browser's proxy form is filled in the same way:

| Field | Value |
| --- | --- |
| Proxy type | HTTP or SOCKS5 |
| Host/Server | `proxy.eproxies.net` |
| Port | `23333` |
| Login/Username | `USERNAME-pool-flow` + targeting/session parameters |
| Password | Your password |

**Key technique for multi-account setups**: give each browser profile a **different `sid`** in its username so every profile gets its own stable, independent IP:

```
Profile 1: USERNAME-pool-flow-region-US-sid-aaaa1111-ttl-120
Profile 2: USERNAME-pool-flow-region-US-sid-bbbb2222-ttl-120
Profile 3: USERNAME-pool-flow-region-GB-sid-cccc3333-ttl-120
```

## Supported browsers & official tutorials

The website provides step-by-step tutorials with screenshots for each browser:

| Browser | Tutorial |
| --- | --- |
| AdsPower | [Setup guide](https://www.eproxies.io/integrations/adspower) |
| Multilogin | [Setup guide](https://www.eproxies.io/integrations/multilogin) |
| BitBrowser | [Setup guide](https://www.eproxies.io/integrations/bitbrowser) |
| GoLogin | [Setup guide](https://www.eproxies.io/integrations/gologin) |
| Dolphin Anty | [Setup guide](https://www.eproxies.io/integrations/dolphin-anty) |
| Hubstudio | [Setup guide](https://www.eproxies.io/integrations/hubstudio) |
| VMLogin | [Setup guide](https://www.eproxies.io/integrations/vmlogin) |
| Nstbrowser | [Setup guide](https://www.eproxies.io/integrations/nstbrowser) |
| MoreLogin | [Setup guide](https://www.eproxies.io/integrations/morelogin) |
| Lalicat | [Setup guide](https://www.eproxies.io/integrations/lalicat) |

## General setup flow (AdsPower as an example)

1. Create or edit a browser profile and open its proxy settings.
2. Choose **SOCKS5** (or HTTP) as the proxy type, then fill in the host, port, username, and password per the table above.
3. Click "Check proxy" and confirm the reported exit IP matches your target country.
4. Save and launch the profile, then visit `ipinfo.io` inside the browser to double-check.

> If the check fails: first verify the credentials themselves with a [cURL command](https://www.eproxies.io/docs/usage/code-examples) on your machine, then review what you entered in the browser (the most common mistakes are a missing `-pool-flow` in the username, or parameters accidentally pasted into the password field).

---

# Automation Frameworks
URL: https://www.eproxies.io/docs/integrations/automation-frameworks

Integration guides for Selenium, Puppeteer, Playwright, Scrapy, and other automation and scraping frameworks. Replace `USERNAME` and `PASSWORD` with your credentials and every example runs as-is.

## Scrapy

Enable the proxy middleware in `settings.py`, or set the proxy per request:

```python
# Option 1: global (settings.py)
HTTPPROXY_ENABLED = True

# Set the proxy for each request in your Spider
def start_requests(self):
    proxy = "http://USERNAME-pool-flow-region-US:PASSWORD@proxy.eproxies.net:23333"
    for url in self.start_urls:
        yield scrapy.Request(url, meta={"proxy": proxy})
```

Per-request rotation is the default behavior and fits Scrapy's concurrency model naturally; add a `sid` to the username when you need session-pinned IPs.

## Selenium (Python)

Chrome's command-line flags do not support authenticated proxies, so use `selenium-wire` to handle the credentials:

```python
# pip install selenium-wire
from seleniumwire import webdriver

options = {
    "proxy": {
        "http": "http://USERNAME-pool-flow-region-US:PASSWORD@proxy.eproxies.net:23333",
        "https": "http://USERNAME-pool-flow-region-US:PASSWORD@proxy.eproxies.net:23333",
    }
}

driver = webdriver.Chrome(seleniumwire_options=options)
driver.get("https://ipinfo.io")
print(driver.page_source)
driver.quit()
```

Alternatively, switch to [whitelist mode](https://www.eproxies.io/docs/usage/api-extraction): extract auth-free `IP:port` proxies and use the native `--proxy-server` flag directly.

## Puppeteer (Node.js)

```javascript
const puppeteer = require("puppeteer");

(async () => {
  const browser = await puppeteer.launch({
    args: ["--proxy-server=http://proxy.eproxies.net:23333"],
  });
  const page = await browser.newPage();
  await page.authenticate({
    username: "USERNAME-pool-flow-region-US",
    password: "PASSWORD",
  });
  await page.goto("https://ipinfo.io/json");
  console.log(await page.evaluate(() => document.body.innerText));
  await browser.close();
})();
```

## Playwright (Node.js / Python)

```javascript
// Node.js
const { chromium } = require("playwright");

(async () => {
  const browser = await chromium.launch({
    proxy: {
      server: "http://proxy.eproxies.net:23333",
      username: "USERNAME-pool-flow-region-US",
      password: "PASSWORD",
    },
  });
  const page = await browser.newPage();
  await page.goto("https://ipinfo.io/json");
  console.log(await page.textContent("body"));
  await browser.close();
})();
```

```python
# Python
from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(proxy={
        "server": "http://proxy.eproxies.net:23333",
        "username": "USERNAME-pool-flow-region-US",
        "password": "PASSWORD",
    })
    page = browser.new_page()
    page.goto("https://ipinfo.io/json")
    print(page.text_content("body"))
    browser.close()
```

## AI agents / LLM data pipelines

When driving browsers or collecting data with LLMs (LangChain tools, Browser Use, custom agents, etc.), pass the proxy configuration from any of the frameworks above. Key points:

* Give each parallel agent its own `sid` so sessions never interfere ([multi-session example](https://www.eproxies.io/docs/usage/session-control)).
* Have agents request `https://ipinfo.io` at the start of a task to verify the exit IP before doing real work.
* Full parameter syntax on one page: [Agent Cheat Sheet](https://www.eproxies.io/docs/agent-reference).

## Scraping tools

Official setup tutorials for GUI scraping tools: [Octoparse](https://www.eproxies.io/integrations/octoparse) · [Scrapy](https://www.eproxies.io/integrations/scrapy) · [ScrapeStorm](https://www.eproxies.io/integrations/scrapestorm) · [SellerSprite](https://www.eproxies.io/integrations/sellersprite) · [Helium 10](https://www.eproxies.io/integrations/helium10)