# FlashProxy Documentation

Full documentation corpus for LLM ingestion. Source: https://www.flashproxy.com/docs


---

# Introduction
Source: https://www.flashproxy.com/docs

# FlashProxy Documentation

Everything you need to start sending traffic through FlashProxy — connection details, code examples, and a guide for every product, backed by 99.98% network uptime.

## Start here

- **[Quickstart](/docs/getting-started)** — get connected in three steps.
- **[Authentication](/docs/authentication)** — how credentials work.
- **[Proxy formats](/docs/proxy-formats)** — HTTP and SOCKS5 connection strings.
- **[Rotating & sticky sessions](/docs/sessions)** — control IP rotation.
- **[Geo-targeting](/docs/geo-targeting)** — target by country, state, city, or ASN.

## Products

| Product                                                                                                 | Best for                                 |
| ------------------------------------------------------------------------------------------------------- | ---------------------------------------- |
| [Residential](/docs/products/residential)                                                               | Premium scraping with deep geo-targeting |
| [Residential Lite](/docs/products/residential-lite)                                                     | High volume on a budget                  |
| [Unlimited Residential](/docs/products/unlimited-residential)                                           | Max-scale, unmetered bandwidth           |
| [Premium Unlimited Residential](/docs/products/premium-unlimited-residential)                           | Unmetered, up to 3 Gbps, US city & ISP   |
| [Datacenter](/docs/products/datacenter)                                                                 | Speed-critical tasks                     |
| [ISP (US)](/docs/products/isp) / [ISP (EU)](/docs/products/isp-eu)                                      | Residential trust at datacenter speed    |
| [IPv6 Residential](/docs/products/ipv6-residential) / [IPv6 Datacenter](/docs/products/ipv6-datacenter) | IPv6-first targets                       |
| [Mobile](/docs/products/mobile)                                                                         | Authentic 4G/5G carrier IPs              |
| [Dedicated ISP](/docs/products/dedicated-isp)                                                           | Static, identity-bound IPs               |

Need a hand? [Talk to a proxy expert](/contact).


---

# Quickstart
Source: https://www.flashproxy.com/docs/getting-started

# Quickstart

Get your first proxied request working in three steps.

## 1. Create an account

[Sign up](/auth/register) and open your dashboard.

## 2. Get your credentials

Every plan comes with a proxy **username** and **password** — FlashProxy uses Basic authentication. You'll find them on your plan's page in the dashboard. See [Authentication](/docs/authentication) for details.

## 3. Make a request

Point your client at the gateway for your product. Using Residential as an example:

```bash
curl -x "http://USERNAME:PASSWORD@adam.flashproxy.io:8080" https://api.ipify.org
```

Prefer code? The same request in Python and Node.js:

```python
import requests

proxy = "http://USERNAME:PASSWORD@adam.flashproxy.io:8080"
print(requests.get("https://api.ipify.org", proxies={"http": proxy, "https": proxy}).text)
```

```javascript
import { ProxyAgent } from 'undici';

const dispatcher = new ProxyAgent(
  'http://USERNAME:PASSWORD@adam.flashproxy.io:8080'
);
console.log(await (await fetch('https://api.ipify.org', { dispatcher })).text());
```

If it prints an IP that isn't yours, you're connected. See [Code examples](/docs/code-examples) for httpx, axios, Scrapy, Playwright, Puppeteer, and Selenium.

> **Getting a `407`?** Your username or password is wrong or stale — re-check it in the dashboard. See [Troubleshooting](/docs/troubleshooting).

## Next steps

- Choose a [session type](/docs/sessions) — rotating or sticky.
- Add [geo-targeting](/docs/geo-targeting) to control where your IPs come from.
- Browse the per-product guides for connection details and pricing.


---

# Authentication
Source: https://www.flashproxy.com/docs/authentication

# Authentication

FlashProxy uses **Basic authentication** at the gateway. Every request carries a proxy **username** and **password** — there are no API tokens or bearer auth.

## Your credentials

Each plan ships with its own `proxy_username` and `proxy_password`. Find them on your plan's page in the [dashboard](/dashboard) — copy them straight into your proxy string:

```bash
curl -x "http://USERNAME:PASSWORD@adam.flashproxy.io:8080" https://api.ipify.org
```

The same `USERNAME:PASSWORD` pair works for both HTTP and SOCKS5. See [Proxy formats](/docs/proxy-formats) for the full connection-string shapes.

## Regenerating credentials

If your credentials leak or stop working, regenerate them from the plan's page in the dashboard. The old pair stops working immediately, so update every client that uses it.

## `407 Proxy Authentication Required`

A **407** means the credentials you sent are stale or invalid — the gateway rejected the Basic auth. Re-check the username and password against the dashboard, and regenerate them if they don't match. More in [Troubleshooting](/docs/troubleshooting).

## IP allowlist (optional)

You can add an **IP allowlist** as an optional second-factor lock layered on top of `user:pass` — requests are accepted only from approved IPs. It is not a standalone method: `user:pass` is always required.

> **Note:** `user:pass` is the only primary authentication method, and it works the same way across every plan.


---

# Proxy formats
Source: https://www.flashproxy.com/docs/proxy-formats

# Proxy Formats

FlashProxy speaks **HTTP** and **SOCKS5**. Any L7 protocol — **HTTP/1.1, HTTP/2, HTTP/3, and HTTPS** — tunnels over either one, and you're free to use whichever your client speaks. The connection string always embeds your [credentials](/docs/authentication) and points at the [gateway](/docs/index) for your product.

## HTTP

```bash
http://USERNAME:PASSWORD@host:port
```

```bash
curl -x "http://USERNAME:PASSWORD@adam.flashproxy.io:8080" https://api.ipify.org
```

## SOCKS5

```bash
socks5://USERNAME:PASSWORD@host:port
```

```bash
curl -x "socks5://USERNAME:PASSWORD@dc.flashproxy.io:666" https://api.ipify.org
```

## Ports

| Product                       | HTTP port | SOCKS5 port |
| ----------------------------- | --------- | ----------- |
| Residential, Mobile           | **8080**  | **1080**    |
| Residential Lite              | **6969**  | **6969**    |
| Datacenter                    | **777**   | **666**     |
| Shared ISP (US & EU)          | **30**    | **31**      |
| IPv6 Residential              | **30**    | **31**      |
| IPv6 Datacenter               | **50**    | **51**      |
| Unlimited Residential         | **10507** | **10507**   |
| Premium Unlimited Residential | **10000** | **6969**    |

Each product page lists its exact gateway host and ports.

## SOCKS5 UDP

**SOCKS5 UDP ASSOCIATE is live** on **Datacenter, IPv6 Residential, IPv6 Datacenter, and Shared ISP** — UDP datagrams are relayed through the SOCKS5 UDP ASSOCIATE command. It's a capability of the SOCKS5 method, not a separate protocol.

> **Note:** The two proxy methods are **HTTP** and **SOCKS5**. The application-layer (L7) protocol you run over them — HTTP/1.1, HTTP/2, **HTTP/3**, or HTTPS — is your choice; FlashProxy doesn't restrict it.


---

# Rotating & sticky
Source: https://www.flashproxy.com/docs/sessions

# Rotating & Sticky Sessions

FlashProxy gives you two ways to control the IP behind your requests.

## Rotating

A **fresh IP for every request**. Best for high-volume work — scraping, crawling, price monitoring — where you want maximum IP diversity and don't care which IP serves any single request.

## Sticky

The **same IP persists across multiple requests**. Use it when a workflow has to keep one identity — logins, multi-step flows, cart sessions, account warming. **How long an IP holds depends on the product:**

- **Residential & mobile pools** (Residential, Mobile, Unlimited Residential): the IP sticks **until the device rotates off the pool** — typically **up to ~2 hours**. You don't set an exact lifetime; the pool's device availability governs it.
- **Premium Unlimited Residential**: you **set the sticky window yourself** with `time-<seconds>` (up to 24 hours) next to `session-<digits>`; after the window the session moves to a new IP (see the [product guide](/docs/products/premium-unlimited-residential)).
- **ISP (US & EU), Datacenter, and IPv6** (large shared pools): hold an IP for **as long as you need**, or **pin a specific IP from the pool** with the IP-targeting flag `-ip-0_0_0_0` in your username (see [Geo-targeting](/docs/geo-targeting)).
- **Dedicated ISP**: you **own** the IP — every request exits that same static IP. There's nothing to pin or rotate; persistence is built in.

## Which products support sticky

Most products support **both rotating and sticky**: Residential, Datacenter, Mobile, Shared ISP (US & EU), Dedicated ISP, IPv6 Residential, IPv6 Datacenter, Unlimited Residential, and Premium Unlimited Residential.

**Exception:** **Residential Lite is rotating-only** — it does not offer sticky sessions.

## When to use each

| Goal                                                 | Session type  |
| ---------------------------------------------------- | ------------- |
| Maximum IP diversity, high request volume            | Rotating      |
| Keep one identity across a multi-step flow           | Sticky        |
| Price-sensitive, high-volume jobs (Residential Lite) | Rotating only |

> **Note:** Choosing a session type is done through your connection settings — see the per-product guides and [Geo-targeting](/docs/geo-targeting) for how options combine in the username.


---

# Geo-targeting
Source: https://www.flashproxy.com/docs/geo-targeting

# Geo-Targeting

FlashProxy lets you control where your IPs come from. The depth available depends on the product.

## Targeting depth by product

| Product                                | Targeting                                         |
| -------------------------------------- | ------------------------------------------------- |
| **Residential**                        | country → state → city → **ASN** (deepest)        |
| **Mobile**                             | country, **carrier ASN**, session                 |
| **Residential Lite**                   | country only                                      |
| **Unlimited Residential**              | country only                                      |
| **Premium Unlimited Residential**      | country; or US state, city or ISP (one at a time) |
| **Datacenter**                         | country (US-only)                                 |
| **Shared ISP (US / EU)**               | country                                           |
| **IPv6 Residential / IPv6 Datacenter** | country (US-only)                                 |
| **Dedicated ISP**                      | you own specific static IPs (US, CA, UK, DE, FR, ES, PL, HK)  |

- **Residential** is the deepest: target down to city and ASN.
- **ASN / carrier targeting** is available on **Mobile** (carrier) and **Residential**.
- **Residential Lite** and **Unlimited Residential** are **country-level only**.
- **Premium Unlimited Residential** supports **country**, or a **US state, city or ISP** — one location per request (no ASN) — see its [product guide](/docs/products/premium-unlimited-residential) for the format.

