# Authentication
Source: https://docs.proxies.fo/authentication

Credentials and targeting modifiers across the Proxies.fo network

All Proxies.fo endpoints use **user : password authentication** over HTTP, HTTPS, and SOCKS5. Targeting is controlled by modifiers appended to your username — no API, no config file, no SDK.

## Credential format

```
Username: <base_user>[-<modifier>-<value>][-<modifier>-<value>]...
Password: <your_account_password>
```

Your base username and password live in the [dashboard](https://app.proxies.fo/signin). Modifiers are optional — without them, the network picks an IP at random from the pool for whichever regional gateway you connected to.

## Real-world examples

Residential — targeting Westlake Village:

```
pr-eu.proxies.fo:13337:adminpcowe-country-us-city-westlakevillage:maskxsndyb
```

Residential — targeting AT\&T (ASN 7018):

```
pr-eu.proxies.fo:13337:adminpcowe-country-us-asn-7018:maskxsndyb
```

Mobile — US carrier IP:

```
pr-eu.proxies.fo:13337:adminmobile-country-us:mobpass123
```

Datacenter — sticky session for 300 seconds:

```
dcp-eu.proxies.fo:10808:adminywsve-session-5s5d4xud-duration-300:jwqcoz4lfm
```

Shared ISP — rotating:

```
pr-eu.proxies.fo:13337:adminshared:sharedpass
```

## Modifier reference

| Modifier             | Products                                    | Purpose                                  | Example                    |
| -------------------- | ------------------------------------------- | ---------------------------------------- | -------------------------- |
| `country-<code>`     | Residential, Mobile                         | ISO 3166-1 alpha-2 country code          | `country-us`, `country-de` |
| `state-<code>`       | Residential                                 | Regional subdivision code (optional)     | `state-ny`, `state-ca`     |
| `city-<n>`           | Residential                                 | Specific city (with or without `state-`) | `city-westlakevillage`     |
| `asn-<number>`       | Residential, Mobile                         | Target a specific ISP / carrier by ASN   | `asn-7018` (AT\&T)         |
| `session-<id>`       | Residential, Mobile, Datacenter, Shared ISP | Sticky session ID                        | `session-5s5d4xud`         |
| `ttl-<minutes>`      | Residential, Mobile, Shared ISP             | Session lifetime in **minutes**          | `ttl-15`                   |
| `duration-<seconds>` | Datacenter                                  | Session lifetime in **seconds**          | `duration-300`             |

Residential and Mobile use `ttl-<minutes>`. Datacenter uses `duration-<seconds>`. Don't mix them — passing `ttl-` to a DC endpoint or `duration-` to residential is ignored or rejected.

**Mobile** does not support `state-` or `city-` — only `country-` and `asn-` for carrier targeting.

**Datacenter** does not support country / state / city / ASN — the regional endpoint determines geography.

**Dedicated ISP** uses static assigned IPs, so no targeting modifiers apply.

**Shared ISP** uses `session-` and `ttl-` for sticky rotation but doesn't take geo modifiers — region is set by which endpoint (`pr-us` or `pr-eu`) you connect to.

## Plan-based routing

Residential, Mobile, and Shared ISP all connect to the same gateway hostnames (`pr-us.proxies.fo`, `pr-eu.proxies.fo`, plus `pr-sg.proxies.fo` for residential only) on port `13337`. Your **plan type determines which pool serves your request** — there's no port switch or product modifier.

A username with a residential plan exits through residential IPs. A mobile plan username exits through mobile IPs. Same endpoint, different pools.

## Targeting granularity (residential)

| Target                        | Username format                                  |
| ----------------------------- | ------------------------------------------------ |
| Random IP, any country        | `adminpcowe`                                     |
| Any US IP                     | `adminpcowe-country-us`                          |
| New York state                | `adminpcowe-country-us-state-ny`                 |
| Specific city (state skipped) | `adminpcowe-country-us-city-westlakevillage`     |
| Specific city within state    | `adminpcowe-country-us-state-ca-city-pleasanton` |
| Specific ISP (AT\&T)          | `adminpcowe-country-us-asn-7018`                 |
| ISP + city combined           | `adminpcowe-country-us-city-pleasanton-asn-7922` |

## ASN targeting

`asn-<number>` pins your IP to a specific ISP (residential) or carrier (mobile) by Autonomous System Number.

Common US ASNs:

| ASN   | ISP / Carrier             |
| ----- | ------------------------- |
| 7018  | AT\&T                     |
| 7922  | Comcast                   |
| 701   | Verizon                   |
| 20115 | Charter / Spectrum        |
| 22773 | Cox                       |
| 209   | CenturyLink               |
| 6167  | Verizon Wireless (mobile) |
| 21928 | T-Mobile USA (mobile)     |

Find the ASN for any IP using `whois`, [bgp.he.net](https://bgp.he.net), or [ipinfo.io](https://ipinfo.io).

## Session IDs

Use alphanumeric strings, 6–16 characters. Same ID = same IP.

Good examples: `5s5d4xud`, `bot-nyc-01`, `a4f8c2e1`

Avoid:

* Spaces or special characters (`$`, `@`, `:`, `/`) — these break URL parsing
* Sequential IDs (`session-1`, `session-2`) if you want session isolation
* Reusing IDs across unrelated workflows

## Protocols

| Product         |  HTTP / HTTPS  |     SOCKS5     | UDP | HTTP3 |
| --------------- | :------------: | :------------: | :-: | :---: |
| Residential     |        ✓       |        ✓       |  ✓  |   —   |
| Mobile          |        ✓       |        ✓       |  —  |   —   |
| Datacenter      |        ✓       |        ✓       |  ✓  |   —   |
| ISP (dedicated) | ✓ (port 61234) | ✓ (port 62234) |  —  |   —   |
| Shared ISP      |        ✓       |        ✓       |  ✓  |   ✓   |

## Rotating credentials

If credentials leak, rotate from the dashboard under **Account → Security**. Existing sessions drop within 60 seconds.

Never commit credentials to version control.


# Datacenter IPv4
Source: https://docs.proxies.fo/datacenter/ipv4

Dedicated IPv4 datacenter proxies across EU and US

IPv4 datacenter proxies are dedicated IPv4 addresses served from the EU and US gateways. Fast, predictable, priced per day.

## Specs

| Attribute      | Value                                |
| -------------- | ------------------------------------ |
| Address family | IPv4 only                            |
| Locations      | EU, US                               |
| Protocols      | HTTP, HTTPS, SOCKS5, UDP             |
| Authentication | Username : password                  |
| Rotation modes | Per-request rotating, sticky session |
| Uplink         | 10 Gbps                              |
| Billing        | Per day, unlimited bandwidth         |

## Endpoints

| Region        | Host                | Port    |
| ------------- | ------------------- | ------- |
| United States | `dcp-us.proxies.fo` | `10808` |
| Europe        | `dcp-eu.proxies.fo` | `10808` |

The endpoint is shared with the IPv6 product. Your IPv4 plan credentials route you to the IPv4 pool automatically.

## Rotating (default)

```
dcp-eu.proxies.fo:10808:adminywsve:jwqcoz4lfm
```

```bash theme={null}
curl -x "http://adminywsve:jwqcoz4lfm@dcp-eu.proxies.fo:10808" https://api.ipify.org
curl -x "http://adminywsve:jwqcoz4lfm@dcp-eu.proxies.fo:10808" https://api.ipify.org
# Each call returns a different IPv4
```

## Sticky sessions

`session-<id>` holds the same IP; `duration-<seconds>` controls how long.

```
dcp-eu.proxies.fo:10808:adminywsve-session-5s5d4xud-duration-300:jwqcoz4lfm
```

300 seconds = 5 minutes. Max duration depends on your plan.

## Code examples

<CodeGroup>
  ```python Python theme={null}
  import requests

  proxy = "http://adminywsve:jwqcoz4lfm@dcp-eu.proxies.fo:10808"
  proxies = {"http": proxy, "https": proxy}

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

  ```javascript Node.js theme={null}
  import axios from "axios";
  import { HttpsProxyAgent } from "https-proxy-agent";

  const agent = new HttpsProxyAgent(
    "http://adminywsve:jwqcoz4lfm@dcp-eu.proxies.fo:10808"
  );

  const { data } = await axios.get("https://api.ipify.org", {
    httpAgent: agent,
    httpsAgent: agent,
  });

  console.log(data);
  ```

  ```go Go theme={null}
  package main

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

  func main() {
  	proxyURL, _ := url.Parse("http://adminywsve:jwqcoz4lfm@dcp-eu.proxies.fo:10808")
  	client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)}}

  	resp, _ := client.Get("https://api.ipify.org")
  	defer resp.Body.Close()
  	body, _ := io.ReadAll(resp.Body)
  	fmt.Println(string(body))
  }
  ```

  ```bash curl theme={null}
  curl -x "http://adminywsve:jwqcoz4lfm@dcp-eu.proxies.fo:10808" https://api.ipify.org
  ```
</CodeGroup>

## High-concurrency scraping

<CodeGroup>
  ```python Python (asyncio + httpx) theme={null}
  import asyncio, httpx

  proxy = "http://adminywsve:jwqcoz4lfm@dcp-eu.proxies.fo:10808"

  async def fetch(client, url):
      r = await client.get(url)
      return r.status_code

  async def main():
      async with httpx.AsyncClient(proxies=proxy, timeout=30) as client:
          urls = ["https://example.com"] * 100
          results = await asyncio.gather(*(fetch(client, u) for u in urls))
          print(results)

  asyncio.run(main())
  ```

  ```javascript Node.js (Promise.all) theme={null}
  import axios from "axios";
  import { HttpsProxyAgent } from "https-proxy-agent";

  const agent = new HttpsProxyAgent(
    "http://adminywsve:jwqcoz4lfm@dcp-eu.proxies.fo:10808"
  );

  const client = axios.create({ httpAgent: agent, httpsAgent: agent });

  const urls = Array(100).fill("https://example.com");
  const results = await Promise.all(urls.map(u => client.get(u)));
  console.log(results.map(r => r.status));
  ```
</CodeGroup>

## SOCKS5 & UDP

<CodeGroup>
  ```bash SOCKS5 (curl) theme={null}
  curl --socks5-hostname "adminywsve:jwqcoz4lfm@dcp-eu.proxies.fo:10808" \
    https://api.ipify.org
  ```

  ```bash UDP via SOCKS5 theme={null}
  curl --socks5 "adminywsve:jwqcoz4lfm@dcp-eu.proxies.fo:10808" \
    --socks5-udp https://api.ipify.org
  ```
</CodeGroup>

UDP routing requires a SOCKS5 client that supports `UDP ASSOCIATE`. Use `curl`, `proxychains`, or `PySocks`.

## Quick-copy `host:port:user:pass`

```
dcp-eu.proxies.fo:10808:adminywsve:jwqcoz4lfm
dcp-eu.proxies.fo:10808:adminywsve-session-5s5d4xud-duration-300:jwqcoz4lfm
dcp-us.proxies.fo:10808:adminywsve:jwqcoz4lfm
```

## Pricing

IPv4 datacenter plans start at **\$7.50 / day** with unlimited bandwidth. See [proxies.fo/product-datacenter](https://proxies.fo/product-datacenter).


# Datacenter IPv6
Source: https://docs.proxies.fo/datacenter/ipv6

IPv6 datacenter proxies with unlimited threads

IPv6 datacenter proxies give you access to a vast IPv6 address space at low cost per connection. Ideal for high-concurrency workloads on targets that support IPv6.

## Specs

| Attribute      | Value                        |
| -------------- | ---------------------------- |
| Address family | IPv6 only                    |
| Allocation     | 2 × /29 IPv6 subnets         |
| Locations      | EU, US                       |
| Protocols      | HTTP, HTTPS, SOCKS5, UDP     |
| Authentication | Username : password          |
| Threads        | Unlimited                    |
| Uplink         | 10 Gbps                      |
| Billing        | Per day, unlimited bandwidth |

## Endpoints

| Region        | Host                | Port    |
| ------------- | ------------------- | ------- |
| United States | `dcp-us.proxies.fo` | `10808` |
| Europe        | `dcp-eu.proxies.fo` | `10808` |

Shared with the IPv4 product. Your IPv6 plan credentials route you to the IPv6 pool automatically.

## Checking your egress

Use `api6.ipify.org` — it's IPv6-only, so a successful response confirms IPv6 egress.

```bash theme={null}
curl -x "http://adminywsve:jwqcoz4lfm@dcp-eu.proxies.fo:10808" https://api6.ipify.org
# Returns: 2a0f:abcd:...
```

## Rotating (default)

```
dcp-eu.proxies.fo:10808:adminywsve:jwqcoz4lfm
```

## Sticky sessions

Same modifiers as IPv4 — `session-<id>` plus optional `duration-<seconds>`:

```
dcp-eu.proxies.fo:10808:adminywsve-session-5s5d4xud-duration-300:jwqcoz4lfm
```

## IPv6 target compatibility

Before committing a workload, confirm the target supports IPv6:

```bash theme={null}
dig AAAA target-site.com +short
```

No AAAA record = IPv4-only target. Use the [IPv4 product](/datacenter/ipv4) instead. Most major CDNs (Cloudflare, Fastly, Google, AWS) support IPv6 transparently.

## Code examples

<CodeGroup>
  ```python Python theme={null}
  import requests

  proxy = "http://adminywsve:jwqcoz4lfm@dcp-eu.proxies.fo:10808"
  proxies = {"http": proxy, "https": proxy}

  print(requests.get("https://api6.ipify.org", proxies=proxies, timeout=30).text)
  ```

  ```javascript Node.js theme={null}
  import axios from "axios";
  import { HttpsProxyAgent } from "https-proxy-agent";

  const agent = new HttpsProxyAgent(
    "http://adminywsve:jwqcoz4lfm@dcp-eu.proxies.fo:10808"
  );

  const { data } = await axios.get("https://api6.ipify.org", {
    httpAgent: agent,
    httpsAgent: agent,
  });

  console.log(data);
  ```

  ```bash curl theme={null}
  curl -x "http://adminywsve:jwqcoz4lfm@dcp-eu.proxies.fo:10808" https://api6.ipify.org
  ```
</CodeGroup>

## Unlimited-thread workload

IPv6 has no thread cap — scale concurrency as high as your client can handle.

```python theme={null}
import concurrent.futures, requests

