# How to set up LatamProxies proxies (2026)

> Set up LatamProxies Latin American proxies in cURL, Python, Node.js, Playwright and Puppeteer: port 7777, SOCKS5, country targeting. No KYC, crypto.

- URL: https://latamproxies.com/guides/proxy-setup/
- Last updated: 2026-10-05
- Publisher: LatamProxies (https://latamproxies.com)

Copy-paste examples for cURL, Python, Node.js, Playwright and Puppeteer, with country, city and sticky-session targeting for Latin America.

**Quick answer — How do I set up LatamProxies proxies?**

To set up **LatamProxies** proxies, point your tool to `gw.latamproxies.com` on port `7777` (HTTP/HTTPS) or `7778` (SOCKS5). Put your targeting in the username, for example `USERNAME-country-br-city-sao_paulo`, and use your proxy password. Residential traffic starts at $0.50/GB. No KYC — no ID, no selfie, no documents. Pay in crypto.

## Connection details

| Attribute | Value |
| --- | --- |
| Gateway host | `gw.latamproxies.com` |
| HTTP / HTTPS port | `7777` |
| SOCKS5 port | `7778` |
| Username format | `USERNAME-country-{cc}-city-{city}-session-{id}-ttl-{minutes}` |
| Country code | ISO 3166-1, lower case: `br`, `mx`, `ar`, `co`, `cl`, `pe` |
| City | Lower case, spaces as `_`: `sao_paulo`, `mexico_city`, `buenos_aires` |
| Rotation | New IP on every request, or sticky sessions up to 30 minutes |
| Price | Residential from $0.50/GB · KYC: none · crypto only |
| Top-up | Minimum $25 in crypto; unused balance stays on your account |

## How do I go from payment to the first request?

Five steps, a few minutes in total once your payment confirms.

1. **Buy a plan** — Choose a plan on the pricing page and pay in USDT, BTC, USDC, ETH, LTC or SOL. The 1 GB plan at $2.63 is enough to test. The small plan is paid from a $25 minimum top-up; the rest stays on your balance (never expires, non-refundable).
2. **Copy your credentials** — Open the dashboard and copy your proxy username and password. They are not your account number.
3. **Build the username** — Add targeting to the username: -country-br for Brazil, -city-sao_paulo for a city, -session-abc123-ttl-30 for a sticky IP.
4. **Test with cURL** — Run one cURL request through the gateway and check that the IP and country are what you asked for.
5. **Plug it into your tool** — Use the examples below for Python, Node.js, Playwright or Puppeteer.

## How is the proxy username built?

All targeting goes into the username, so you never need a different host or port per country. The full format is `USERNAME-country-{cc}-city-{city}-session-{id}-ttl-{minutes}`. Every part after `USERNAME` is optional.

- `USERNAME` alone: a rotating IP from any supported country.
- `USERNAME-country-mx`: a rotating IP in [Mexico](https://latamproxies.com/residential-proxies/mexico/).
- `USERNAME-country-ar-city-buenos_aires`: a rotating IP in [Buenos Aires](https://latamproxies.com/residential-proxies/argentina/buenos-aires/).
- `USERNAME-country-br-session-abc123-ttl-30`: the same Brazilian IP for up to 30 minutes.

Country codes are two-letter ISO codes in lower case. City names are lower case with `_` instead of spaces and no accents: `sao_paulo`, not `São Paulo`. Do not add other parameters: the gateway does not read ASN, ZIP or carrier parameters in the username.

### Username parameters

| Parameter | Example | What it does |
| --- | --- | --- |
| `country` | `-country-co` | Exit IP in that country (Colombia here) |
| `city` | `-city-mexico_city` | Exit IP in that city; use it together with `country` |
| `session` | `-session-job42` | Keeps the same IP while the id stays the same |
| `ttl` | `-ttl-30` | Session length in minutes, up to 30 minutes |

## How do I test the proxy with cURL?

cURL is the fastest way to check that your credentials and targeting work. The request below goes through the HTTP gateway and prints the exit IP. Replace `USERNAME` and `PASSWORD` with the values from your dashboard.

*cURL — HTTP gateway, Brazil*

```bash
curl -x http://gw.latamproxies.com:7777 \
  -U "USERNAME-country-br:PASSWORD" \
  https://api.ipify.org?format=json
```

*cURL — SOCKS5, Mexico City, sticky 30 minutes*

```bash
curl --socks5-hostname gw.latamproxies.com:7778 \
  -U "USERNAME-country-mx-city-mexico_city-session-abc123-ttl-30:PASSWORD" \
  https://api.ipify.org?format=json
```

## How do I use the proxy with Python requests?

With `requests`, set the same proxy URL for both `http` and `https`. HTTPS targets are tunnelled through the HTTP gateway with CONNECT, so the URL scheme of the proxy stays `http://`. For SOCKS5, install `requests[socks]` and use `socks5h://` so DNS is resolved through the proxy, in the target country.

*Python requests — rotating IP in Colombia*

```python
import requests

USER = "USERNAME-country-co"
PASS = "PASSWORD"
proxy = f"http://{USER}:{PASS}@gw.latamproxies.com:7777"

proxies = {"http": proxy, "https": proxy}
r = requests.get("https://api.ipify.org?format=json", proxies=proxies, timeout=30)
print(r.json())
```

*Python requests — SOCKS5, sticky session in São Paulo*

```python
# pip install "requests[socks]"
import requests

USER = "USERNAME-country-br-city-sao_paulo-session-job42-ttl-30"
PASS = "PASSWORD"
proxy = f"socks5h://{USER}:{PASS}@gw.latamproxies.com:7778"

with requests.Session() as s:
    s.proxies = {"http": proxy, "https": proxy}
    for _ in range(3):
        print(s.get("https://api.ipify.org?format=json", timeout=30).json())  # same IP 3 times
```

## How do I use the proxy with Node.js?

In Node.js 18 or later, the built-in `fetch` does not read proxy settings, so use `undici`'s `ProxyAgent` and pass it as the `dispatcher`. With `axios`, use `https-proxy-agent` and set `proxy: false` so axios does not apply its own proxy logic.

*Node.js — undici ProxyAgent, Argentina*

```javascript
// npm install undici
import { fetch, ProxyAgent } from 'undici';

const user = 'USERNAME-country-ar';
const pass = 'PASSWORD';
const dispatcher = new ProxyAgent({
  uri: 'http://gw.latamproxies.com:7777',
  token: 'Basic ' + Buffer.from(`${user}:${pass}`).toString('base64'),
});

const res = await fetch('https://api.ipify.org?format=json', { dispatcher });
console.log(await res.json());
```

*Node.js — axios with https-proxy-agent, Chile*

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

const user = encodeURIComponent('USERNAME-country-cl');
const pass = encodeURIComponent('PASSWORD');
const agent = new HttpsProxyAgent(`http://${user}:${pass}@gw.latamproxies.com:7777`);

const { data } = await axios.get('https://api.ipify.org?format=json', {
  httpsAgent: agent,
  proxy: false,
  timeout: 30000,
});
console.log(data);
```

## How do I use the proxy with Playwright?

Playwright accepts the proxy server, username and password at launch. Use a sticky session for browser work: a page loads many resources, and one IP per page keeps the session consistent. Change the session id to get a new IP for the next browser context.

*Playwright (Node.js) — sticky IP in Lima*

```javascript
// npm install playwright
import { chromium } from 'playwright';

const browser = await chromium.launch({
  proxy: {
    server: 'http://gw.latamproxies.com:7777',
    username: 'USERNAME-country-pe-city-lima-session-pw1-ttl-30',
    password: 'PASSWORD',
  },
});
const page = await browser.newPage();
await page.goto('https://api.ipify.org?format=json');
console.log(await page.textContent('body'));
await browser.close();
```

*Playwright (Python) — Brazil*

```python
# pip install playwright && playwright install chromium
from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(proxy={
        "server": "http://gw.latamproxies.com:7777",
        "username": "USERNAME-country-br-session-pw2-ttl-30",
        "password": "PASSWORD",
    })
    page = browser.new_page()
    page.goto("https://api.ipify.org?format=json")
    print(page.text_content("body"))
    browser.close()
```

## How do I use the proxy with Puppeteer?

Chrome does not accept credentials inside `--proxy-server`, so Puppeteer passes the server as a launch argument and the username and password with `page.authenticate()`.

*Puppeteer — sticky IP in Mexico City*

```javascript
// npm install puppeteer
import puppeteer from 'puppeteer';

const browser = await puppeteer.launch({
  args: ['--proxy-server=http://gw.latamproxies.com:7777'],
});
const page = await browser.newPage();
await page.authenticate({
  username: 'USERNAME-country-mx-city-mexico_city-session-pp1-ttl-30',
  password: 'PASSWORD',
});
await page.goto('https://api.ipify.org?format=json');
console.log(await page.evaluate(() => document.body.innerText));
await browser.close();
```

## Should I use rotating or sticky sessions?

Use rotating IPs for independent requests and sticky sessions for multi-step flows. New IP on every request, or sticky sessions up to 30 minutes.

- **Rotating** (no `session`): best for crawling many product pages, such as [Mercado Libre price monitoring](https://latamproxies.com/use-cases/mercado-libre-price-monitoring/), or for checking search results from many places.
- **Sticky** (`-session-ID-ttl-30`): best for browser automation, pagination that depends on cookies, checkout-flow testing on your own store and [ad verification](https://latamproxies.com/use-cases/ad-verification/) journeys.

For 4G/5G dedicated ports, rotation works differently: you change the IP through an API link. See the [mobile proxy rotation guide](https://latamproxies.com/guides/mobile-proxy-rotation/).

## What do common errors mean?

Most problems come from the username string or from the target site:

- **407 Proxy Authentication Required**: the username or password is wrong. Check for spaces, and URL-encode special characters in the password.
- **Connection refused or timeout on connect**: check the host and port. HTTP uses `7777`, SOCKS5 uses `7778`.
- **Wrong country**: check the country code (`br`, not `bra`) and the city spelling (`sao_paulo`).
- **403 or CAPTCHA from the target**: slow down, rotate more often, or use a sticky session with a real browser.
- **Target refused by the gateway**: banks, government portals, payment portals and SMTP are blocked by our [Acceptable Use Policy](https://latamproxies.com/acceptable-use-policy/).

If the problem continues, email support@latamproxies.com with your username string (without the password), the target and the error.

## Setup questions

### What host and port do LatamProxies proxies use?

All residential traffic goes through `gw.latamproxies.com`. Use port `7777` for HTTP and HTTPS targets, and port `7778` for SOCKS5. The same host and ports work for every country; targeting is set in the username, for example `USERNAME-country-cl`.

### How do I target a specific Latin American country?

Add `-country-` and the two-letter ISO code in lower case to your username: `br` for Brazil, `mx` for Mexico, `ar` for Argentina, `co` for Colombia, `cl` for Chile, `pe` for Peru. The full list of 38 countries is on the [countries page](https://latamproxies.com/residential-proxies/countries/).

### How do I keep the same IP?

Add `-session-` with any id and `-ttl-` with a number of minutes, for example `USERNAME-country-br-session-abc123-ttl-30`. The IP stays the same while you reuse that id, up to 30 minutes. Use a new id to get a new IP.

### Should I use HTTP or SOCKS5?

Use HTTP on port `7777` for most tools: browsers, scrapers and HTTP libraries handle it natively, and HTTPS targets are tunnelled securely. Use SOCKS5 on port `7778` when a tool only supports SOCKS, or when you want DNS resolved on the proxy side with `socks5h://`.

### Is my proxy username the same as my account number?

No. Your account number logs you into the dashboard. Your proxy username and password are shown in the dashboard and are used only for the gateway. Never share your account number, and never put it in scripts.

### Can I use the proxies with Scrapy, Selenium or other tools?

Yes. Any tool that supports HTTP or SOCKS5 proxies with username and password authentication works with LatamProxies. Use the same host, port and username format shown in this guide. If a tool cannot send proxy credentials, contact support@latamproxies.com.

### How much does it cost to test the setup?

The smallest residential plan is 1 GB for $2.63, enough for thousands of test requests to a light page. Larger plans cost less per GB, down to $0.50/GB. No KYC — no ID, no selfie, no documents. Pay in crypto. See the [pricing page](https://latamproxies.com/pricing/). The small plan is paid from a $25 minimum top-up; the rest stays on your balance (never expires, non-refundable).

**Get your credentials** Buy a plan with USDT, BTC or another coin and start sending requests as soon as your top-up is credited. [Get residential proxies — from $0.50/GB](https://latamproxies.com/pricing/) · [Residential proxies](https://latamproxies.com/residential-proxies/)

---

LatamProxies: LatamProxies is a no-KYC residential and 4G/5G mobile proxy provider for Latin America and the Caribbean — Brazil, Mexico, Argentina, Colombia, Chile, Peru and more — paid only in crypto (USDT, BTC, USDC, ETH, LTC, SOL). Residential traffic starts at $0.50/GB.