## How to add targeting

Targeting parameters are encoded into your proxy **username**, alongside your session choice. Build the username in the [dashboard](/dashboard) generator for your plan, then drop it into the connection string from [Proxy formats](/docs/proxy-formats).

For the exact username encoding — parameter names, ordering, and accepted values — see the [API reference](https://rapi.flashproxy.com/docs).

## Pinning a specific IP

On **ISP, Datacenter, and IPv6** plans — the large shared pools with many IPs — you can target one exact IP instead of letting the pool choose, by adding the IP-targeting flag to your username:

```text
-ip-0_0_0_0
```

Replace `0_0_0_0` with the IP you want (dots written as underscores). This keeps the **same IP for as long as you need** — see [Rotating & sticky sessions](/docs/sessions) for how IP persistence differs across products.

> **Dedicated ISP is different:** you **own** the IP(s) on the plan, so all your traffic already exits your assigned static IP — there's nothing to pin or rotate. The `-ip-` flag is only for the shared pools above.

> **Note:** A product can only target as deep as the table above allows — asking for a city on a country-only plan won't apply. See [Troubleshooting](/docs/troubleshooting) if geo-targeting doesn't take effect.


---

# Code examples
Source: https://www.flashproxy.com/docs/code-examples

# Code examples

Connect to FlashProxy from any language or framework. Every product uses the **same** connection pattern — your **username** and **password** with your product's **host** and **port**:

```text
USERNAME:PASSWORD@HOST:PORT
```

The examples below use the **Residential** gateway (`adam.flashproxy.io:8080`). Swap in your product's host and port from its page in [Products](/docs), and replace `USERNAME` / `PASSWORD` with your plan's proxy credentials. Each example fetches your exit IP from `api.ipify.org` — if it prints an IP that isn't yours, you're connected.

> **Where do `USERNAME` / `PASSWORD` come from?** They're your **plan's** `proxy_username` and `proxy_password` — generated per plan and shown on that plan's page in the [dashboard](/dashboard). They are _not_ your FlashProxy account login. See [Authentication](/docs/authentication) for the full details.

> For **SOCKS5**, use `socks5://` and the SOCKS port instead (see [Proxy formats](/docs/proxy-formats)). For **sticky sessions** and **geo-targeting**, build the username in the dashboard generator (see [Rotating & sticky](/docs/sessions) and [Geo-targeting](/docs/geo-targeting)).

## cURL

```bash
curl -x "http://USERNAME:PASSWORD@adam.flashproxy.io:8080" https://api.ipify.org
```

## Python — requests

```python
import requests

proxy = "http://USERNAME:PASSWORD@adam.flashproxy.io:8080"
proxies = {"http": proxy, "https": proxy}

resp = requests.get("https://api.ipify.org", proxies=proxies)
print(resp.text)
```

Install with `pip install requests`.

## Python — httpx (async)

```python
import asyncio
import httpx

proxy = "http://USERNAME:PASSWORD@adam.flashproxy.io:8080"

async def main():
    async with httpx.AsyncClient(proxy=proxy) as client:
        resp = await client.get("https://api.ipify.org")
        print(resp.text)

asyncio.run(main())
```

Install with `pip install httpx`. Requires httpx **0.26+** (the `proxy=` argument); older versions use `proxies={"http://": proxy, "https://": proxy}` instead.

## Node.js — axios

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

const agent = new HttpsProxyAgent(
  'http://USERNAME:PASSWORD@adam.flashproxy.io:8080'
);

const resp = await axios.get('https://api.ipify.org', {
  httpAgent: agent,
  httpsAgent: agent,
});
console.log(resp.data);
```

Install with `npm install axios https-proxy-agent`.

## Node.js — fetch (undici)

```javascript
import { ProxyAgent } from 'undici';

const dispatcher = new ProxyAgent(
  'http://USERNAME:PASSWORD@adam.flashproxy.io:8080'
);

const resp = await fetch('https://api.ipify.org', { dispatcher });
console.log(await resp.text());
```

Node 18+ ships a global `fetch`; install the agent with `npm install undici`.

## Scrapy

Set the proxy on every request with a small downloader middleware:

```python
# middlewares.py
class FlashProxyMiddleware:
    PROXY = "http://USERNAME:PASSWORD@adam.flashproxy.io:8080"

    def process_request(self, request, spider):
        request.meta["proxy"] = self.PROXY
```

```python
# settings.py
DOWNLOADER_MIDDLEWARES = {
    "myproject.middlewares.FlashProxyMiddleware": 610,
}
```

## Playwright (Python)

```python
from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(
        proxy={
            "server": "http://adam.flashproxy.io:8080",
            "username": "USERNAME",
            "password": "PASSWORD",
        }
    )
    page = browser.new_page()
    page.goto("https://api.ipify.org")
    print(page.inner_text("body"))
    browser.close()
```

## Puppeteer (Node.js)

```javascript
import puppeteer from 'puppeteer';

const browser = await puppeteer.launch({
  args: ['--proxy-server=http://adam.flashproxy.io:8080'],
});
const page = await browser.newPage();
await page.authenticate({ username: 'USERNAME', password: 'PASSWORD' });
await page.goto('https://api.ipify.org');
console.log(await page.evaluate(() => document.body.innerText));
await browser.close();
```

## Selenium (Python)

Selenium can't pass proxy credentials directly — use **selenium-wire**:

```python
from seleniumwire import webdriver

proxy = "http://USERNAME:PASSWORD@adam.flashproxy.io:8080"
options = {"proxy": {"http": proxy, "https": proxy, "no_proxy": "localhost,127.0.0.1"}}

driver = webdriver.Chrome(seleniumwire_options=options)
driver.get("https://api.ipify.org")
print(driver.find_element("tag name", "body").text)
driver.quit()
```

Install with `pip install selenium-wire`.

## Browser (manual)

Enter the host and port in your browser's network/proxy settings; it will prompt for the username and password on first connect. For per-profile control, use an extension like FoxyProxy and add `adam.flashproxy.io:8080` with your credentials.


---

# API reference
Source: https://www.flashproxy.com/docs/api

# FlashProxy API reference

Check your balance and plans, read usage, generate proxies and extend plans from your own scripts. Every endpoint returns JSON and only reads data from your own account.

Base URL: `https://www.flashproxy.com`

Create an API key in your dashboard at https://www.flashproxy.com/dashboard/api. The full key is shown only once, so store it safely.

Using an AI agent? Give it this whole reference as one Markdown file: https://www.flashproxy.com/api-reference.md. An OpenAPI 3.1 spec is at https://www.flashproxy.com/openapi.json.

## Quickstart

List your plans, then use a plan_id from the answer in the other endpoints.

**cURL**

```bash
curl "https://www.flashproxy.com/api/v1/plans?status=active&limit=10" \
  -H "Authorization: Bearer fpk_live_YOUR_KEY"
```

**Python**

```python
import requests

response = requests.get(
    "https://www.flashproxy.com/api/v1/plans?status=active&limit=10",
    headers={
        "Authorization": "Bearer fpk_live_YOUR_KEY",
    },
    timeout=30,
)
print(response.json())
```

**Node.js**

```javascript
const response = await fetch("https://www.flashproxy.com/api/v1/plans?status=active&limit=10", {
  headers: {
    "Authorization": "Bearer fpk_live_YOUR_KEY",
  },
});
console.log(await response.json());
```

## Authentication

Send your key in the `Authorization` header as `Bearer fpk_live_…`, or in the `X-API-Key` header.

Every key can read usage. Generating proxies and extending plans each need their own permission, which you choose when you create the key. Treat a key like a password and revoke it if it leaks.

**Key permissions**

| Permission | Allows |
| --- | --- |
| `usage` | Read data used, data left and current speed. Every key has it. |
| `proxies` | Generate proxy lists. Responses contain your proxy username and password. |
| `extend` | Extend plans. Each call is paid from your account balance. |

## Account

### Current key

`GET /api/v1/key`

Returns the key you are calling with: its name, prefix and permissions. Useful when a call answers 403 FORBIDDEN.

Permission: `usage`

**Request**

```bash
curl "https://www.flashproxy.com/api/v1/key" \
  -H "Authorization: Bearer fpk_live_YOUR_KEY"
```

**Response · 200**

```json
{
  "success": true,
  "data": {
    "key_id": "7d1c2b4e-…",
    "name": "Monitoring server",
    "key_prefix": "fpk_live_k3x9q2ma",
    "permissions": [
      "usage",
      "proxies",
      "extend"
    ],
    "created_at": "2026-09-29T12:00:00.000Z",
    "last_used_at": "2026-10-13T12:00:00.000Z"
  }
}
```

### Account balance

`GET /api/v1/balance`

Returns your available account balance, the money extensions are paid from.

Permission: `usage`

**Request**

```bash
curl "https://www.flashproxy.com/api/v1/balance" \
  -H "Authorization: Bearer fpk_live_YOUR_KEY"
```

**Response · 200**

```json
{
  "success": true,
  "data": {
    "balance_usd": 42.18,
    "balance_cents": 4218,
    "currency": "USD"
  }
}
```

### List plans

`GET /api/v1/plans`

Returns your plans, newest first, with their status, expiry, data cap and whether they are extended by gb or days. Never returns proxy credentials.

Permission: `usage`

**Parameters**

| Name | In | Required | Description |
| --- | --- | --- | --- |
| `status` | query |  | all (default), active or expired. |
| `limit` | query |  | How many plans to return, up to 100. Defaults to 50. |
| `offset` | query |  | How many plans to skip, for paging. Defaults to 0. |

**Request**

```bash
curl "https://www.flashproxy.com/api/v1/plans?status=active&limit=10" \
  -H "Authorization: Bearer fpk_live_YOUR_KEY"
```

**Response · 200**

```json
{
  "success": true,
  "data": {
    "plans": [
      {
        "plan_id": "YOUR_PLAN_ID",
        "product": "residential",
        "name": "Residential Proxies",
        "status": "active",
        "billed_by": "data",
        "created_at": "2026-09-13T12:00:00.000Z",
        "expires_at": "2027-03-12T12:00:00.000Z",
        "max_bytes": 10737418240,
        "bytes_used": 4294967296,
        "speed_mbps": null,
        "extend_with": "gb"
      }
    ],
    "total": 1,
    "limit": 10,
    "offset": 0
  }
}
```

### List transactions

`GET /api/v1/transactions`

Returns your payments, top-ups and balance purchases, newest first, for bookkeeping.

Permission: `usage`

**Parameters**

| Name | In | Required | Description |
| --- | --- | --- | --- |
| `limit` | query |  | How many transactions to return, up to 100. Defaults to 50. |
| `offset` | query |  | How many transactions to skip, for paging. Defaults to 0. |

**Request**

```bash
curl "https://www.flashproxy.com/api/v1/transactions?limit=10" \
  -H "Authorization: Bearer fpk_live_YOUR_KEY"
```

**Response · 200**

```json
{
  "success": true,
  "data": {
    "transactions": [
      {
        "transaction_id": "FP-1791900000000-a1b2c3d4e",
        "type": "PURCHASE",
        "status": "COMPLETED",
        "amount_usd": 29.8,
        "payment_method": "BALANCE",
        "description": "Purchase of 1 item",
        "created_at": "2026-10-11T12:00:00.000Z",
        "completed_at": "2026-10-11T12:00:00.000Z"
      }
    ],
    "total": 1,
    "limit": 10,
    "offset": 0,
    "currency": "USD"
  }
}
```,## Usage

### Usage of all active plans

`GET /api/v1/usage`

Returns a usage record for every active plan on your account.

Permission: `usage`

**Request**

```bash
curl "https://www.flashproxy.com/api/v1/usage" \
  -H "Authorization: Bearer fpk_live_YOUR_KEY"
```

**Response · 200**

```json
{
  "success": true,
  "data": {
    "plans": [
      {
        "plan_id": "YOUR_PLAN_ID",
        "product": "ipv6-datacenter",
        "name": "IPv6 Datacenter Proxies",
        "status": "active",
        "expires_at": "2026-11-01T12:00:00.000Z",
        "usage": {
          "bytes_used": 2639963,
          "max_bytes": null,
          "remaining_bytes": null,
          "percentage_used": null
        },
        "throughput_status": "ok",
        "throughput": {
          "source": "per_minute",
          "current_mbps": 412.5,
          "avg_mbps_5m": 380.1,
          "peak_mbps_1h": 955,
          "sampled_at": "2026-10-13T11:59:15.000Z",
          "data_delay_seconds": 45,
          "limit_mbps": 1000,
          "utilization_pct": 41.25
        },
        "generated_at": "2026-10-13T12:00:00.000Z"
      }
    ]
  }
}
```

### Usage of one plan

`GET /api/v1/plans/{plan_id}/usage`

Returns the usage record of one of your plans, whatever its status.

Permission: `usage`

**Parameters**

| Name | In | Required | Description |
| --- | --- | --- | --- |
| `plan_id` | path | required | The plan ID, as returned in plan_id by List plans. |

**Request**

```bash
curl "https://www.flashproxy.com/api/v1/plans/YOUR_PLAN_ID/usage" \
  -H "Authorization: Bearer fpk_live_YOUR_KEY"
```

**Response · 200**

```json
{
  "success": true,
  "data": {
    "plan_id": "YOUR_PLAN_ID",
    "product": "ipv6-datacenter",
    "name": "IPv6 Datacenter Proxies",
    "status": "active",
    "expires_at": "2026-11-01T12:00:00.000Z",
    "usage": {
      "bytes_used": 2639963,
      "max_bytes": null,
      "remaining_bytes": null,
      "percentage_used": null
    },
    "throughput_status": "ok",
    "throughput": {
      "source": "per_minute",
      "current_mbps": 412.5,
      "avg_mbps_5m": 380.1,
      "peak_mbps_1h": 955,
      "sampled_at": "2026-10-13T11:59:15.000Z",
      "data_delay_seconds": 45,
      "limit_mbps": 1000,
      "utilization_pct": 41.25
    },
    "generated_at": "2026-10-13T12:00:00.000Z"
  }
}
```

### Usage history

`GET /api/v1/plans/{plan_id}/usage/history`

Returns a plan's traffic and speed over time, in fixed buckets (1 minute for 1h up to 4 hours for 30d), with totals, success rate and peaks. Timestamps are UTC. Available for ISP, ISP EU, Datacenter, IPv6 and Premium Unlimited plans.

Permission: `usage`

**Parameters**

| Name | In | Required | Description |
| --- | --- | --- | --- |
| `plan_id` | path | required | The plan ID, as returned in plan_id by List plans. |
| `range` | query |  | Time window: 1h, 24h, 7d, 30d. Defaults to 24h. |

**Request**

```bash
curl "https://www.flashproxy.com/api/v1/plans/YOUR_PLAN_ID/usage/history?range=24h" \
  -H "Authorization: Bearer fpk_live_YOUR_KEY"
```

**Response · 200**

```json
{
  "success": true,
  "data": {
    "plan_id": "YOUR_PLAN_ID",
    "range": "24h",
    "bucket_seconds": 900,
    "generated_at": "2026-10-13T12:00:00.000Z",
    "totals": {
      "bytes": 3221225472,
      "bytes_up": 214748364.8,
      "bytes_down": 3006477107.2,
      "connections": 48210,
      "success_pct": 99.2,
      "peak_mbps": 412.5,
      "peak_concurrent": 37
    },
    "series": [
      {
        "t": "2026-10-13T11:30:00.000Z",
        "bytes": 41943040,
        "bytes_up": 2097152,
        "bytes_down": 39845888,
        "mbps": 0.37,
        "connections_per_sec": 0.62,
        "concurrent": 12
      },
      {
        "t": "2026-10-13T11:45:00.000Z",
        "bytes": 52428800,
        "bytes_up": 3145728,
        "bytes_down": 49283072,
        "mbps": 0.47,
        "connections_per_sec": 0.71,
        "concurrent": 15
      }
    ]
  }
}
```

### Top destinations

`GET /api/v1/plans/{plan_id}/destinations`

Returns the sites a plan connected to most over a time range, with traffic, connections and success rate per host (top 100).

Permission: `usage`

**Parameters**

| Name | In | Required | Description |
| --- | --- | --- | --- |
| `plan_id` | path | required | The plan ID, as returned in plan_id by List plans. |
| `range` | query |  | Time window: 1h, 24h, 7d, 30d. Defaults to 24h. |

**Request**

```bash
curl "https://www.flashproxy.com/api/v1/plans/YOUR_PLAN_ID/destinations?range=24h" \
  -H "Authorization: Bearer fpk_live_YOUR_KEY"
```

**Response · 200**

```json
{
  "success": true,
  "data": {
    "plan_id": "YOUR_PLAN_ID",
    "range": "24h",
    "generated_at": "2026-10-13T12:00:00.000Z",
    "destinations": [
      {
        "host": "example.com",
        "bytes_down": 1288490188.8,
        "bytes_up": 107374182.4,
        "connections": 18240,
        "failed": 96,
        "success_pct": 99.5
      }
    ]
  }
}
```

### Error breakdown

`GET /api/v1/plans/{plan_id}/errors`

Returns what went wrong over a time range, grouped by category, each with a readable label and a hint on what to check.

Permission: `usage`

**Parameters**

| Name | In | Required | Description |
| --- | --- | --- | --- |
| `plan_id` | path | required | The plan ID, as returned in plan_id by List plans. |
| `range` | query |  | Time window: 1h, 24h, 7d, 30d. Defaults to 24h. |

**Request**

```bash
curl "https://www.flashproxy.com/api/v1/plans/YOUR_PLAN_ID/errors?range=24h" \
  -H "Authorization: Bearer fpk_live_YOUR_KEY"
```

**Response · 200**

```json
{
  "success": true,
  "data": {
    "plan_id": "YOUR_PLAN_ID",
    "range": "24h",
    "generated_at": "2026-10-13T12:00:00.000Z",
    "errors": [
      {
        "category": "timeout",
        "label": "Connection timed out",
        "hint": "The destination did not answer in time. Usually a slow or overloaded target site; retry with a longer client timeout, and check whether one destination dominates.",
        "count": 214
      }
    ]
  }
}
```,## Proxies

### Plan locations

`GET /api/v1/plans/{plan_id}/locations`

Returns the countries a plan can target with the country field when you generate proxies. When any_country is true, any two-letter code is accepted and there is no list.

Permission: `usage`

**Parameters**

| Name | In | Required | Description |
| --- | --- | --- | --- |
| `plan_id` | path | required | The plan ID, as returned in plan_id by List plans. |

**Request**

```bash
curl "https://www.flashproxy.com/api/v1/plans/YOUR_PLAN_ID/locations" \
  -H "Authorization: Bearer fpk_live_YOUR_KEY"
```

**Response · 200**

```json
{
  "success": true,
  "data": {
    "plan_id": "YOUR_PLAN_ID",
    "product": "ipv6-datacenter",
    "any_country": false,
    "countries": [
      {
        "code": "CA",
        "name": "Canada"
      },
      {
        "code": "FR",
        "name": "France"
      },
      {
        "code": "US",
        "name": "United States"
      }
    ]
  }
}
```

### Generate proxies

`POST /api/v1/plans/{plan_id}/proxies`

Builds ready-to-use proxy lines for one of your active plans, the same way the dashboard generator does.

Permission: `proxies`

**Parameters**

| Name | In | Required | Description |
| --- | --- | --- | --- |
| `plan_id` | path | required | The plan ID, as returned in plan_id by List plans. |
| `count` | body |  | How many lines to return, 1 to 1000. Defaults to 10. |
| `country` | body |  | Two-letter country code to target, for example US. Leave it out for any country. |
| `session` | body |  | rotating for a new IP on every request (default), or sticky to keep the same IP. |
| `sticky_minutes` | body |  | How long a sticky IP is kept, 1 to 1000 minutes. Residential and mobile cap it at 120. Defaults to 30. |
| `protocol` | body |  | http (default) or socks5. |
| `format` | body |  | hostport for host:port:user:pass (default), or url for scheme://user:pass@host:port. |

**Request**

```bash
curl -X POST "https://www.flashproxy.com/api/v1/plans/YOUR_PLAN_ID/proxies" \
  -H "Authorization: Bearer fpk_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"count":2,"country":"US","session":"sticky","sticky_minutes":30,"protocol":"http","format":"hostport"}'
```

**Response · 200**

```json
{
  "success": true,
  "data": {
    "plan_id": "YOUR_PLAN_ID",
    "count": 2,
    "protocol": "http",
    "format": "hostport",
    "proxies": [
      "adam.flashproxy.io:8080:USERNAME-country-US-session-k3x9q2ma-time-30:PASSWORD",
      "adam.flashproxy.io:8080:USERNAME-country-US-session-p7d1v8tc-time-30:PASSWORD"
    ]
  }
}
```

### Fixed IP list

`GET /api/v1/plans/{plan_id}/ips`

Returns the plan's fixed IPs with its login: live exit IPs for Datacenter plans, or the leased IPs for Dedicated ISP plans. Rotating-gateway plans use Generate proxies instead.

Permission: `proxies`

**Parameters**

| Name | In | Required | Description |
| --- | --- | --- | --- |
| `plan_id` | path | required | The plan ID, as returned in plan_id by List plans. |
| `protocol` | query |  | http (default) or socks5. Dedicated ISP v2 plans support http only. |
| `format` | query |  | hostport for host:port:user:pass (default), or url for scheme://user:pass@host:port. |
| `limit` | query |  | How many IPs to return, up to 10000. Defaults to 1000. total always shows the full count. |

**Request**

```bash
curl "https://www.flashproxy.com/api/v1/plans/YOUR_PLAN_ID/ips?protocol=http&limit=2" \
  -H "Authorization: Bearer fpk_live_YOUR_KEY"
```

**Response · 200**

```json
{
  "success": true,
  "data": {
    "plan_id": "YOUR_PLAN_ID",
    "product": "datacenter",
    "source": "live",
    "protocol": "http",
    "format": "hostport",
    "total": 2048,
    "count": 2,
    "proxies": [
      "203.0.113.10:777:USERNAME:PASSWORD",
      "203.0.113.11:777:USERNAME:PASSWORD"
    ]
  }
}
```,## Extensions

### Quote an extension

`GET /api/v1/plans/{plan_id}/extend/quote`

Returns what an extension would cost, running the same checks as Extend a plan, without buying anything.

Permission: `usage`

**Parameters**

| Name | In | Required | Description |
| --- | --- | --- | --- |
| `plan_id` | path | required | The plan ID, as returned in plan_id by List plans. |
| `gb` | query |  | GB to quote, for plans billed by data. |
| `days` | query |  | Days to quote, for plans billed by time. Send gb or days, not both. |

**Request**

```bash
curl "https://www.flashproxy.com/api/v1/plans/YOUR_PLAN_ID/extend/quote?gb=10" \
  -H "Authorization: Bearer fpk_live_YOUR_KEY"
```

**Response · 200**

```json
{
  "success": true,
  "data": {
    "plan_id": "YOUR_PLAN_ID",
    "added": {
      "gb": 10
    },
    "price_usd": 35,
    "currency": "USD"
  }
}
```

### Extend a plan

`POST /api/v1/plans/{plan_id}/extend`

Adds data (gb) or time (days) to one of your plans and pays from your account balance, at the same price as the dashboard.

Permission: `extend`

**Parameters**

| Name | In | Required | Description |
| --- | --- | --- | --- |
| `plan_id` | path | required | The plan ID, as returned in plan_id by List plans. |
| `Idempotency-Key` | header | required | A unique string for this extension. See Idempotency below. |
| `gb` | body |  | GB to add, for plans billed by data. A whole number from 1 to 2,000,000. |
| `days` | body |  | Days to add, for plans billed by time: 1 to 365, or 1, 7, 30, 60 for Premium Unlimited Residential. Send gb or days, not both. |

**Request**

```bash
curl -X POST "https://www.flashproxy.com/api/v1/plans/YOUR_PLAN_ID/extend" \
  -H "Authorization: Bearer fpk_live_YOUR_KEY" \
  -H "Idempotency-Key: extend-2026-10-13-001" \
  -H "Content-Type: application/json" \
  -d '{"gb":10}'
```

**Response · 200**

```json
{
  "success": true,
  "data": {
    "plan_id": "YOUR_PLAN_ID",
    "charged_usd": 35,
    "added": {
      "gb": 10
    },
    "plan": {
      "status": "active",
      "expires_at": "2027-04-11T12:00:00.000Z",
      "max_bytes": 21474836480
    },
    "replayed": false
  }
}
```,## Products & prices

### Products and prices

`GET /api/v1/products`

Returns every product with its per-GB tiers (the whole amount is billed at the rate of the tier it falls in) and its speed-and-days prices. Use Quote an extension for the exact price of a specific plan.

Permission: `usage`

**Request**

```bash
curl "https://www.flashproxy.com/api/v1/products" \
  -H "Authorization: Bearer fpk_live_YOUR_KEY"
```

**Response · 200**

```json
{
  "success": true,
  "data": {
    "products": [
      {
        "product": "datacenter",
        "name": "Datacenter Proxies",
        "billed_by": [
          "data",
          "time"
        ],
        "data_pricing": [
          {
            "up_to_gb": 1,
            "per_gb_usd": 0.7
          },
          {
            "up_to_gb": 5,
            "per_gb_usd": 0.65
          }
        ],
        "time_pricing": [
          {
            "mbps": 10,
            "days": 1,
            "price_usd": 1
          },
          {
            "mbps": 10,
            "days": 30,
            "price_usd": 18
          }
        ]
      }
    ],
    "currency": "USD"
  }
}
```

## Idempotency

Extending a plan spends your balance, so every extend call needs an `Idempotency-Key` header.

- Use a new key for every extension you mean to buy: 8 to 128 letters, digits, `-` or `_`.
- If a call times out or returns a 5xx error, send it again with the same key. You are charged at most once, and a finished extension comes back with `replayed: true`.
- The same key with a different plan or amount returns `409 IDEMPOTENCY_KEY_REUSED`.
- While the first call is still running, a second call with the same key returns `409 REQUEST_IN_PROGRESS`.

## Response fields

Each plan in a usage response carries the same record.

| Field | Meaning |
| --- | --- |
| `usage.*` | `bytes_used`, `max_bytes`, `remaining_bytes` and `percentage_used`. `max_bytes` and `remaining_bytes` are null on plans without a data cap. `bytes_used` is null on Unlimited Residential, which is billed by time and speed. |
| `throughput.current_mbps` | The latest speed measurement: the last complete minute for most products, 0 when there was no recent traffic. |
| `throughput.avg_mbps_5m / peak_mbps_1h` | The 5-minute average and the 1-hour peak speed. |
| `throughput.limit_mbps` | Your plan's speed limit. `utilization_pct` is the current speed divided by this limit. |
| `throughput.sampled_at` | When the latest measurement was taken. `data_delay_seconds` tells you how old it is. |

**Values of `throughput_status`**

| Value | Meaning |
| --- | --- |
| `ok` | throughput is filled in. |
| `pending` | Speed is still being collected. For Unlimited Residential the first reading can take up to 10 minutes; keep polling as usual. |
| `unavailable` | Speed is temporarily unavailable. Retry later. |
| `not_supported` | This product has no speed metrics yet. The usage counters still work. |

## Limits

- 60 requests a minute per key
- All keys of one account share a limit of 120 requests a minute.
- Over the limit you get `429` with a `Retry-After: 60` header.
- Extend calls also count toward the limit of 6 balance purchases a minute per account, shared with the dashboard.
- Speed is measured per minute, so polling every 15 to 30 seconds is plenty.
- Usage answers can be up to 15 seconds old and product prices up to 5 minutes old.

## Errors

Errors share one shape: success is false and error holds a code and a readable message.

```json
{
  "success": false,
  "error": {
    "code": "UNAUTHORIZED",
    "message": "Invalid API key"
  }
}
```

| Status | Code | Meaning |
| --- | --- | --- |
| 400 | `INVALID_REQUEST` | The body or a parameter is invalid. The message says which. |
| 400 | `IDEMPOTENCY_KEY_REQUIRED` | An extend call without a valid Idempotency-Key header. |
| 400 | `PAYMENT_REFUSED` | The balance payment was refused. Contact support. |
| 401 | `UNAUTHORIZED` | Missing, invalid or revoked key. |
| 402 | `INSUFFICIENT_BALANCE` | Your balance is too low for this extension. Top up and retry. |
| 403 | `FORBIDDEN` | The key doesn't have the permission this endpoint needs. |
| 404 | `NOT_FOUND` | No such plan on your account. |
| 409 | `PLAN_NOT_ACTIVE` | Proxies can only be generated for an active plan. |
| 409 | `PLAN_NOT_READY` | The plan has no proxy credentials yet. Try again shortly. |
| 409 | `IDEMPOTENCY_KEY_REUSED` | This Idempotency-Key was already used for a different extension. |
| 409 | `REQUEST_IN_PROGRESS` | An extension with this Idempotency-Key is still running. Retry in a moment. |
| 409 | `PRICE_MISMATCH` | The price changed while processing. Retry with a new Idempotency-Key. |
| 422 | `EXTENSION_NOT_SUPPORTED` | This plan can't be extended through the API. Extend it in the dashboard. |
| 422 | `PROXIES_NOT_SUPPORTED` | Dedicated plans have a fixed IP list. Download it from the dashboard. |
| 422 | `USAGE_HISTORY_NOT_SUPPORTED` | This product has no usage history. Use the usage endpoints for its counters. |
| 422 | `IPS_NOT_SUPPORTED` | This plan uses a rotating gateway, not a fixed IP list. Use Generate proxies. |
| 422 | `CUSTOM_PLAN_EXTEND_VIA_SUPPORT` | Custom plans are extended by support only. |
| 429 | `RATE_LIMITED` | Too many requests. Wait for Retry-After, then retry. |
| 500 | `INTERNAL_ERROR` | Temporary error. Try again. |
| 502 | `EXTENSION_FAILED` | The extension didn't complete. Retry with the same Idempotency-Key only if the message says nothing was charged; otherwise contact support. |
| 503 | `IPS_UNAVAILABLE` | The IP list could not be loaded right now. Retry in a minute. |


---

# Residential
Source: https://www.flashproxy.com/docs/products/residential

# Residential Proxies

Premium rotating residential IPs sourced through ISP partnerships — the best choice when IP quality and precise geo-targeting matter.

## Specs

- **Pool:** 100M+ IPs, millions active daily
- **Typical response time:** ~400 ms
- **Protocols:** HTTP, SOCKS5
- **Sessions:** rotating or sticky (up to 2 hours)
- **Concurrency:** up to 50,000 concurrent connections
- **Best for:** web scraping, data collection, anything needing deep geo-targeting

## Connect

**Gateway:** `adam.flashproxy.io` — port **8080** (HTTP) / **1080** (SOCKS5).

```bash
# Rotating — a fresh IP on every request
curl -x "http://USERNAME:PASSWORD@adam.flashproxy.io:8080" https://api.ipify.org
```

```bash
# SOCKS5
curl -x "socks5://USERNAME:PASSWORD@adam.flashproxy.io:1080" https://api.ipify.org
```

## Request parameters

Targeting and session options are encoded **into the username**, each appended as a `-key-value` pair after your base username:

```text
USERNAME-country-US-state-california-session-a1b2c3d4-time-long
```

Residential supports the deepest targeting in the catalogue:

| Parameter      | Format                            | Example                      | Notes                               |
| -------------- | --------------------------------- | ---------------------------- | ----------------------------------- |
| Country        | `country-<ISO2>`                  | `country-US`                 | Comma-join several: `country-US,GB` |
| State          | `state-<name>`                    | `state-california`           | Lower-case, no spaces               |
| City           | `city-<name>`                     | `city-newyork`               | Lower-case, no spaces               |
| ASN            | `asn-<number>`                    | `asn-7922`                   | Target a specific network           |
| Sticky session | `session-<id>-time-<long\|short>` | `session-a1b2c3d4-time-long` | Omit entirely for a rotating IP     |

For the complete reference — parameter ordering and every accepted value — see the [API reference](https://rapi.flashproxy.com/docs).

## Examples

```bash
# Rotating — United States
curl -x "http://USERNAME-country-US:PASSWORD@adam.flashproxy.io:8080" https://api.ipify.org
```

```bash
# Sticky — hold the same US IP across the session
curl -x "http://USERNAME-country-US-session-a1b2c3d4-time-long:PASSWORD@adam.flashproxy.io:8080" https://api.ipify.org
```

```bash
# City-level — New York, NY
curl -x "http://USERNAME-country-US-state-newyork-city-newyork:PASSWORD@adam.flashproxy.io:8080" https://api.ipify.org
```

```bash
# Specific ASN
curl -x "http://USERNAME-country-US-asn-7922:PASSWORD@adam.flashproxy.io:8080" https://api.ipify.org
```

## Sessions

Use **rotating** for high-volume scraping (maximum IP diversity) or **sticky** to keep the same IP across a session — see [Rotating & sticky](/docs/sessions).

## Pricing

Per-GB, with volume discounts as you scale. See [Residential pricing](/pricing/residential).

## Quickstart

1. Buy a Residential plan in the [dashboard](/dashboard).
2. Copy your username and password.
3. Use the connection string above, adding targeting parameters as needed.


---

# Residential Lite
Source: https://www.flashproxy.com/docs/products/residential-lite

# Residential Lite Proxies

Budget-friendly residential coverage at the lowest entry price in the catalogue — built for high-volume jobs where cost-per-GB is the primary lever.

## Specs

- **Coverage:** 201+ countries (country-level targeting)
- **Typical response time:** ~421 ms
- **Success rate:** 99.5%
- **Protocols:** HTTP, SOCKS5
- **Sessions:** rotating only (no sticky)
- **Concurrency:** up to 50,000 concurrent connections
- **Best for:** high-volume scraping and price-sensitive operations

## Connect

**Gateway:** `lite.flashproxy.io` — port **6969** (HTTP) / **6969** (SOCKS5).

```bash
# Rotating — a fresh IP on every request
curl -x "http://USERNAME:PASSWORD@lite.flashproxy.io:6969" https://api.ipify.org
```

```bash
# SOCKS5
curl -x "socks5://USERNAME:PASSWORD@lite.flashproxy.io:6969" https://api.ipify.org
```

## Request parameters

Targeting is encoded **into the username**, appended as a `-key-value` pair after your base username. Residential Lite is **country-level only** and **rotating-only** (no sticky sessions):

| Parameter | Format           | Example      | Notes                               |
| --------- | ---------------- | ------------ | ----------------------------------- |
| Country   | `country-<ISO2>` | `country-US` | Comma-join several: `country-US,GB` |

For the complete reference — every accepted value — see the [API reference](https://rapi.flashproxy.com/docs).

## Examples

```bash
# Rotating — any country
curl -x "http://USERNAME:PASSWORD@lite.flashproxy.io:6969" https://api.ipify.org
```

```bash
# Rotating — United Kingdom
curl -x "http://USERNAME-country-GB:PASSWORD@lite.flashproxy.io:6969" https://api.ipify.org
```

## Sessions

Residential Lite is **rotating-only** — you get a fresh IP on every request, with no sticky sessions. See [Rotating & sticky](/docs/sessions).

## Pricing

Per-GB, from $0.16/GB at scale. See [Residential Lite pricing](/pricing/residential-lite).

## Quickstart

1. Buy a Residential Lite plan in the [dashboard](/dashboard).
2. Copy your username and password.
3. Use the connection string above, adding a country to your username if needed.


---

# Unlimited Residential
Source: https://www.flashproxy.com/docs/products/unlimited-residential

# Unlimited Residential Proxies

FlashProxy's flagship plan: unmetered residential bandwidth with uncapped concurrency — built for max-scale operations where bandwidth predictability and unconstrained parallelism matter most.

## Specs

- **Coverage:** 201+ countries (country-level targeting)
- **Bandwidth:** unmetered (only the mbps throughput cap applies)
- **Concurrency:** uncapped
- **Protocols:** HTTP, SOCKS5
- **Sessions:** rotating or sticky (up to 2 hours)
- **Best for:** max-scale operations needing predictable bandwidth and unlimited parallelism

## Connect

**Gateway:** `unlim.flashproxy.io` — port **10507** (HTTP) / **10507** (SOCKS5).

```bash
# Rotating — a fresh IP on every request
curl -x "http://USERNAME:PASSWORD@unlim.flashproxy.io:10507" https://api.ipify.org
```

```bash
# SOCKS5
curl -x "socks5://USERNAME:PASSWORD@unlim.flashproxy.io:10507" https://api.ipify.org
```

## Request parameters

Targeting and session options are encoded **into the username**, appended as a `-key-value` pair after your base username. Unlimited Residential is **country-level only**:

| Parameter      | Format                        | Example                    | Notes                                 |
| -------------- | ----------------------------- | -------------------------- | ------------------------------------- |
| Country        | `country-<ISO2>`              | `country-US`               | Comma-join several: `country-US,GB`   |
| Sticky session | `time-<minutes>-session-<id>` | `time-30-session-a1b2c3d4` | Up to 120 min; omit for a rotating IP |

For the complete reference — every accepted value — see the [API reference](https://rapi.flashproxy.com/docs).

## Examples

```bash
# Rotating — United States
curl -x "http://USERNAME-country-US:PASSWORD@unlim.flashproxy.io:10507" https://api.ipify.org
```

```bash
# Sticky — hold the same IP for 30 minutes
curl -x "http://USERNAME-time-30-session-a1b2c3d4:PASSWORD@unlim.flashproxy.io:10507" https://api.ipify.org
```

## Sessions

Use **rotating** for maximum IP diversity or **sticky** to keep the same IP across a session — see [Rotating & sticky](/docs/sessions).

## Pricing

Unmetered, available via a $20 trial. See [Unlimited Residential pricing](/pricing/unlimited-residential).

## Quickstart

1. Buy an Unlimited Residential plan in the [dashboard](/dashboard).
2. Copy your username and password.
3. Use the connection string above, adding a country to your username if needed.


---

# Premium Unlimited Residential
Source: https://www.flashproxy.com/docs/products/premium-unlimited-residential

# Premium Unlimited Residential Proxies

Unmetered residential bandwidth on a dedicated high-speed tier: pick a throughput from 200 Mbps up to 3 Gbps, get 70% Tier 1 IPs, and connect through a hostname assigned to your plan.

## Specs

- **Coverage:** worldwide country targeting, plus US state, city and ISP targeting
- **Bandwidth:** unmetered (only your plan's Mbps cap applies)
- **Speed tiers:** 200 – 1,000 Mbps in 100 Mbps steps, plus 1.5, 2, 2.5 and 3 Gbps
- **IP quality:** 70% Tier 1 IPs; 600K+ USA and 200K+ GB IPs daily, 1.5M+ daily active users across the network
- **Terms:** 1, 7, 30 or 60 days
- **Protocols:** HTTP, HTTPS (CONNECT), SOCKS5
- **Sessions:** rotating or sticky (up to 24 hours)
- **Best for:** high-throughput scraping and automation that needs a guaranteed speed tier

## Premium vs Unlimited Residential

|                 | Premium Unlimited Residential        | Unlimited Residential             |
| --------------- | ------------------------------------ | --------------------------------- |
| IP quality      | 70% Tier 1 IPs                       | mostly Tier 3 countries           |
| Gateway         | Your plan's own hostname (dashboard) | `unlim.flashproxy.io`              |
| Ports           | **10000** (HTTP) / **6969** (SOCKS5) | **10507** (both) |
| Speed tiers     | 200 Mbps – 3 Gbps                    | 200 Mbps – 3 Gbps                 |
| Targeting       | country; US state, city or ISP       | country                           |
| Sticky sessions | very long: up to 24 hours (seconds)  | standard: up to 2 hours (minutes) |
| Extend a plan   | yes, same speed tier                 | no, buy a new plan                |

## Connect

**Gateway:** every plan gets its **own hostname** — copy it from the plan page in the [dashboard](/dashboard). Ports are **10000** (HTTP) and **6969** (SOCKS5). In the examples below, replace `YOUR_PLAN_HOST` with that hostname.

```bash
# Rotating — a fresh IP on every request
curl -x "http://USERNAME:PASSWORD@YOUR_PLAN_HOST:10000" https://api.ipify.org
```

```bash
# SOCKS5 (socks5h resolves DNS through the proxy)
curl -x "socks5h://USERNAME:PASSWORD@YOUR_PLAN_HOST:6969" https://api.ipify.org
```

The plan page also has a **proxy generator** that builds ready-to-use proxy lists with your hostname, credentials and targeting filled in.

## Request parameters

Targeting and session options are encoded **into the username**, appended as `-key-value` pairs after your base username. Your password stays the same.

| Parameter      | Format             | Example             | Notes                                   |
| -------------- | ------------------ | ------------------- | --------------------------------------- |
| Country        | `country-<iso2>`   | `country-us`        | Any ISO 3166 two-letter code, lowercase |
| US state       | `state-<code>`     | `state-tx`          | Two-letter US state code, lowercase     |
| US city        | `city-<name>`      | `city-newyork`      | Lowercase, no spaces                    |
| US ISP         | `isp-<name>`       | `isp-comcast_cable` | Lowercase, `_` between words            |
| Sticky session | `session-<digits>` | `session-12345678`  | 1–16 digits; omit for a rotating IP     |
| Session length | `time-<seconds>`   | `time-600`          | 1–86400 seconds; needs a session        |

**Use one location per request:** a country, **or** a US state, **or** a US city, **or** a US ISP. They don't combine — if you send more than one, only one is applied (ISP first, then city, then state, then country), so `isp-comcast_cable` with `state-tx` gives a Comcast IP anywhere in the US, not one in Texas. State, city and ISP targeting are **US only**; ASN and ZIP targeting are not available.

City names are written in lowercase with spaces and punctuation removed — **New York** becomes `newyork`, **Los Angeles** becomes `losangeles`. A city doesn't need a country, and a state doesn't narrow down a city name shared by several states (for example Springfield).

Only target locations from the list in the **proxy generator** on your plan page — it shows every country, US state, city and ISP you can pick, with the number of devices online. A location that isn't available doesn't fall back to a random IP: the connection fails. State accuracy depends on IP geolocation, so a small share of IPs can resolve to a neighbouring state.

## Examples

```bash
# Rotating — United States
curl -x "http://USERNAME-country-us:PASSWORD@YOUR_PLAN_HOST:10000" https://api.ipify.org
```

```bash
# Rotating — New York City
curl -x "http://USERNAME-city-newyork:PASSWORD@YOUR_PLAN_HOST:10000" https://api.ipify.org
```

```bash
# Rotating — Texas
curl -x "http://USERNAME-state-tx:PASSWORD@YOUR_PLAN_HOST:10000" https://api.ipify.org
```

```bash
# Rotating — Comcast home IPs anywhere in the US
curl -x "http://USERNAME-isp-comcast_cable:PASSWORD@YOUR_PLAN_HOST:10000" https://api.ipify.org
```

```bash
# Sticky — hold the same German IP for 10 minutes
curl -x "http://USERNAME-country-de-session-12345678-time-600:PASSWORD@YOUR_PLAN_HOST:10000" https://api.ipify.org
```

## Sessions

Without `session`, every request gets a new IP. Add `session-<digits>` to keep the same IP, and `time-<seconds>` to set how long it holds (up to 24 hours) — use a new session number whenever you want a fresh IP. See [Rotating & sticky](/docs/sessions).

## Trials and extensions

- **Trial:** 1 hour at 200 Mbps ($20) or 1 Gbps ($35).
- **Extend:** add 1, 7, 30 or 60 days to an **active** plan from its plan page. The speed tier and credentials stay the same.
- Trials, and plans that have already expired, can't be extended — buy a new plan instead.

## Pricing

Choose a speed tier and term in the [dashboard](/dashboard/products/premium-unl-resi) to see the price before you buy.

## Quickstart

1. Buy a Premium Unlimited Residential plan in the [dashboard](/dashboard/products/premium-unl-resi).
2. Open the plan and copy its hostname, username and password.
3. Connect to port 10000 (HTTP) or 6969 (SOCKS5), adding one location (country, US state, city or ISP) or a session to your username if needed.


---

# Datacenter
Source: https://www.flashproxy.com/docs/products/datacenter

# Datacenter Proxies

High-throughput US datacenter proxies at ~30 ms response — built for fast scraping and price monitoring on non-sensitive targets where speed and cost matter most.

## Specs

- **Pool:** 14,000+ USA IPs
- **Coverage:** US only (country-level targeting)
- **Typical response time:** ~30 ms
- **Protocols:** HTTP, SOCKS5 (SOCKS5 UDP ASSOCIATE supported)
- **Sessions:** rotating or sticky (up to 2 hours)
- **Concurrency:** up to 50,000 concurrent connections (per-GB); 9,000 on the time-based Unlimited tier — higher on request
- **Best for:** fast scraping and e-commerce price monitoring

## Connect

**Gateway:** `dc.flashproxy.io` — port **777** (HTTP) / **666** (SOCKS5).

```bash
# Rotating — a fresh IP on every request
curl -x "http://USERNAME:PASSWORD@dc.flashproxy.io:777" https://api.ipify.org
```

```bash
# SOCKS5
curl -x "socks5://USERNAME:PASSWORD@dc.flashproxy.io:666" https://api.ipify.org
```

## Request parameters

Datacenter is **US-only**, so there's no country parameter to set. Two options are still available, encoded **into the username**:

| Parameter         | Format                        | Example                    | Notes                                                                        |
| ----------------- | ----------------------------- | -------------------------- | ---------------------------------------------------------------------------- |
| Sticky session    | `time-<minutes>-session-<id>` | `time-30-session-a1b2c3d4` | Up to 120 min; omit for a rotating IP                                        |
| Pin a specific IP | `-ip-<address>`               | `-ip-0_0_0_0`              | Target one exact IP from the pool — see [Geo-targeting](/docs/geo-targeting) |

For the complete reference — every accepted value — see the [API reference](https://rapi.flashproxy.com/docs).

## Examples

```bash
# Rotating — a fresh US IP each request
curl -x "http://USERNAME:PASSWORD@dc.flashproxy.io:777" https://api.ipify.org
```

```bash
# Sticky — hold the same IP for 30 minutes
curl -x "http://USERNAME-time-30-session-a1b2c3d4:PASSWORD@dc.flashproxy.io:777" https://api.ipify.org
```

```bash
# Pin one exact IP
curl -x "http://USERNAME-ip-0_0_0_0:PASSWORD@dc.flashproxy.io:777" https://api.ipify.org
```

## Sessions

Use **rotating** for maximum IP diversity or **sticky** to keep the same IP across a session — see [Rotating & sticky](/docs/sessions).

## Pricing

Per-GB, with volume discounts as you scale, and a time-based Unlimited tier. See [Datacenter pricing](/pricing/datacenter).

## Quickstart

1. Buy a Datacenter plan in the [dashboard](/dashboard).
2. Copy your username and password.
3. Use the connection string above.


---

# ISP (US)
Source: https://www.flashproxy.com/docs/products/isp

# Shared ISP Proxies (US)

ISP-hosted US IPs that combine residential authenticity with datacenter-grade ~39 ms latency — built for ad verification, SEO, sneakers, and any workflow that needs residential trust at near-datacenter speed.

## Specs

- **Pool:** 22,000+ USA IPs
- **Coverage:** US only (country-level targeting)
- **Typical response time:** ~39 ms
- **Protocols:** HTTP, SOCKS5 (SOCKS5 UDP ASSOCIATE supported)
- **Sessions:** rotating or sticky (up to 2 hours)
- **Concurrency:** up to 9,000 concurrent connections — higher on request
- **Best for:** ad verification, SEO monitoring, sneakers

## Connect

**Gateway:** `beta.flashproxy.io` — port **30** (HTTP) / **31** (SOCKS5).

```bash
# Rotating — a fresh IP on every request
curl -x "http://USERNAME:PASSWORD@beta.flashproxy.io:30" https://api.ipify.org
```

```bash
# SOCKS5
curl -x "socks5://USERNAME:PASSWORD@beta.flashproxy.io:31" https://api.ipify.org
```

## Request parameters

Shared ISP (US) is **US-only**, so there's no country parameter to set. Two options are still available, encoded **into the username**:

| Parameter         | Format                        | Example                    | Notes                                                                        |
| ----------------- | ----------------------------- | -------------------------- | ---------------------------------------------------------------------------- |
| Sticky session    | `time-<minutes>-session-<id>` | `time-30-session-a1b2c3d4` | Up to 120 min; omit for a rotating IP                                        |
| Pin a specific IP | `-ip-<address>`               | `-ip-0_0_0_0`              | Target one exact IP from the pool — see [Geo-targeting](/docs/geo-targeting) |

For the complete reference — every accepted value — see the [API reference](https://rapi.flashproxy.com/docs).

## Examples

```bash
# Rotating — a fresh US IP each request
curl -x "http://USERNAME:PASSWORD@beta.flashproxy.io:30" https://api.ipify.org
```

```bash
# Sticky — hold the same IP for 30 minutes
curl -x "http://USERNAME-time-30-session-a1b2c3d4:PASSWORD@beta.flashproxy.io:30" https://api.ipify.org
```

```bash
# Pin one exact IP
curl -x "http://USERNAME-ip-0_0_0_0:PASSWORD@beta.flashproxy.io:30" https://api.ipify.org
```

## Sessions

Use **rotating** for maximum IP diversity or **sticky** to keep the same IP across a session — see [Rotating & sticky](/docs/sessions).

## Pricing

Per-GB, with volume discounts as you scale, and a time-based Unlimited tier. See [Shared ISP pricing](/pricing/isp).

## Quickstart

1. Buy a Shared ISP (US) plan in the [dashboard](/dashboard).
2. Copy your username and password.
3. Use the connection string above.


---

# ISP (EU)
Source: https://www.flashproxy.com/docs/products/isp-eu

# Shared ISP Proxies (EU)

The European counterpart to Shared ISP US — the same residential-trust-at-datacenter-speed profile, on European ISP IPs. Built for EU-geo ad verification, SEO, and account work that needs European ISP IPs.

## Specs

- **Coverage:** currently Germany, the UK and France (the list follows our live pool; the generator's Country list shows it)
- **Protocols:** HTTP, SOCKS5 (SOCKS5 UDP ASSOCIATE supported)
- **Sessions:** rotating or sticky (up to 2 hours)
- **Concurrency:** up to 9,000 concurrent connections — higher on request
- **Latency:** see live, per-node latency at [status.flashproxy.com](https://status.flashproxy.com)
- **Best for:** EU-geo ad verification, SEO monitoring, account work

## Connect

**Gateway:** `new-eu-isp.flashproxy.io` — port **30** (HTTP) / **31** (SOCKS5).

```bash
# Rotating — a fresh IP on every request
curl -x "http://USERNAME:PASSWORD@new-eu-isp.flashproxy.io:30" https://api.ipify.org
```

```bash
# SOCKS5
curl -x "socks5://USERNAME:PASSWORD@new-eu-isp.flashproxy.io:31" https://api.ipify.org
```

## Request parameters

Targeting and session options are encoded **into the username**. Shared ISP (EU) is **country-level** (pick from the generator's Country list):

| Parameter         | Format                        | Example                    | Notes                                                                        |
| ----------------- | ----------------------------- | -------------------------- | ---------------------------------------------------------------------------- |
| Country           | `country-<ISO2>`              | `country-DE`               | A country from the generator's Country list, e.g. `country-FR`, `country-GB` |
| Sticky session    | `time-<minutes>-session-<id>` | `time-30-session-a1b2c3d4` | Up to 120 min; omit for a rotating IP                                        |
| Pin a specific IP | `-ip-<address>`               | `-ip-0_0_0_0`              | Target one exact IP from the pool — see [Geo-targeting](/docs/geo-targeting) |

For the complete reference — every accepted value — see the [API reference](https://rapi.flashproxy.com/docs).

## Examples

```bash
# Rotating — Germany
curl -x "http://USERNAME-country-DE:PASSWORD@new-eu-isp.flashproxy.io:30" https://api.ipify.org
```

```bash
# Sticky — hold the same IP for 30 minutes
curl -x "http://USERNAME-country-DE-time-30-session-a1b2c3d4:PASSWORD@new-eu-isp.flashproxy.io:30" https://api.ipify.org
```

```bash
# Pin one exact IP
curl -x "http://USERNAME-ip-0_0_0_0:PASSWORD@new-eu-isp.flashproxy.io:30" https://api.ipify.org
```

## Sessions

Use **rotating** for maximum IP diversity or **sticky** to keep the same IP across a session — see [Rotating & sticky](/docs/sessions).

## Pricing

Per-GB, with volume discounts as you scale, and a time-based Unlimited tier — identical pricing to Shared ISP US. See [Shared ISP EU pricing](/pricing/isp-eu).

## Quickstart

1. Buy a Shared ISP (EU) plan in the [dashboard](/dashboard).
2. Copy your username and password.
3. Use the connection string above.


---

# IPv6 Residential
Source: https://www.flashproxy.com/docs/products/ipv6-residential

# IPv6 Residential Proxies

IPv6-allocated residential IPs (US) with strong ~39 ms response times — built for sites that have shifted to IPv6-first infrastructure and operations that benefit from the larger address space.

## Specs

- **Pool:** ~160 octillion IPv6 addresses (US)
- **Coverage:** US only (country-level targeting)
- **Typical response time:** ~39 ms
- **Protocols:** HTTP, SOCKS5 (SOCKS5 UDP ASSOCIATE supported)
- **Sessions:** rotating or sticky (up to 2 hours)
- **Concurrency:** up to 50,000 concurrent connections (per-GB); 9,000 on the time-based Unlimited tier — higher on request
- **Best for:** IPv6-first targets and large-address-space operations

## Connect

**Gateway:** `beta-ipv6.flashproxy.io` — port **30** (HTTP) / **31** (SOCKS5).

```bash
# Rotating — a fresh IP on every request
curl -x "http://USERNAME:PASSWORD@beta-ipv6.flashproxy.io:30" https://api.ipify.org
```

```bash
# SOCKS5
curl -x "socks5://USERNAME:PASSWORD@beta-ipv6.flashproxy.io:31" https://api.ipify.org
```

## Request parameters

IPv6 Residential is **US-only**, so there's no country parameter to set. Two options are still available, encoded **into the username**:

| Parameter         | Format                                   | Example                    | Notes                                       |
| ----------------- | ---------------------------------------- | -------------------------- | ------------------------------------------- |
| Sticky session    | `time-<minutes>-session-<id>`            | `time-30-session-a1b2c3d4` | Up to 120 min; omit for a rotating IP       |
| Pin a specific IP | see [Geo-targeting](/docs/geo-targeting) | —                          | Target one exact IPv6 address from the pool |

For the complete reference — every accepted value — see the [API reference](https://rapi.flashproxy.com/docs).

## Examples

```bash
# Rotating — a fresh IPv6 each request
curl -x "http://USERNAME:PASSWORD@beta-ipv6.flashproxy.io:30" https://api.ipify.org
```

```bash
# Sticky — hold the same IP for 30 minutes
curl -x "http://USERNAME-time-30-session-a1b2c3d4:PASSWORD@beta-ipv6.flashproxy.io:30" https://api.ipify.org
```

## Sessions

Use **rotating** for maximum IP diversity or **sticky** to keep the same IP across a session — see [Rotating & sticky](/docs/sessions).

## Pricing

Per-GB, with volume discounts as you scale. See [IPv6 Residential pricing](/pricing/ipv6).

## Quickstart

1. Buy an IPv6 Residential plan in the [dashboard](/dashboard).
2. Copy your username and password.
3. Use the connection string above.


---

# IPv6 Datacenter
Source: https://www.flashproxy.com/docs/products/ipv6-datacenter

# IPv6 Datacenter Proxies

The highest-throughput, lowest-cost option in the catalogue at ~30 ms response, with unlimited bandwidth on the IPv6 stack (US). Built for high-volume operations on IPv6-compatible targets where cost-per-request is the primary lever.

## Specs

- **Pool:** ~160 octillion IPv6 addresses (US)
- **Coverage:** US only (country-level targeting)
- **Typical response time:** ~30 ms
- **Protocols:** HTTP, SOCKS5 (SOCKS5 UDP ASSOCIATE supported)
- **Sessions:** rotating or sticky (up to 2 hours)
- **Concurrency:** up to 50,000 concurrent connections (per-GB); 9,000 on the time-based Unlimited tier — higher on request
- **Best for:** high-volume work on IPv6-compatible targets

## Connect

**Gateway:** `v6-dc.flashproxy.io` — port **50** (HTTP) / **51** (SOCKS5).

```bash
# Rotating — a fresh IP on every request
curl -x "http://USERNAME:PASSWORD@v6-dc.flashproxy.io:50" https://api.ipify.org
```

```bash
# SOCKS5
curl -x "socks5://USERNAME:PASSWORD@v6-dc.flashproxy.io:51" https://api.ipify.org
```

## Request parameters

IPv6 Datacenter is **US-only**, so there's no country parameter to set. Two options are still available, encoded **into the username**:

| Parameter         | Format                                   | Example                    | Notes                                       |
| ----------------- | ---------------------------------------- | -------------------------- | ------------------------------------------- |
| Sticky session    | `time-<minutes>-session-<id>`            | `time-30-session-a1b2c3d4` | Up to 120 min; omit for a rotating IP       |
| Pin a specific IP | see [Geo-targeting](/docs/geo-targeting) | —                          | Target one exact IPv6 address from the pool |

For the complete reference — every accepted value — see the [API reference](https://rapi.flashproxy.com/docs).

## Examples

```bash
# Rotating — a fresh IPv6 each request
curl -x "http://USERNAME:PASSWORD@v6-dc.flashproxy.io:50" https://api.ipify.org
```

```bash
# Sticky — hold the same IP for 30 minutes
curl -x "http://USERNAME-time-30-session-a1b2c3d4:PASSWORD@v6-dc.flashproxy.io:50" https://api.ipify.org
```

## Sessions

Use **rotating** for maximum IP diversity or **sticky** to keep the same IP across a session — see [Rotating & sticky](/docs/sessions).

## Pricing

Per-GB, with volume discounts as you scale, and a time-based Unlimited tier. See [IPv6 Datacenter pricing](/pricing/ipv6).

## Quickstart

1. Buy an IPv6 Datacenter plan in the [dashboard](/dashboard).
2. Copy your username and password.
3. Use the connection string above.


---

# Mobile
Source: https://www.flashproxy.com/docs/products/mobile

# Mobile Proxies

Authentic 4G / 5G mobile carrier IPs across 115 countries at ~387 ms response — the cleanest IP reputation in the FlashProxy catalogue. Built for mobile app testing and account creation where mobile-specific signals are required.

## Specs

- **Pool:** millions of mobile IPs active daily
- **Coverage:** 115 countries
- **Typical response time:** ~387 ms
- **Protocols:** HTTP, SOCKS5
- **Sessions:** rotating or sticky (up to 2 hours)
- **Concurrency:** up to 50,000 concurrent connections
- **Best for:** mobile app testing, account creation

## Connect

**Gateway:** `adam.flashproxy.io` — port **8080** (HTTP) / **1080** (SOCKS5).

```bash
# Rotating — a fresh IP on every request
curl -x "http://USERNAME:PASSWORD@adam.flashproxy.io:8080" https://api.ipify.org
```

```bash
# SOCKS5
curl -x "socks5://USERNAME:PASSWORD@adam.flashproxy.io:1080" https://api.ipify.org
```

## Request parameters

Targeting and session options are encoded **into the username**, appended as a `-key-value` pair after your base username. Mobile supports **country** and **carrier (ASN)** targeting:

| Parameter      | Format                            | Example                      | Notes                               |
| -------------- | --------------------------------- | ---------------------------- | ----------------------------------- |
| Country        | `country-<ISO2>`                  | `country-US`                 | Comma-join several: `country-US,GB` |
| Carrier (ASN)  | `asn-<number>`                    | `asn-21928`                  | Any carrier ASN within the country  |
| Sticky session | `session-<id>-time-<long\|short>` | `session-a1b2c3d4-time-long` | Omit for a rotating IP              |

For the complete reference — every accepted value — see the [API reference](https://rapi.flashproxy.com/docs).

## Examples

```bash
# Rotating — United States
curl -x "http://USERNAME-country-US:PASSWORD@adam.flashproxy.io:8080" https://api.ipify.org
```

```bash
# Target a specific carrier (ASN)
curl -x "http://USERNAME-country-US-asn-21928:PASSWORD@adam.flashproxy.io:8080" https://api.ipify.org
```

```bash
# Sticky — hold the same mobile IP across the session
curl -x "http://USERNAME-country-US-session-a1b2c3d4-time-long:PASSWORD@adam.flashproxy.io:8080" https://api.ipify.org
```

## Sessions

Use **rotating** for maximum IP diversity or **sticky** to keep the same IP across a session — see [Rotating & sticky](/docs/sessions).

## Pricing

Per-GB, with volume discounts as you scale. See [Mobile pricing](/pricing/mobile).

## Quickstart

1. Buy a Mobile plan in the [dashboard](/dashboard).
2. Copy your username and password.
3. Use the connection string above, adding country or carrier targeting as needed.


---

# Dedicated ISP
Source: https://www.flashproxy.com/docs/products/dedicated-isp

# Dedicated ISP Proxies

Static, exclusive IP addresses registered to real ISPs — you buy specific IPs for your own use (not a shared pool), with unlimited bandwidth. Built for long-running, identity-bound operations like account warming and ticketing.

## Specs

- **Model:** dedicated IPs sold per IP for 30 days (one user owns the IP for the term)
- **Coverage:** 8 countries — US, Canada, UK, Germany, France, Spain, Poland, Hong Kong
- **Carriers:** choose a carrier pool at purchase (e.g. Verizon, British Telecom, Deutsche Telekom)
- **Bandwidth:** unlimited
- **Protocol:** HTTP
- **Authentication:** username and password — every IP in a plan shares the same pair
- **Best for:** account warming, ticketing, identity-bound workflows

## Connect

Dedicated ISP has no fixed gateway — each purchased IP has its own host and port, shown in your [dashboard](/dashboard) after purchase (copy or download the full list as `host:port:username:password`). Substitute them below.

```bash
# HTTP
curl -x "http://USERNAME:PASSWORD@<your-dedicated-host>:<port>" https://api.ipify.org
```

## Request parameters

**None.** You **own** the IP — connect to the host:port assigned to your plan (shown in the [dashboard](/dashboard)) and every request exits that IP. There are no country, session, or IP-targeting flags to add to the username. Your country and carrier pool are chosen **at purchase** from the 8 supported countries (US, CA, UK, DE, FR, ES, PL, HK).

## Sessions

Your dedicated IP is **static** for the term — every request comes out of the same IP, so there's nothing to rotate or pin. If your plan includes multiple IPs, you can distribute traffic across them.

## Managing a plan

- **Extend:** adds 30 days and keeps the same IPs. Only an active plan can be extended — an expired plan cannot be revived; buy a new one.
- **Password:** the credentials are set by the provider and cannot be changed.
- **IP allowlist:** not supported — authentication is username and password only.

## Pricing

Per IP, for 30 days, with unlimited bandwidth. See [Dedicated ISP pricing](/pricing/isp).

## Quickstart

1. Buy a Dedicated ISP plan in the [dashboard](/dashboard), choosing your country, carrier pool and number of IPs.
2. Open the plan to copy your proxy list (`host:port:username:password`).
3. Use the connection string above with your dedicated host and port.


---

# Account security (2FA)
Source: https://www.flashproxy.com/docs/account-security

# Account security (2FA)

FlashProxy supports **two-factor authentication (2FA)** with an authenticator
app. With 2FA enabled, signing in takes your password **plus** a 6-digit code
from your phone — so a stolen password alone can't access your account, your
balance, or your proxies.

2FA is optional and free. It applies to **password sign-in**: if you log in
with Google or GitHub, your provider's own two-step verification protects your
sign-in instead, and the 2FA option is not shown.

## Enabling 2FA

1. Go to [Settings → Security](/dashboard/settings?tab=security) in the
   dashboard.
2. In the **Two-factor authentication** card, click **Enable 2FA** and confirm
   your password.
3. Scan the QR code with any authenticator app — Google Authenticator, Authy,
   1Password, Microsoft Authenticator all work. On a laptop, you can instead
   copy the **manual setup key** and paste it into your app.
4. Enter the 6-digit code your app shows to confirm.

You'll then see your **backup codes** — save them before leaving the page (see
below).

## Backup codes

When you enable 2FA you receive **10 one-time backup codes**. Each code can be
used **once** in place of an authenticator code if you lose access to your
phone.

- **They are shown only once.** Copy or download them at that moment and store
  them somewhere safe (a password manager is ideal). They cannot be viewed
  again later.
- The Security card shows how many you have left, and **Regenerate** issues a
  fresh set of 10 at any time. Regenerating **invalidates all previous codes**.
- If you run low (or hit zero), regenerate — the card will warn you.

## Signing in with 2FA

After entering your password you'll be asked for the 6-digit code from your
authenticator app.

**Lost your phone?** Choose the backup-code option on the sign-in screen and
enter one of your saved backup codes. Each code works once — after you're in,
consider regenerating a fresh set in Settings. A security notification email is
sent whenever a backup code is used.

## Disabling 2FA

In [Settings → Security](/dashboard/settings?tab=security), click **Disable**,
then confirm your password and a current authenticator code. Your enrolled
authenticator and any remaining backup codes are removed immediately. You can
re-enable at any time — re-enrolling generates a **new** QR code and secret, so
delete the old FlashProxy entry from your authenticator app first.


---

# Troubleshooting
Source: https://www.flashproxy.com/docs/troubleshooting

# Troubleshooting

Quick fixes for the most common connection problems.

## `407 Proxy Authentication Required`

Your username or password is **stale or invalid**. Re-check the pair on your plan's page in the [dashboard](/dashboard), and regenerate the credentials if they don't match. Update every client after regenerating. See [Authentication](/docs/authentication).

## Connection timeout

The client can't reach the gateway. Check that:

- the **host** matches your product's gateway (see the per-product guide),
- the **port** is right — **8080** by default, **30/31** for Datacenter and Shared ISP, **10507** for Unlimited Residential, **10000/6969** for Premium Unlimited Residential (whose host is your plan's own hostname from the dashboard),
- the **format** is correct — `http://USER:PASS@host:port` or `socks5://USER:PASS@host:port` ([Proxy formats](/docs/proxy-formats)).

## Slow responses

Latency is product-dependent. Datacenter and ISP products respond fastest; Residential and Mobile trade speed for IP authenticity. If response time matters more than IP type, match your workload to a faster product — see the product guides and [pricing](/pricing/residential).

## IP not rotating

If you're getting the same IP repeatedly, you're likely on a **sticky** session. Switch to **rotating** for a fresh IP per request. Remember **Residential Lite is rotating-only**. See [Rotating & sticky sessions](/docs/sessions).

## Geo-targeting not working

Confirm the targeting depth you're asking for is **available on your product**. Residential Lite and Unlimited Residential are **country-level only**, Premium Unlimited Residential supports country, or one US state, city or ISP; Datacenter, Shared ISP, and IPv6 products are country-level (and US-only where noted). See [Geo-targeting](/docs/geo-targeting).

> **Still stuck?** [Talk to a proxy expert](/contact) — support is 24/7.


---

# FAQ
Source: https://www.flashproxy.com/docs/faq

# FAQ

## Is using FlashProxy legal?

Proxies are a legitimate tool. You're responsible for using FlashProxy lawfully and within our [Acceptable Use Policy](/docs/acceptable-use) — the prohibited-use boundaries are set out in Section 9 of the [Terms](/terms). Breaking them can lead to suspension or termination.

## Are the IPs ethically sourced?

Yes. FlashProxy's residential IP pool is built on **ISP partnerships** rather than consumer-side SDKs or malware-bundled proxy clients, with a documentable provenance chain.

## How does billing work?

It depends on the product:

- **Per-GB** for metered plans (Residential, Residential Lite, Datacenter, Mobile, Shared ISP, IPv6).
- **Flat / unmetered (throughput-throttled)** for Unlimited Residential and Premium Unlimited Residential.
- **Per-IP** for Dedicated ISP.

Pay by **card** or **crypto**. See [pricing](/pricing/residential).

## What's the difference between the products?

Each product trades off IP type, speed, geo depth, and price differently. See the per-product guides linked from the [docs home](/docs/index), or the [pricing](/pricing/residential) pages.

## Is IPv6 supported?

Yes — **IPv6 Residential** and **IPv6 Datacenter** (US). See their product guides.

## What's a sticky session?

A session that keeps the **same IP** across all its requests, configurable from **1 minute up to 2 hours**. The alternative is **rotating** — a fresh IP per request. See [Sessions](/docs/sessions).

## How do I rotate IPs?

Use a **rotating** session — every request gets a fresh IP automatically. See [Sessions](/docs/sessions).

## Is there a free trial?

The **14-day free trial is currently paused and returning soon**. Unlimited Residential is available via a $20 trial, and Premium Unlimited Residential via a 1-hour trial ($20 at 200 Mbps, $35 at 1 Gbps).

> **Need more?** [Talk to a proxy expert](/contact) — 24/7 support.


---

# Acceptable use
Source: https://www.flashproxy.com/docs/acceptable-use

# Acceptable Use Policy

FlashProxy's Acceptable Use Policy is **Section 9 of the [Terms of Service](/terms)**. Using FlashProxy means agreeing to it.

## Prohibited uses

You may not use FlashProxy for:

- Illegal activity of any kind
- Unauthorized access to systems or accounts
- Distributing malware
- Spam, phishing, or fraud
- Harassment
- Intellectual-property infringement
- Harm to minors
- Circumventing security controls
- Interfering with or disrupting systems
- Violating the terms of service of the targets you connect to
- Unauthorized resale of the service
- Sharing your credentials

## Consequences

Violations lead to **immediate suspension or termination of your account without refund** (subject to the KYC-decline carve-out in the [KYC Policy](/kyc-policy)). FlashProxy reserves the right to refer matters to law enforcement.

> **Report abuse:** email [legal@flash.io](mailto:legal@flash.io). See the full policy at [/terms](/terms).


---

# Compliance & privacy
Source: https://www.flashproxy.com/docs/compliance

# Compliance

A public summary of how FlashProxy handles legal and data-protection obligations.

## Jurisdiction

FlashProxy is operated by **FlashProxy B.V.**, a Dutch private limited company incorporated in the **Netherlands**.

## GDPR

FlashProxy is **GDPR compliant**. Data-subject rights are honored, sub-processors are listed in the [Privacy Policy](/privacy), and Standard Contractual Clauses (SCCs) cover international transfers.

## KYC

FlashProxy operates a tiered KYC model — baseline email verification for all users, with risk-triggered escalated verification. Full details are in the public [KYC Policy](/kyc-policy).

## Data retention

| Data             | Retention                    |
| ---------------- | ---------------------------- |
| Account data     | Account lifetime + 2 years   |
| Transactions     | 7 years (Dutch tax law)      |
| Security records | 6 months – 2 years           |
| KYC documents    | Account lifetime + 12 months |

See the [Privacy Policy](/privacy) for the full statement.

## Legal documents

- [Terms of Service](/terms) — includes the Refund Policy and Acceptable Use Policy
- [Privacy Policy](/privacy)
- [Cookie Policy](/cookies)
- [KYC Policy](/kyc-policy)

> **Questions?** Contact [legal@flash.io](mailto:legal@flash.io) for legal, privacy, or data-subject requests.