proxy = "http://adminywsve:jwqcoz4lfm@dcp-eu.proxies.fo:10808"
proxies = {"http": proxy, "https": proxy}

def fetch():
    return requests.get("https://api6.ipify.org", proxies=proxies, timeout=15).text

with concurrent.futures.ThreadPoolExecutor(max_workers=500) as pool:
    results = list(pool.map(lambda _: fetch(), range(500)))

print(f"Got {len(set(results))} unique IPv6 addresses across 500 requests")
```

## Common issues

<AccordionGroup>
  <Accordion title="'No route to host' on a target">
    The target doesn't have an AAAA record — it's IPv4-only. Switch to the IPv4 product.
  </Accordion>

  <Accordion title="Getting IPv4 back from a test endpoint">
    Use `api6.ipify.org` instead of `api.ipify.org`.
  </Accordion>
</AccordionGroup>

## Quick-copy `host:port:user:pass`

```
dcp-eu.proxies.fo:10808:adminywsve:jwqcoz4lfm
dcp-eu.proxies.fo:10808:adminywsve-session-5s5d4xud-duration-300:jwqcoz4lfm
dcp-us.proxies.fo:10808:adminywsve:jwqcoz4lfm
```

## Pricing

IPv6 plans start at **\$10 / day** with unlimited threads and bandwidth. See [proxies.fo/product-IPv6](https://proxies.fo/product-IPv6).


# Datacenter Overview
Source: https://docs.proxies.fo/datacenter/overview

High-speed IPv4 and IPv6 datacenter proxies

Datacenter proxies give you high-throughput IPs on a 10 Gbps uplink. When your target doesn't discriminate by IP type, datacenter outperforms residential on both speed and cost per request.

**IPv4 and IPv6 are separate products** with their own plans, IP pools, and credentials. Your username determines which pool serves your requests — you don't pick address family at connection time.

## Products

<CardGroup>
  <Card title="Datacenter IPv4" icon="server" href="/datacenter/ipv4">
    Dedicated IPv4 addresses, rotating or sticky. High success rate on IPv4-only targets.
  </Card>

  <Card title="Datacenter IPv6" icon="network-wired" href="/datacenter/ipv6">
    IPv6 subnets with unlimited threads. Cheaper per request for IPv6-compatible targets.
  </Card>
</CardGroup>

## Shared endpoints

Both products connect through the same hosts and port:

| Region        | Host                | Port    |
| ------------- | ------------------- | ------- |
| United States | `dcp-us.proxies.fo` | `10808` |
| Europe        | `dcp-eu.proxies.fo` | `10808` |

Which pool serves your request is determined by your credentials. An IPv4 plan username exits through IPv4; an IPv6 plan username exits through IPv6. No modifier or port switch — the account type is the signal.

## Authentication format

Both products use the same auth and session modifiers:

| Modifier              | Purpose                                   |
| --------------------- | ----------------------------------------- |
| *(none)*              | Rotate on every request                   |
| `-session-<id>`       | Sticky session — same IP for the duration |
| `-duration-<seconds>` | How long to hold the sticky IP            |

```
# Rotating
dcp-eu.proxies.fo:10808:adminywsve:jwqcoz4lfm

# Sticky, 5 minutes
dcp-eu.proxies.fo:10808:adminywsve-session-5s5d4xud-duration-300:jwqcoz4lfm
```

Datacenter doesn't support country / state / city / ASN targeting. The regional endpoint determines geography. For country-level control, use [Residential](/residential/overview).

## Protocols

Both IPv4 and IPv6 support HTTP, HTTPS, SOCKS5, and UDP on the same port.

## When to pick datacenter

* Targets that don't actively block datacenter ranges
* Speed and throughput matter more than IP type
* You want predictable daily pricing instead of per-GB billing
* You need UDP support (DNS, game servers, WebRTC)

If your target flags datacenter IPs, use [Residential](/residential/overview) or [Mobile](/mobile/overview).


# Error Codes
Source: https://docs.proxies.fo/error-codes

HTTP responses and SOCKS5 reply codes from the Proxies.fo network

Error codes differ by product. Residential and Mobile have a richer set of plan-limit and targeting errors; Datacenter has a tighter set focused on authentication and upstream failures plus SOCKS5 reply codes.

## Residential & Mobile

### Authentication & request errors

<ResponseField name="400 Bad Request" type="standard">
  Your HTTP request is malformed. Check your proxy client is sending a valid HTTP CONNECT or request line.
</ResponseField>

<ResponseField name="407 Proxy Authentication Required" type="standard">
  Username or password is wrong, or your targeting modifiers contain an unrecognised value.

  Body: `Incorrect username or password`
</ResponseField>

<ResponseField name="417 Expectation Failed" type="standard">
  Your client sent an `Expect:` header the proxy can't satisfy. Remove it or switch libraries.
</ResponseField>

### Plan limit errors

<ResponseField name="452 Bandwidth Exceeded" type="custom">
  You've used all the bandwidth on your plan. Top up or upgrade from the dashboard.

  Body: `exceeded bandwidth limit`
</ResponseField>

<ResponseField name="453 Thread Limit Exceeded" type="custom">
  You're making more concurrent connections than your plan allows. Lower concurrency or upgrade.

  Body: `exceeded threads limit`
</ResponseField>

### Targeting errors

<ResponseField name="454 Invalid Country Code" type="custom">
  The `country-<code>` modifier isn't a recognised country. Use lowercase ISO 3166-1 alpha-2 codes (e.g. `us`, `de`, `jp`).

  Body: `invalid country code`
</ResponseField>

<ResponseField name="454 Invalid State Code" type="custom">
  The `state-<code>` value isn't recognised for the country (residential only). Use the standard regional subdivision code.

  Body: `invalid state code`
</ResponseField>

<ResponseField name="454 Invalid City Code" type="custom">
  The `city-<n>` value isn't recognised, or no IPs are available (residential only). City names should be lowercase and concatenated (`westlakevillage`).

  Body: `invalid city code`
</ResponseField>

<ResponseField name="454 Invalid ASN" type="custom">
  The `asn-<number>` value isn't in the supported set, or no IPs are available for the combined geo + ASN targeting. Verify the ASN with `whois` or bgp.he.net.

  Body: `invalid asn`
</ResponseField>

<ResponseField name="455 Invalid TTL" type="custom">
  The `ttl-<minutes>` value is outside the allowed range. TTL must be a positive integer within the supported lifetime range.

  Body: `invalid ttl`
</ResponseField>

### Upstream errors

<ResponseField name="502 Bad Gateway" type="standard">
  The target site couldn't be reached. DNS failure, target-side refusal, or a transient network issue. Retry with backoff.
</ResponseField>

<ResponseField name="500 Internal Server Error" type="standard">
  An unexpected error occurred. If you see this repeatedly, reach out via the [dashboard](https://app.proxies.fo/signin) with a timestamp.
</ResponseField>

<ResponseField name="503 Service Unavailable" type="standard">
  A transient internal error. Retry with backoff — if it persists, contact support.
</ResponseField>

### Residential & Mobile summary

| Code | Meaning                              | Action                               |
| ---- | ------------------------------------ | ------------------------------------ |
| 400  | Bad request                          | Fix client request format            |
| 407  | Auth failed                          | Check username / password            |
| 417  | Expectation failed                   | Remove `Expect:` header              |
| 452  | Bandwidth exhausted                  | Top up plan                          |
| 453  | Thread limit hit                     | Lower concurrency or upgrade         |
| 454  | Invalid country / state / city / ASN | Fix targeting modifier               |
| 455  | Invalid TTL                          | Use a valid `ttl-<minutes>` value    |
| 500  | Internal error                       | Contact support                      |
| 502  | Upstream unreachable                 | Retry with backoff                   |
| 503  | Service unavailable                  | Retry; contact support if persistent |

<Note>
  Mobile only accepts `country-` and `asn-` targeting, so `454 invalid state/city code` won't apply to mobile.
</Note>

***

## Datacenter (HTTP)

<ResponseField name="400 Bad Request" type="standard">
  Malformed authentication — typically a bad Base64-encoded `Proxy-Authorization` header. Your client is sending credentials in the wrong format. Regenerate or re-encode.
</ResponseField>

<ResponseField name="407 Proxy Authentication Required" type="standard">
  Missing, invalid, expired, or capped credentials. Common causes: wrong username/password, expired session credentials, plan bandwidth or thread limit reached, account suspended.
</ResponseField>

<ResponseField name="500 Internal Server Error" type="standard">
  Server-side error **after** authentication succeeded. Inspect the `X-Server-Error` response header for a more specific reason.

  ```
  curl -v -x "http://user:pass@dcp-eu.proxies.fo:10808" https://api.ipify.org
  # Look for: < X-Server-Error: <reason>
  ```
</ResponseField>

### Datacenter HTTP summary

| Code | Meaning                        | Action                                |
| ---- | ------------------------------ | ------------------------------------- |
| 400  | Bad auth encoding              | Check Base64 of `Proxy-Authorization` |
| 407  | Auth failed / expired / capped | Verify creds and plan status          |
| 500  | Post-auth server error         | Inspect `X-Server-Error` header       |

## Datacenter (SOCKS5)

SOCKS5 replies use single-byte reply codes. Most libraries surface these as descriptive errors automatically.

| Code | Meaning               | Action                                      |
| ---- | --------------------- | ------------------------------------------- |
| 0    | Succeeded             | —                                           |
| 1    | Network unreachable   | Retry with backoff                          |
| 2    | Host unreachable      | Check target availability                   |
| 3    | Connection refused    | Target rejected — check port / target state |
| 4    | Command not supported | Use `CONNECT` or `UDP ASSOCIATE` only       |

***

## Handling errors in code

<CodeGroup>
  ```python Python (residential / mobile) theme={null}
  import requests

  proxy = "http://adminpcowe-country-zz:maskxsndyb@pr-us.proxies.fo:13337"
  proxies = {"http": proxy, "https": proxy}

  try:
      r = requests.get("https://api.ipify.org", proxies=proxies, timeout=30)
      if r.status_code == 454:
          print("Targeting error:", r.text.strip())
      elif r.status_code == 452:
          print("Out of bandwidth — top up your plan")
      elif r.status_code == 453:
          print("Too many concurrent connections")
      elif r.status_code >= 500:
          print(f"Upstream issue ({r.status_code}) — retry with backoff")
      else:
          print(r.text)
  except requests.exceptions.ProxyError as e:
      print("Auth failed — check credentials:", e)
  ```

  ```python Python (datacenter) theme={null}
  import requests

  proxy = "http://adminywsve:jwqcoz4lfm@dcp-eu.proxies.fo:10808"
  proxies = {"http": proxy, "https": proxy}

  try:
      r = requests.get("https://api.ipify.org", proxies=proxies, timeout=30)
      if r.status_code == 500:
          print("Post-auth error:", r.headers.get("X-Server-Error", "unknown"))
      elif r.status_code == 407:
          print("Auth failed or plan capped — check dashboard")
      elif r.status_code == 400:
          print("Bad auth encoding — check Proxy-Authorization header")
      else:
          print(r.text)
  except requests.exceptions.ProxyError as e:
      print("Connection failed:", e)
  ```
</CodeGroup>

## Still stuck?

Best support is through the [dashboard](https://app.proxies.fo/signin) — fastest response time. You can also reach us on [Discord](https://discord.gg/proxy), [Telegram](https://t.me/prodigynet), or by email at [admin@proxies.fo](mailto:admin@proxies.fo). Include a request timestamp and the full response when reporting an issue.


# Welcome to Proxies.fo
Source: https://docs.proxies.fo/introduction

Premium proxy infrastructure for scraping, automation, and anonymous browsing

<img alt="Proxies.fo" />

## Skip the blocks. Scale without limits.

Proxies.fo provides premium proxies built for serious workloads — scraping, ad verification, price monitoring, SEO tracking, and anything else that needs clean IPs at scale.

<CardGroup>
  <Card title="Residential" icon="globe" href="/residential/overview">
    100M+ real home IPs across 180+ countries. Country, state, city & ASN targeting.
  </Card>

  <Card title="Mobile" icon="mobile-screen" href="/mobile/overview">
    Real 4G/5G carrier IPs. Country and ASN targeting on the same gateway as residential.
  </Card>

  <Card title="Datacenter" icon="server" href="/datacenter/overview">
    Dedicated IPv4 and IPv6 via shared endpoints in EU and US. High-throughput, low-latency.
  </Card>

  <Card title="ISP Proxies" icon="network-wired" href="/isp/overview">
    Premium static IPs on Tier 1 ISP networks. Dedicated or shared pool options.
  </Card>
</CardGroup>

## Why Proxies.fo

<CardGroup>
  <Card title="Verified Proxies" icon="shield-check">
    Every IP tested before it reaches you. Clean, reliable connections from the first request.
  </Card>

  <Card title="Highly Secure" icon="lock">
    Bank-grade encryption on every connection. Your data stays yours.
  </Card>

  <Card title="Global Coverage" icon="earth-americas">
    180+ countries on residential, plus dedicated EU and US datacenter pools.
  </Card>

  <Card title="100% Privacy" icon="user-secret">
    Strict no-log policy. Nothing you do on our network is stored, tracked, or shared.
  </Card>

  <Card title="Instant Setup" icon="bolt">
    Get running in minutes with username-based targeting. No API keys, no SDKs.
  </Card>

  <Card title="Dedicated Resources" icon="gauge-high">
    High-performance infrastructure on a 10 Gbps uplink. Built for scale.
  </Card>
</CardGroup>

## Network at a glance

| Metric                  | Value                                            |
| ----------------------- | ------------------------------------------------ |
| Uptime                  | 99.9%                                            |
| Countries (residential) | 180+                                             |
| Residential IPs         | 100M+                                            |
| Shared ISP pool         | 20,000 IPs                                       |
| Datacenter locations    | EU, US                                           |
| Mobile locations        | EU, US                                           |
| Avg response time       | \<0.1s                                           |
| Protocols               | HTTP / HTTPS / SOCKS5 / UDP / HTTP3 (Shared ISP) |

New to proxies? Start with the [Quickstart](/quickstart) to connect your first endpoint in under five minutes.


# Code Examples
Source: https://docs.proxies.fo/isp/examples

Snippets for dedicated and shared ISP

Examples for both ISP products. Dedicated ISP uses its own host on ports 61234/62234; Shared ISP uses the residential gateway on port 13337.

## Dedicated ISP — HTTP / HTTPS (port 61234)

<CodeGroup>
  ```python Python theme={null}
  import requests

  proxy = "http://adminywsve:jwqcoz4lfm@isp.proxies.fo:61234"
  proxies = {"http": proxy, "https": proxy}

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

  ```javascript Node.js theme={null}
  import axios from "axios";
  import { HttpsProxyAgent } from "https-proxy-agent";

  const agent = new HttpsProxyAgent(
    "http://adminywsve:jwqcoz4lfm@isp.proxies.fo:61234"
  );

  const { data } = await axios.get("https://api.ipify.org", {
    httpAgent: agent,
    httpsAgent: agent,
  });

  console.log(data);
  ```

  ```go Go theme={null}
  package main

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

  func main() {
  	proxyURL, _ := url.Parse("http://adminywsve:jwqcoz4lfm@isp.proxies.fo:61234")
  	client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)}}

  	resp, _ := client.Get("https://api.ipify.org")
  	defer resp.Body.Close()
  	body, _ := io.ReadAll(resp.Body)
  	fmt.Println(string(body))
  }
  ```

  ```bash curl theme={null}
  curl -x "http://adminywsve:jwqcoz4lfm@isp.proxies.fo:61234" https://api.ipify.org
  ```
</CodeGroup>

## Dedicated ISP — SOCKS5 (port 62234)

<CodeGroup>
  ```python Python theme={null}
  # pip install requests[socks]
  import requests

  proxy = "socks5://adminywsve:jwqcoz4lfm@isp.proxies.fo:62234"
  proxies = {"http": proxy, "https": proxy}

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

  ```bash curl theme={null}
  curl --socks5-hostname "adminywsve:jwqcoz4lfm@isp.proxies.fo:62234" \
    https://api.ipify.org
  ```
</CodeGroup>

## Shared ISP (port 13337)

<CodeGroup>
  ```python Python theme={null}
  import requests

  proxy = "http://adminshared:sharedpass@pr-eu.proxies.fo:13337"
  proxies = {"http": proxy, "https": proxy}

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

  ```bash curl theme={null}
  curl -x "http://adminshared:sharedpass@pr-eu.proxies.fo:13337" https://api.ipify.org
  ```

  ```bash SOCKS5 theme={null}
  curl --socks5-hostname "adminshared:sharedpass@pr-eu.proxies.fo:13337" \
    https://api.ipify.org
  ```
</CodeGroup>

## Browser automation (dedicated ISP)

Static IPs pair well with long-running browser sessions.

<CodeGroup>
  ```javascript Playwright theme={null}
  import { chromium } from "playwright";

  const browser = await chromium.launch({
    proxy: {
      server: "http://isp.proxies.fo:61234",
      username: "adminywsve",
      password: "jwqcoz4lfm",
    },
  });

  const page = await browser.newPage();
  await page.goto("https://api.ipify.org");
  console.log(await page.textContent("body"));
  await browser.close();
  ```

  ```javascript Puppeteer theme={null}
  import puppeteer from "puppeteer";

  const browser = await puppeteer.launch({
    args: ["--proxy-server=http://isp.proxies.fo:61234"],
  });
  const page = await browser.newPage();
  await page.authenticate({ username: "adminywsve", password: "jwqcoz4lfm" });
  await page.goto("https://api.ipify.org");
  console.log(await page.evaluate(() => document.body.innerText));
  await browser.close();
  ```
</CodeGroup>

## Quick-copy `host:port:user:pass`

```
# Dedicated ISP
isp.proxies.fo:61234:adminywsve:jwqcoz4lfm
isp.proxies.fo:62234:adminywsve:jwqcoz4lfm

# Shared ISP
pr-eu.proxies.fo:13337:adminshared:sharedpass
pr-us.proxies.fo:13337:adminshared:sharedpass
pr-eu.proxies.fo:13337:adminshared-session-5s5d4xud-ttl-15:sharedpass
```

## Need help?

Best support is through the [dashboard](https://app.proxies.fo/signin). You can also reach us on [Discord](https://discord.gg/proxy), [Telegram](https://t.me/prodigynet), or at [admin@proxies.fo](mailto:admin@proxies.fo).


# ISP Overview
Source: https://docs.proxies.fo/isp/overview

Premium static IPs on Tier 1 ISP networks

ISP proxies are static residential IPs hosted on Tier 1 ISP networks. You get the legitimacy of residential (low fraud score, real ISP-registered IP) combined with the speed and stability of datacenter (dedicated, no rotation, always-on).

We offer two ISP products:

<CardGroup>
  <Card title="Dedicated ISP" icon="user-lock" href="/isp/overview">
    Static IPs assigned exclusively to you. No rotation, full control.
  </Card>

  <Card title="Shared ISP" icon="users" href="/isp/shared">
    Tier 1 ISP IPs from a 20,000-strong shared pool. Lower cost, rotating or sticky.
  </Card>
</CardGroup>

## Dedicated ISP specs

| Attribute      | Value                                          |
| -------------- | ---------------------------------------------- |
| IP type        | Static residential on Tier 1 ISP               |
| Protocols      | HTTP / HTTPS (port 61234), SOCKS5 (port 62234) |
| Authentication | Username : password                            |
| Bandwidth      | 10 Gbps uplink, unlimited                      |
| Fraud score    | Low                                            |
| Rotation       | None — IPs are dedicated and static            |
| Billing        | Per IP                                         |

## Ports

| Protocol     | Port    |
| ------------ | ------- |
| HTTP / HTTPS | `61234` |
| SOCKS5       | `62234` |

The host for your dedicated ISP proxies is assigned per account from the dashboard. Each plan gives you one or more dedicated static IPs, each reachable on both ports.

## Authentication

Plain `user : password` — no modifiers. Each credential pair is bound to the IPs allocated to your plan.

```
adminywsve:jwqcoz4lfm
```

## Quick test

<CodeGroup>
  ```bash HTTP theme={null}
  curl -x "http://adminywsve:jwqcoz4lfm@isp.proxies.fo:61234" https://api.ipify.org
  ```

  ```bash SOCKS5 theme={null}
  curl --socks5-hostname "adminywsve:jwqcoz4lfm@isp.proxies.fo:62234" \
    https://api.ipify.org
  ```
</CodeGroup>

Use the host shown in your [dashboard](https://app.proxies.fo/signin).

## When to pick dedicated ISP

<CardGroup>
  <Card title="Account management at scale" icon="users">
    The same static IP makes repeated logins look consistent — useful for managing many accounts without tripping anomaly detection.
  </Card>

  <Card title="Long-running sessions" icon="clock">
    No rotation means no session drops. Run bots or automation that needs hours of continuous uptime on a single IP.
  </Card>

  <Card title="Sensitive targets" icon="shield">
    Tier 1 ISP-registered IPs look clean to fraud detection systems that flag datacenter ranges.
  </Card>

  <Card title="Speed + legitimacy" icon="bolt">
    Datacenter-grade speeds on the 10 Gbps uplink, with a residential-looking fingerprint.
  </Card>
</CardGroup>

## Pricing

Dedicated ISP plans start at **\$3 / IP**. See [proxies.fo/product-ISP](https://proxies.fo/product-ISP).

## Dedicated vs Shared

|               | Dedicated ISP                      | Shared ISP                        |
| ------------- | ---------------------------------- | --------------------------------- |
| IPs           | Assigned exclusively to you        | Drawn from a 20,000 shared pool   |
| Rotation      | None (static)                      | Rotating or sticky                |
| Pricing model | Per IP (from \$3)                  | Pool access (from \$180)          |
| Best for      | Account management, fixed identity | High-volume rotation on clean IPs |

Need rotation across many clean ISP IPs? See [Shared ISP](/isp/shared).


# Shared ISP
Source: https://docs.proxies.fo/isp/shared

Tier 1 ISP IPs from a 20,000-strong shared pool, rotating or sticky

Shared ISP gives you access to a large pool of Tier 1 ISP IPs — 20,000 addresses across US and EU — at a much lower cost than dedicated. Rotating or sticky, on the same gateway as residential.

## Specs

| Attribute      | Value                                |
| -------------- | ------------------------------------ |
| Pool size      | 20,000 ISP IPs                       |
| Locations      | US & EU pools                        |
| Protocols      | SOCKS5, HTTP, HTTP3 / UDP            |
| Authentication | Username : password                  |
| Rotation modes | Per-request rotating, sticky session |
| Uplink         | 10 Gbps                              |
| Uptime         | 99.9%                                |
| Billing        | Pool access                          |

## Endpoints

Shared ISP runs on the residential gateway hostnames, port `13337`. Your shared ISP plan routes you to the shared ISP pool automatically.

| Region        | Host               | Port    |
| ------------- | ------------------ | ------- |
| United States | `pr-us.proxies.fo` | `13337` |
| Europe        | `pr-eu.proxies.fo` | `13337` |

The endpoint you connect to determines which regional pool (US or EU) serves your request.

## Protocols

Shared ISP supports the widest protocol set of any product, including **HTTP3 / UDP**:

| Protocol     | Supported |
| ------------ | :-------: |
| HTTP / HTTPS |     ✓     |
| SOCKS5       |     ✓     |
| HTTP3 / UDP  |     ✓     |

## Rotating (default)

No modifiers = a fresh ISP IP from the pool per request:

```
pr-eu.proxies.fo:13337:adminshared:sharedpass
```

```bash theme={null}
curl -x "http://adminshared:sharedpass@pr-eu.proxies.fo:13337" https://api.ipify.org
curl -x "http://adminshared:sharedpass@pr-eu.proxies.fo:13337" https://api.ipify.org
# Different ISP IP each time
```

## Sticky sessions

Append `-session-<id>` to hold the same IP, with optional `-ttl-<minutes>`:

```
pr-eu.proxies.fo:13337:adminshared-session-5s5d4xud-ttl-15:sharedpass
```

Shared ISP uses `ttl-<minutes>` (like residential), not `duration-<seconds>`.

## Code examples

<CodeGroup>
  ```python Python theme={null}
  import requests

  proxy = "http://adminshared:sharedpass@pr-eu.proxies.fo:13337"
  proxies = {"http": proxy, "https": proxy}

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

  ```javascript Node.js theme={null}
  import axios from "axios";
  import { HttpsProxyAgent } from "https-proxy-agent";

  const agent = new HttpsProxyAgent(
    "http://adminshared:sharedpass@pr-eu.proxies.fo:13337"
  );

  const { data } = await axios.get("https://api.ipify.org", {
    httpAgent: agent,
    httpsAgent: agent,
  });

  console.log(data);
  ```

  ```bash curl theme={null}
  curl -x "http://adminshared:sharedpass@pr-eu.proxies.fo:13337" https://api.ipify.org
  ```

  ```bash SOCKS5 theme={null}
  curl --socks5-hostname "adminshared:sharedpass@pr-eu.proxies.fo:13337" \
    https://api.ipify.org
  ```
</CodeGroup>

## Sticky session example

<CodeGroup>
  ```python Python theme={null}
  import secrets, requests

  session_id = secrets.token_hex(4)
  username = f"adminshared-session-{session_id}-ttl-15"
  proxy = f"http://{username}:sharedpass@pr-eu.proxies.fo:13337"

  s = requests.Session()
  s.proxies = {"http": proxy, "https": proxy}

  for _ in range(3):
      print(s.get("https://api.ipify.org").text)
  ```

  ```javascript Node.js theme={null}
  import { randomBytes } from "crypto";
  import axios from "axios";
  import { HttpsProxyAgent } from "https-proxy-agent";

  const sessionId = randomBytes(4).toString("hex");
  const agent = new HttpsProxyAgent(
    `http://adminshared-session-${sessionId}-ttl-15:sharedpass@pr-eu.proxies.fo:13337`
  );

  const client = axios.create({ httpAgent: agent, httpsAgent: agent });

  for (let i = 0; i < 3; i++) {
    const { data } = await client.get("https://api.ipify.org");
    console.log(data);
  }
  ```
</CodeGroup>

## Quick-copy `host:port:user:pass`

```
pr-eu.proxies.fo:13337:adminshared:sharedpass
pr-us.proxies.fo:13337:adminshared:sharedpass
pr-eu.proxies.fo:13337:adminshared-session-5s5d4xud-ttl-15:sharedpass
```

## Pricing

Shared ISP starts at **\$180** for pool access. See [proxies.fo/product-shared-isp](https://proxies.fo/product-shared-isp).

## Shared vs Dedicated

|           | Shared ISP                        | Dedicated ISP                      |
| --------- | --------------------------------- | ---------------------------------- |
| IPs       | 20,000 shared pool                | Assigned exclusively to you        |
| Rotation  | Rotating or sticky                | None (static)                      |
| Protocols | SOCKS5, HTTP, HTTP3/UDP           | HTTP, HTTPS, SOCKS5                |
| Pricing   | Pool access (from \$180)          | Per IP (from \$3)                  |
| Best for  | High-volume rotation on clean IPs | Fixed identity, account management |

Need a fixed IP that never changes? See [Dedicated ISP](/isp/overview).


# Code Examples
Source: https://docs.proxies.fo/mobile/examples

Ready-to-use snippets for the mobile network

Mobile uses the same gateway and auth format as residential. No UDP or HTTP3 support — stick to HTTP, HTTPS, and SOCKS5.

## Basic request

<CodeGroup>
  ```python Python theme={null}
  import requests

  proxy = "http://adminmobile-country-us:mobpass123@pr-us.proxies.fo:13337"
  proxies = {"http": proxy, "https": proxy}

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

  ```javascript Node.js theme={null}
  import axios from "axios";
  import { HttpsProxyAgent } from "https-proxy-agent";

  const agent = new HttpsProxyAgent(
    "http://adminmobile-country-us:mobpass123@pr-us.proxies.fo:13337"
  );

  const { data } = await axios.get("https://api.ipify.org", {
    httpAgent: agent,
    httpsAgent: agent,
  });

  console.log(data);
  ```

  ```go Go theme={null}
  package main

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

  func main() {
  	proxyURL, _ := url.Parse("http://adminmobile-country-us:mobpass123@pr-us.proxies.fo:13337")
  	client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)}}

  	resp, _ := client.Get("https://api.ipify.org")
  	defer resp.Body.Close()
  	body, _ := io.ReadAll(resp.Body)
  	fmt.Println(string(body))
  }
  ```

  ```bash curl theme={null}
  curl -x "http://adminmobile-country-us:mobpass123@pr-us.proxies.fo:13337" \
    https://api.ipify.org
  ```
</CodeGroup>

## Carrier targeting

<CodeGroup>
  ```python Python theme={null}
  import requests

  # T-Mobile USA
  proxy = "http://adminmobile-country-us-asn-21928:mobpass123@pr-us.proxies.fo:13337"
  proxies = {"http": proxy, "https": proxy}

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

  ```bash curl theme={null}
  curl -x "http://adminmobile-country-us-asn-6167:mobpass123@pr-us.proxies.fo:13337" \
    https://api.ipify.org
  ```
</CodeGroup>

## Sticky session

<CodeGroup>
  ```python Python theme={null}
  import secrets, requests

  session_id = secrets.token_hex(4)
  username = f"adminmobile-country-us-session-{session_id}-ttl-15"
  proxy = f"http://{username}:mobpass123@pr-us.proxies.fo:13337"

  s = requests.Session()
  s.proxies = {"http": proxy, "https": proxy}

  for _ in range(3):
      print(s.get("https://api.ipify.org").text)
  ```

  ```javascript Node.js theme={null}
  import { randomBytes } from "crypto";
  import axios from "axios";
  import { HttpsProxyAgent } from "https-proxy-agent";

  const sessionId = randomBytes(4).toString("hex");
  const agent = new HttpsProxyAgent(
    `http://adminmobile-country-us-session-${sessionId}-ttl-15:mobpass123@pr-us.proxies.fo:13337`
  );

  const client = axios.create({ httpAgent: agent, httpsAgent: agent });

  for (let i = 0; i < 3; i++) {
    const { data } = await client.get("https://api.ipify.org");
    console.log(data);
  }
  ```
</CodeGroup>

## SOCKS5

```bash theme={null}
curl --socks5-hostname "adminmobile-country-us:mobpass123@pr-us.proxies.fo:13337" \
  https://api.ipify.org
```

## Quick-copy `host:port:user:pass`

```
pr-us.proxies.fo:13337:adminmobile-country-us:mobpass123
pr-eu.proxies.fo:13337:adminmobile-country-de:mobpass123
pr-us.proxies.fo:13337:adminmobile-country-us-asn-6167:mobpass123
pr-us.proxies.fo:13337:adminmobile-country-us-asn-21928:mobpass123
pr-us.proxies.fo:13337:adminmobile-country-us-session-5s5d4xud-ttl-15:mobpass123
```

## Need help?

Best support is through the [dashboard](https://app.proxies.fo/signin). You can also reach us on [Discord](https://discord.gg/proxy), [Telegram](https://t.me/prodigynet), or at [admin@proxies.fo](mailto:admin@proxies.fo).


# Mobile Overview
Source: https://docs.proxies.fo/mobile/overview

Real 4G/5G carrier IPs with country and ASN targeting

Mobile proxies route your traffic through real 4G/5G mobile carrier IPs. Because mobile IPs are shared by many real users behind carrier-grade NAT, they're among the hardest IPs for targets to block — making them ideal for the most aggressive anti-bot environments.

## Specs

| Attribute             | Value                                                   |
| --------------------- | ------------------------------------------------------- |
| IP type               | Real mobile carrier (4G/5G)                             |
| Targeting granularity | Country, ASN (carrier)                                  |
| Protocols             | HTTP, HTTPS, SOCKS5                                     |
| Authentication        | Username : password                                     |
| Rotation modes        | Per-request rotating, sticky session (configurable TTL) |
| Billing               | Per GB of bandwidth                                     |

<Note>
  Mobile does **not** support UDP or HTTP3, and does **not** support state or city targeting. Use `country-` and `asn-` only.
</Note>

## Endpoints

Mobile shares the residential gateway hostnames on port `13337`. Your mobile plan routes you to the mobile pool automatically.

| Region        | Host               | Port    |
| ------------- | ------------------ | ------- |
| United States | `pr-us.proxies.fo` | `13337` |
| Europe        | `pr-eu.proxies.fo` | `13337` |

<Note>
  Mobile is available on the US and EU gateways only. The `pr-sg` (APAC) gateway is residential-only.
</Note>

## Rotation modes

<CardGroup>
  <Card title="Rotating" icon="arrows-rotate">
    New mobile IP per request. Note that carrier NAT means many requests may share an egress IP regardless.
  </Card>

  <Card title="Sticky" icon="thumbtack">
    Hold the same mobile IP for a session via `session-<id>` and `ttl-<minutes>`.
  </Card>
</CardGroup>

## Pricing

Mobile plans start at **\$3 / GB**. See [proxies.fo/product-mobile-proxies](https://proxies.fo/product-mobile-proxies) for the full grid.

## When to pick mobile

* Targets that block residential and datacenter IPs
* Mobile-first platforms (apps, social media) where mobile IPs look most natural
* Carrier-specific testing (e.g. verifying content served to T-Mobile vs Verizon users)
* The strongest possible trust signal — mobile IPs rotate naturally and are rarely blocklisted

For broader geo precision (state, city), use [Residential](/residential/overview). For raw speed, use [Datacenter](/datacenter/overview).


# Targeting
Source: https://docs.proxies.fo/mobile/targeting

Route mobile traffic by country and carrier ASN

Mobile supports two targeting modifiers: `country-` and `asn-`. State and city targeting are not available on mobile.

## Format

```
Username: <base>-country-<cc>[-asn-<num>]
Password: <your password>
```

## Country targeting

Use any supported ISO 3166-1 alpha-2 country code. Lowercase.

```bash theme={null}
# US mobile IP
curl -x "http://adminmobile-country-us:mobpass123@pr-us.proxies.fo:13337" \
  https://api.ipify.org

# Germany mobile IP
curl -x "http://adminmobile-country-de:mobpass123@pr-eu.proxies.fo:13337" \
  https://api.ipify.org
```

## Carrier (ASN) targeting

`asn-<number>` pins your IP to a specific mobile carrier by its Autonomous System Number. Useful for testing content delivery, ad targeting, or app behaviour specific to a carrier's network.

```bash theme={null}
# Verizon Wireless (ASN 6167)
curl -x "http://adminmobile-country-us-asn-6167:mobpass123@pr-us.proxies.fo:13337" \
  https://api.ipify.org

# T-Mobile USA (ASN 21928)
curl -x "http://adminmobile-country-us-asn-21928:mobpass123@pr-us.proxies.fo:13337" \
  https://api.ipify.org
```

### Common US mobile carrier ASNs

| ASN   | Carrier          |
| ----- | ---------------- |
| 6167  | Verizon Wireless |
| 21928 | T-Mobile USA     |
| 20057 | AT\&T Mobility   |
| 22394 | Cellco / Verizon |

Find the ASN for any mobile IP using `whois`, [bgp.he.net](https://bgp.he.net), or [ipinfo.io](https://ipinfo.io).

<Note>
  Carrier ASN availability depends on the active pool. If an ASN has no IPs available, you'll receive a `454 invalid asn` response — drop the `asn-` modifier to use any carrier in that country.
</Note>

## Sessions

Mobile supports sticky sessions with the same `session-` + `ttl-` (minutes) format as residential:

```
adminmobile-country-us-session-5s5d4xud-ttl-15:mobpass123
```

See [Residential → Sessions](/residential/sessions) for the full mechanics — they're identical on mobile.

## Quick-copy `host:port:user:pass`

```
pr-us.proxies.fo:13337:adminmobile-country-us:mobpass123
pr-eu.proxies.fo:13337:adminmobile-country-de:mobpass123
pr-us.proxies.fo:13337:adminmobile-country-us-asn-6167:mobpass123
pr-us.proxies.fo:13337:adminmobile-country-us-asn-21928:mobpass123
pr-us.proxies.fo:13337:adminmobile-country-us-session-5s5d4xud-ttl-15:mobpass123
```


# Quickstart
Source: https://docs.proxies.fo/quickstart

Get your first Proxies.fo connection running in under 5 minutes

This guide walks you from signup to a working proxy request.

## 1. Create an account

<Steps>
  <Step title="Sign up">
    Head to [app.proxies.fo/signup](https://app.proxies.fo/signup). Email verification takes under a minute.
  </Step>

  <Step title="Pick a plan">
    * **Residential** — real home IPs, country/state/city/ASN targeting
    * **Mobile** — real 4G/5G carrier IPs, country and ASN targeting
    * **Datacenter** — high-speed IPv4 / IPv6 in EU and US
    * **ISP** — dedicated static IPs on Tier 1 networks
    * **Shared ISP** — Tier 1 ISP IPs from a shared pool, lower cost per IP
  </Step>

  <Step title="Fund and activate">
    Pay with card or crypto. Plans activate instantly.
  </Step>
</Steps>

## 2. Get your credentials

Open the dashboard at [app.proxies.fo](https://app.proxies.fo/signin). The **Generate** panel gives you a ready-to-use connection string:

```
pr-eu.proxies.fo:13337:adminpcowe:maskxsndyb
```

Format is `host:port:username:password` — the format most proxy testers and browser extensions expect.

## 3. Endpoints at a glance

Residential, Mobile, and Shared ISP **share the same gateway hostnames and port** (13337). Your plan type determines which pool you exit through.

| Product                  | Host(s)                                                    | Port    |
| ------------------------ | ---------------------------------------------------------- | ------- |
| Residential              | `pr-us.proxies.fo`, `pr-eu.proxies.fo`, `pr-sg.proxies.fo` | `13337` |
| Mobile                   | `pr-us.proxies.fo`, `pr-eu.proxies.fo`                     | `13337` |
| Shared ISP               | `pr-us.proxies.fo`, `pr-eu.proxies.fo`                     | `13337` |
| Datacenter (IPv4 & IPv6) | `dcp-us.proxies.fo`, `dcp-eu.proxies.fo`                   | `10808` |
| ISP — HTTP / HTTPS       | *from dashboard*                                           | `61234` |
| ISP — SOCKS5             | *from dashboard*                                           | `62234` |

Pick the regional host closest to your target for lowest latency. APAC traffic uses `pr-sg` (residential only).

## 4. Make your first request

<CodeGroup>
  ```bash Residential theme={null}
  curl -x "http://adminpcowe-country-us:maskxsndyb@pr-eu.proxies.fo:13337" \
    https://api.ipify.org
  ```

  ```bash Mobile theme={null}
  curl -x "http://adminmobile-country-us:mobpass123@pr-eu.proxies.fo:13337" \
    https://api.ipify.org
  ```

  ```bash Datacenter theme={null}
  curl -x "http://adminywsve:jwqcoz4lfm@dcp-eu.proxies.fo:10808" \
    https://api.ipify.org
  ```

  ```bash ISP theme={null}
  curl -x "http://adminywsve:jwqcoz4lfm@isp.proxies.fo:61234" https://api.ipify.org
  ```

  ```bash Shared ISP theme={null}
  curl -x "http://adminshared:sharedpass@pr-eu.proxies.fo:13337" \
    https://api.ipify.org
  ```
</CodeGroup>

The response should be the proxy's egress IP — not your local address.

## 5. Integrate into your code

<CodeGroup>
  ```python Python theme={null}
  import requests

  proxy = "http://adminpcowe-country-us:maskxsndyb@pr-eu.proxies.fo:13337"
  proxies = {"http": proxy, "https": proxy}

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

  ```javascript Node.js theme={null}
  import axios from "axios";
  import { HttpsProxyAgent } from "https-proxy-agent";

  const agent = new HttpsProxyAgent(
    "http://adminpcowe-country-us:maskxsndyb@pr-eu.proxies.fo:13337"
  );

  const { data } = await axios.get("https://api.ipify.org", {
    httpAgent: agent,
    httpsAgent: agent,
  });

  console.log(data);
  ```

  ```go Go theme={null}
  package main

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

  func main() {
  	proxyURL, _ := url.Parse("http://adminpcowe-country-us:maskxsndyb@pr-eu.proxies.fo:13337")
  	client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)}}

  	resp, _ := client.Get("https://api.ipify.org")
  	defer resp.Body.Close()
  	body, _ := io.ReadAll(resp.Body)
  	fmt.Println(string(body))
  }
  ```
</CodeGroup>

## Next steps

<CardGroup>
  <Card title="Targeting" icon="crosshairs" href="/residential/targeting">
    Country, state, city, and ASN targeting.
  </Card>

  <Card title="Sticky sessions" icon="thumbtack" href="/residential/sessions">
    Hold the same IP across multiple requests.
  </Card>

  <Card title="Authentication" icon="key" href="/authentication">
    Full reference for credentials and modifiers.
  </Card>

  <Card title="Error codes" icon="triangle-exclamation" href="/error-codes">
    HTTP and SOCKS5 response codes explained.
  </Card>
</CardGroup>


# Code Examples
Source: https://docs.proxies.fo/residential/examples

Ready-to-use snippets for the residential network

Copy-paste-ready examples for common languages and use cases.

## Basic request

<CodeGroup>
  ```python Python theme={null}
  import requests

  proxy = "http://adminpcowe:maskxsndyb@pr-eu.proxies.fo:13337"
  proxies = {"http": proxy, "https": proxy}

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

  ```javascript Node.js theme={null}
  import axios from "axios";
  import { HttpsProxyAgent } from "https-proxy-agent";

  const agent = new HttpsProxyAgent(
    "http://adminpcowe:maskxsndyb@pr-eu.proxies.fo:13337"
  );

  const { data } = await axios.get("https://api.ipify.org", {
    httpAgent: agent,
    httpsAgent: agent,
  });

  console.log(data);
  ```

  ```go Go theme={null}
  package main

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

  func main() {
  	proxyURL, _ := url.Parse("http://adminpcowe:maskxsndyb@pr-eu.proxies.fo:13337")
  	client := &http.Client{
  		Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)},
  		Timeout:   30 * time.Second,
  	}

  	resp, _ := client.Get("https://api.ipify.org")
  	defer resp.Body.Close()
  	body, _ := io.ReadAll(resp.Body)
  	fmt.Println(string(body))
  }
  ```

  ```php PHP theme={null}
  <?php
  $ch = curl_init("https://api.ipify.org");
  curl_setopt_array($ch, [
      CURLOPT_PROXY          => "pr-eu.proxies.fo:13337",
      CURLOPT_PROXYUSERPWD   => "adminpcowe:maskxsndyb",
      CURLOPT_PROXYTYPE      => CURLPROXY_HTTP,
      CURLOPT_RETURNTRANSFER => true,
      CURLOPT_TIMEOUT        => 30,
  ]);
  echo curl_exec($ch);
  curl_close($ch);
  ```

  ```bash curl theme={null}
  curl -x "http://adminpcowe:maskxsndyb@pr-eu.proxies.fo:13337" https://api.ipify.org
  ```
</CodeGroup>

## Rotating IP per request

<CodeGroup>
  ```python Python theme={null}
  import requests

  proxy = "http://adminpcowe:maskxsndyb@pr-eu.proxies.fo:13337"
  proxies = {"http": proxy, "https": proxy}

  for _ in range(5):
      print(requests.get("https://api.ipify.org", proxies=proxies).text)
  ```

  ```javascript Node.js theme={null}
  import axios from "axios";
  import { HttpsProxyAgent } from "https-proxy-agent";

  const agent = new HttpsProxyAgent(
    "http://adminpcowe:maskxsndyb@pr-eu.proxies.fo:13337"
  );

  for (let i = 0; i < 5; i++) {
    const { data } = await axios.get("https://api.ipify.org", {
      httpAgent: agent,
      httpsAgent: agent,
    });
    console.log(data);
  }
  ```
</CodeGroup>

## Sticky session with city targeting

<CodeGroup>
  ```python Python theme={null}
  import secrets, requests

  session_id = secrets.token_hex(4)
  username = f"adminpcowe-country-us-city-westlakevillage-session-{session_id}-ttl-15"
  proxy = f"http://{username}:maskxsndyb@pr-eu.proxies.fo:13337"

  s = requests.Session()
  s.proxies = {"http": proxy, "https": proxy}

  for _ in range(3):
      print(s.get("https://api.ipify.org").text)
  ```

  ```javascript Node.js theme={null}
  import { randomBytes } from "crypto";
  import axios from "axios";
  import { HttpsProxyAgent } from "https-proxy-agent";

  const sessionId = randomBytes(4).toString("hex");
  const agent = new HttpsProxyAgent(
    `http://adminpcowe-country-us-city-westlakevillage-session-${sessionId}-ttl-15:maskxsndyb@pr-eu.proxies.fo:13337`
  );

  const client = axios.create({ httpAgent: agent, httpsAgent: agent });

  for (let i = 0; i < 3; i++) {
    const { data } = await client.get("https://api.ipify.org");
    console.log(data);
  }
  ```
</CodeGroup>

## Concurrent scraping

<CodeGroup>
  ```python Python theme={null}
  import concurrent.futures, requests

  proxy = "http://adminpcowe-country-us:maskxsndyb@pr-us.proxies.fo:13337"
  proxies = {"http": proxy, "https": proxy}

  def fetch(url):
      r = requests.get(url, proxies=proxies, timeout=30)
      return r.status_code

  urls = ["https://api.ipify.org"] * 20

  with concurrent.futures.ThreadPoolExecutor(max_workers=20) as pool:
      for status in pool.map(fetch, urls):
          print(status)
  ```

  ```javascript Node.js theme={null}
  import axios from "axios";
  import { HttpsProxyAgent } from "https-proxy-agent";

  const agent = new HttpsProxyAgent(
    "http://adminpcowe-country-us:maskxsndyb@pr-us.proxies.fo:13337"
  );

  const client = axios.create({ httpAgent: agent, httpsAgent: agent, timeout: 30000 });

  const results = await Promise.all(
    Array.from({ length: 20 }, () => client.get("https://api.ipify.org"))
  );

  for (const r of results) console.log(r.data);
  ```
</CodeGroup>

## SOCKS5

<CodeGroup>
  ```python Python theme={null}
  # pip install requests[socks]
  import requests

  proxy = "socks5://adminpcowe-country-us:maskxsndyb@pr-us.proxies.fo:13337"
  proxies = {"http": proxy, "https": proxy}

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

  ```bash curl theme={null}
  curl --socks5-hostname "adminpcowe-country-us:maskxsndyb@pr-us.proxies.fo:13337" \
    https://api.ipify.org
  ```
</CodeGroup>

## Playwright & Puppeteer

<CodeGroup>
  ```javascript Playwright theme={null}
  import { chromium } from "playwright";

  const browser = await chromium.launch({
    proxy: {
      server: "http://pr-us.proxies.fo:13337",
      username: "adminpcowe-country-us-city-westlakevillage",
      password: "maskxsndyb",
    },
  });

  const page = await browser.newPage();
  await page.goto("https://api.ipify.org");
  console.log(await page.textContent("body"));
  await browser.close();
  ```

  ```javascript Puppeteer theme={null}
  import puppeteer from "puppeteer";

  const browser = await puppeteer.launch({
    args: ["--proxy-server=http://pr-us.proxies.fo:13337"],
  });
  const page = await browser.newPage();
  await page.authenticate({
    username: "adminpcowe-country-us-city-westlakevillage",
    password: "maskxsndyb",
  });
  await page.goto("https://api.ipify.org");
  console.log(await page.evaluate(() => document.body.innerText));
  await browser.close();
  ```
</CodeGroup>

## Quick-copy `host:port:user:pass`

```
pr-eu.proxies.fo:13337:adminpcowe:maskxsndyb
pr-eu.proxies.fo:13337:adminpcowe-country-us:maskxsndyb
pr-eu.proxies.fo:13337:adminpcowe-country-us-city-westlakevillage:maskxsndyb
pr-eu.proxies.fo:13337:adminpcowe-country-us-city-pleasanton:maskxsndyb
pr-us.proxies.fo:13337:adminpcowe-country-us-state-ny:maskxsndyb
pr-us.proxies.fo:13337:adminpcowe-country-us-asn-7018:maskxsndyb
pr-us.proxies.fo:13337:adminpcowe-country-us-city-pleasanton-asn-7922:maskxsndyb
pr-sg.proxies.fo:13337:adminpcowe-country-jp:maskxsndyb
pr-eu.proxies.fo:13337:adminpcowe-country-us-session-5s5d4xud-ttl-15:maskxsndyb
```

## Need help?

Best support is through the [dashboard](https://app.proxies.fo/signin) — fastest response. You can also reach us on [Discord](https://discord.gg/proxy), [Telegram](https://t.me/prodigynet), or at [admin@proxies.fo](mailto:admin@proxies.fo).


# Residential Overview
Source: https://docs.proxies.fo/residential/overview

100M+ real home IPs across 180+ countries with country, state, city, and ASN targeting

The residential network gives you access to **100M+ genuine home IPs** across **180+ countries**. Ideal for workloads that need to blend with real human traffic — scraping search engines, ad verification, price monitoring, anything where datacenter IPs get blocked.

## Specs

| Attribute             | Value                                                   |
| --------------------- | ------------------------------------------------------- |
| Pool size             | 100M+ IPs                                               |
| Country coverage      | 180+                                                    |
| Targeting granularity | Country, state, city, ASN                               |
| Protocols             | HTTP, HTTPS, SOCKS5, UDP                                |
| Authentication        | Username : password                                     |
| Rotation modes        | Per-request rotating, sticky session (configurable TTL) |
| Billing               | Per GB of bandwidth                                     |

## Endpoints

| Region           | Host               | Port    |
| ---------------- | ------------------ | ------- |
| United States    | `pr-us.proxies.fo` | `13337` |
| Europe           | `pr-eu.proxies.fo` | `13337` |
| Singapore / APAC | `pr-sg.proxies.fo` | `13337` |

The regional host controls which gateway handles your request, not the egress country. Egress country is set via the `country-<code>` modifier — see [Targeting](/residential/targeting).

## Rotation modes

<CardGroup>
  <Card title="Rotating" icon="arrows-rotate">
    A new IP is assigned on every request. Best for scraping, SERP collection, broad data gathering.
  </Card>

  <Card title="Sticky" icon="thumbtack">
    The same IP is held for the lifetime of a session token. TTL configurable via `ttl-<minutes>`.
  </Card>
</CardGroup>

Learn more in [Sessions](/residential/sessions).

## Pricing

Plans start at **\$3 / GB** with per-GB cost scaling down as volume increases. See [proxies.fo/product-residential](https://proxies.fo/product-residential) for the full grid.

## When to pick residential

* Targets actively block datacenter ranges
* You need to appear as a normal home user (ad verification, social media automation)
* Aggressive anti-bot defences (Cloudflare, PerimeterX, DataDome)
* Need country, state, city, or ASN-level targeting

For raw speed on targets that don't discriminate by IP type, [Datacenter](/datacenter/overview) is faster per request.


# Sessions
Source: https://docs.proxies.fo/residential/sessions

Sticky sessions and TTL on the residential network

Sessions control how long you hold the same residential IP.

* **Rotating** — every request gets a fresh IP (default)
* **Sticky** — the same IP is held for a configurable TTL

## Rotating (default)

Without a session modifier, each request pulls a new IP:

```bash theme={null}
curl -x "http://adminpcowe:maskxsndyb@pr-eu.proxies.fo:13337" https://api.ipify.org
curl -x "http://adminpcowe:maskxsndyb@pr-eu.proxies.fo:13337" https://api.ipify.org
# Each call returns a different IP.
```

Good for: scraping, SERP collection, broad crawls.

## Sticky sessions

Append `-session-<id>` to your username. Same ID = same IP.

```bash theme={null}
curl -x "http://adminpcowe-session-5s5d4xud:maskxsndyb@pr-eu.proxies.fo:13337" https://api.ipify.org
curl -x "http://adminpcowe-session-5s5d4xud:maskxsndyb@pr-eu.proxies.fo:13337" https://httpbin.org/headers
curl -x "http://adminpcowe-session-5s5d4xud:maskxsndyb@pr-eu.proxies.fo:13337" https://example.com
```

### Session TTL

Control how long the session holds the same IP with `-ttl-<minutes>`:

```
adminpcowe-session-5s5d4xud-ttl-15:maskxsndyb
```

After the TTL expires, the next request with that session ID starts a new session with a fresh IP.

Residential uses `ttl-<minutes>`. Datacenter uses `duration-<seconds>` — see [Datacenter](/datacenter/overview).

If the assigned IP drops off the network before TTL expires, a new IP is assigned and the session continues seamlessly.

### Combining with targeting

```
adminpcowe-country-us-city-westlakevillage-session-5s5d4xud-ttl-15:maskxsndyb
```

Pins a Westlake Village IP for 15 minutes.

## Picking session IDs

Alphanumeric, 6–16 characters. Same ID = same IP.

Good: `5s5d4xud`, `bot-nyc-01`, `a4f8c2e1`, `sess-7xk9m2`

Avoid:

* Spaces or special characters (`$`, `@`, `:`, `/`)
* Sequential IDs (`session-1`, `session-2`) if isolation matters
* Reusing IDs across unrelated workflows

## Code examples

<CodeGroup>
  ```python Python theme={null}
  import secrets, requests

  session_id = secrets.token_hex(4)
  username = f"adminpcowe-country-us-city-westlakevillage-session-{session_id}-ttl-15"
  proxy = f"http://{username}:maskxsndyb@pr-eu.proxies.fo:13337"

  s = requests.Session()
  s.proxies = {"http": proxy, "https": proxy}

  for _ in range(3):
      print(s.get("https://api.ipify.org").text)
  ```

  ```javascript Node.js theme={null}
  import { randomBytes } from "crypto";
  import axios from "axios";
  import { HttpsProxyAgent } from "https-proxy-agent";

  const sessionId = randomBytes(4).toString("hex");
  const agent = new HttpsProxyAgent(
    `http://adminpcowe-country-us-city-westlakevillage-session-${sessionId}-ttl-15:maskxsndyb@pr-eu.proxies.fo:13337`
  );

  const client = axios.create({ httpAgent: agent, httpsAgent: agent });

  for (let i = 0; i < 3; i++) {
    const { data } = await client.get("https://api.ipify.org");
    console.log(data);
  }
  ```
</CodeGroup>

## When to use each mode

| Scenario                                        | Mode     |
| ----------------------------------------------- | -------- |
| Scraping many pages across many sites           | Rotating |
| Logging into an account and navigating          | Sticky   |
| Adding items to a cart and checking out         | Sticky   |
| Querying an API that rate-limits per IP         | Rotating |
| Anything that checks session cookies against IP | Sticky   |

Use the shortest TTL that covers your workflow. Shorter sessions recycle IPs faster and reduce the chance of a flagged IP affecting many requests.


# Targeting
Source: https://docs.proxies.fo/residential/targeting

Route residential traffic by country, state, city, or ASN

Targeting is controlled entirely through username modifiers. No separate endpoints per country.

## Format

```
Username: <base>-country-<cc>[-state-<sc>][-city-<n>][-asn-<num>]
Password: <your password>
```

Each level is independent — stop wherever you need to. To get a random IP at a broader level, just omit the narrower modifier.

## Country targeting

Use any ISO 3166-1 alpha-2 country code. Lowercase.

```bash theme={null}
# Germany — via the EU gateway
curl -x "http://adminpcowe-country-de:maskxsndyb@pr-eu.proxies.fo:13337" \
  https://api.ipify.org

# Japan — via the APAC gateway for lower latency
curl -x "http://adminpcowe-country-jp:maskxsndyb@pr-sg.proxies.fo:13337" \
  https://api.ipify.org

# Netherlands
curl -x "http://adminpcowe-country-nl:maskxsndyb@pr-eu.proxies.fo:13337" \
  https://api.ipify.org
```

Match the regional gateway to your target country for lowest latency.

## State targeting

Available for countries with state / regional subdivisions (US, Canada, Australia, Germany, Brazil, etc.).

```bash theme={null}
# Any IP in California
curl -x "http://adminpcowe-country-us-state-ca:maskxsndyb@pr-us.proxies.fo:13337" \
  https://api.ipify.org

# Ontario, Canada
curl -x "http://adminpcowe-country-ca-state-on:maskxsndyb@pr-us.proxies.fo:13337" \
  https://api.ipify.org
```

Omitting `city-` means "any city in that state" — the network picks one at random.

## City targeting

Append `-city-<n>` for a specific city. Lowercase and concatenated.

City targeting works **with or without** `state-`:

```bash theme={null}
# Westlake Village, CA (state omitted)
curl -x "http://adminpcowe-country-us-city-westlakevillage:maskxsndyb@pr-eu.proxies.fo:13337" \
  https://api.ipify.org

# Pleasanton, CA
curl -x "http://adminpcowe-country-us-city-pleasanton:maskxsndyb@pr-eu.proxies.fo:13337" \
  https://api.ipify.org

# Explicit state (when disambiguation is needed)
curl -x "http://adminpcowe-country-us-state-ca-city-pleasanton:maskxsndyb@pr-eu.proxies.fo:13337" \
  https://api.ipify.org
```

Add `state-` only when two cities share a name across states (e.g. "Springfield").

### City name format

* All lowercase
* No spaces, apostrophes, or hyphens (concatenate): `westlakevillage`, `sanfrancisco`, `newyorkcity`
* Accents stripped: `zurich` not `zürich`

## ASN targeting

`asn-<number>` pins your IP to a specific ISP by its Autonomous System Number. Useful for ad verification on specific carriers, CDN peering tests, or simulating traffic from a particular network.

```bash theme={null}
# AT&T customers in the US (ASN 7018)
curl -x "http://adminpcowe-country-us-asn-7018:maskxsndyb@pr-us.proxies.fo:13337" \
  https://api.ipify.org

# Comcast in any US city (ASN 7922)
curl -x "http://adminpcowe-country-us-asn-7922:maskxsndyb@pr-us.proxies.fo:13337" \
  https://api.ipify.org
```

### Common US ASNs

| ASN   | ISP                |
| ----- | ------------------ |
| 7018  | AT\&T              |
| 7922  | Comcast            |
| 701   | Verizon            |
| 20115 | Charter / Spectrum |
| 22773 | Cox                |
| 209   | CenturyLink        |

Find the ASN for any IP using `whois`, [bgp.he.net](https://bgp.he.net), or [ipinfo.io](https://ipinfo.io).

### Stacking ASN with geo

```bash theme={null}
# Comcast subscribers in Pleasanton, CA
curl -x "http://adminpcowe-country-us-city-pleasanton-asn-7922:maskxsndyb@pr-eu.proxies.fo:13337" \
  https://api.ipify.org

# AT&T in New York state
curl -x "http://adminpcowe-country-us-state-ny-asn-7018:maskxsndyb@pr-us.proxies.fo:13337" \
  https://api.ipify.org
```

The narrower the combined targeting, the smaller the pool. For high-concurrency workloads, keep at least one level wide.

## Targeting granularity cheat sheet

| Target                        | Username format                                  |
| ----------------------------- | ------------------------------------------------ |
| Random IP, any country        | `adminpcowe`                                     |
| Random IP in any US city      | `adminpcowe-country-us`                          |
| Random IP in any NY city      | `adminpcowe-country-us-state-ny`                 |
| Specific city (state skipped) | `adminpcowe-country-us-city-westlakevillage`     |
| Specific city within state    | `adminpcowe-country-us-state-ca-city-pleasanton` |
| Specific ISP (AT\&T)          | `adminpcowe-country-us-asn-7018`                 |
| ISP + city combined           | `adminpcowe-country-us-city-pleasanton-asn-7922` |

## Combining with sessions

```
adminpcowe-country-us-city-westlakevillage-session-5s5d4xud-ttl-15:maskxsndyb
```

Pins a Westlake Village IP for 15 minutes. See [Sessions](/residential/sessions).

## Quick-copy `host:port:user:pass`

```
pr-eu.proxies.fo:13337:adminpcowe-country-us-city-westlakevillage:maskxsndyb
pr-eu.proxies.fo:13337:adminpcowe-country-us-city-pleasanton:maskxsndyb
pr-eu.proxies.fo:13337:adminpcowe-country-us-state-ny:maskxsndyb
pr-us.proxies.fo:13337:adminpcowe-country-us:maskxsndyb
pr-us.proxies.fo:13337:adminpcowe-country-us-asn-7018:maskxsndyb
pr-us.proxies.fo:13337:adminpcowe-country-us-city-pleasanton-asn-7922:maskxsndyb
pr-sg.proxies.fo:13337:adminpcowe-country-jp:maskxsndyb
```

## Troubleshooting

<AccordionGroup>
  <Accordion title="454 invalid country code">
    Country code isn't recognised. Use lowercase ISO 3166-1 alpha-2 (`us`, not `US` or `usa`).
  </Accordion>

  <Accordion title="454 invalid state code">
    State code not recognised for that country. Use standard subdivision codes (e.g. `ny`, `ca` for US states; `on`, `qc` for Canadian provinces).
  </Accordion>

  <Accordion title="454 invalid city code">
    City isn't recognised, or no IPs available. Check the city name is lowercase and concatenated. If valid but low availability, drop the `city-` modifier.
  </Accordion>

  <Accordion title="454 invalid ASN">
    ASN not in supported set, or no IPs for the combined geo + ASN. Verify with `whois` or bgp.he.net and try widening geo targeting.
  </Accordion>

  <Accordion title="Slow or timing out">
    Narrow targeting = smaller pool. Widen to state or country level, or split workloads across regional gateways.
  </Accordion>
</AccordionGroup>