# Obtenha um IP de cidade europeia em 5 minutos

> Quickstart: conecte-se a um IP de Paris em 5 minutos com curl, Python, Node 22 ou SOCKS5. 1 GB custa US$ 0,95, sem KYC, pago com cripto.

- URL: https://eurocityproxies.com/pt/guides/quickstart/
- Última atualização: 2026-10-18
- Publisher: EuroCity Proxies (https://eurocityproxies.com)

Cinco exemplos para copiar e colar, de uma linha curl ao Node.js, todos voltados para um IP residencial em Paris. Cada um imprime o IP de saída e sua cidade para você ver a segmentação funcionando.

**Resposta rápida — Como faço para me conectar a um IP de cidade europeia?**

Envie suas requisições para o gateway **EuroCity Proxies** com a cidade no nome de usuário, por exemplo `USERNAME-country-fr-city-paris`, depois leia `https://ipinfo.io/json` para ver a saída. A partir de outubro de 2026, a segmentação por cidade está em todos os planos e 1 GB custa a partir de US$ 0,95. A disponibilidade de cidades varia; o checkout mostra o que está online.

## O que você precisa antes da primeira requisição?

| Atributo | Valor |
| --- | --- |
| Gateway | `gw.eurocityproxies.com` |
| Porta HTTP e HTTPS | `7777` |
| Porta SOCKS5 | `7778` |
| Nome de usuário rotativo | `USERNAME-country-fr-city-paris` |
| Nome de usuário fixo | `USERNAME-country-fr-city-paris-session-paris1-ttl-10` |
| URL de verificação | `https://ipinfo.io/json` (IP, cidade, região, país, rede) |
| Protocolos | HTTP, HTTPS (CONNECT) e SOCKS5 |

## Como o nome de usuário é montado?

O nome de usuário carrega a segmentação: o nome de usuário da sua conta, depois `-country-` com um código ISO em minúsculas e, em seguida, segmentos opcionais. O segmento de país é sempre obrigatório, mesmo quando você adiciona uma cidade.

- `-city-paris`: id da cidade em minúsculas, sem acentos, com `_` no lugar de espaços ou hífens (`-city-the_hague`).
- `-asn-<number>`: uma rede, por exemplo um provedor de banda larga; a segmentação por ASN não custa nada a mais ([guia de ASN](https://eurocityproxies.com/pt/targeting/asn/)).
- `-session-paris1-ttl-10`: uma sessão fixa chamada `paris1` que dura até 10 minutos. O ttl pode ir até 30.

Os códigos de país são minúsculos no nome de usuário, mas maiúsculos na API. A lista de ids de cidades de um país vem de `GET /api/v1/catalog/countries/FR/cities`, descrita na [documentação da API](https://eurocityproxies.com/docs/api/). Use os ids que ela retorna; não adivinhe grafias como `kraków` ou `münchen`.

## Um nome de usuário rotativo troca de IP a cada requisição?

Ele troca de IP a cada nova conexão, não a cada requisição. Cada nova conexão recebe um IP do pool, geralmente diferente; para obter um novo IP a cada requisição, envie uma requisição por conexão (desative o keep-alive).

Isso importa no código. Um `requests.Session`, um `httpx.Client` ou um agente undici mantém seu túnel aberto entre requisições, então a saída continua a mesma. Para um IP por requisição, abra um novo cliente para cada requisição ou envie `Connection: close`. Para um IP em várias requisições de propósito, use uma sessão fixa, explicada em [sessões fixas por cidade](https://eurocityproxies.com/pt/guides/city-sessions/).

*curl: saídas rotativas, fixas e SOCKS5 em Paris*

```bash
# Rotating exit in Paris (HTTP proxy, HTTPS target through CONNECT)
curl -s -x "http://USERNAME-country-fr-city-paris:PASSWORD@gw.eurocityproxies.com:7777" https://ipinfo.io/json

# Sticky exit in Paris: session paris1, up to 10 minutes
curl -s -x "http://USERNAME-country-fr-city-paris-session-paris1-ttl-10:PASSWORD@gw.eurocityproxies.com:7777" https://ipinfo.io/json

# SOCKS5 with socks5h: the proxy resolves the hostname, not your machine
curl -s -x "socks5h://USERNAME-country-fr-city-paris:PASSWORD@gw.eurocityproxies.com:7778" https://ipinfo.io/json

# Gateway alone, without a target site: prints only the exit IP
curl -s -x "http://USERNAME-country-fr-city-paris:PASSWORD@gw.eurocityproxies.com:7777" https://api.ipify.org
```

*Python requests: saída fixa em Paris (Python 3.9 ou mais recente)*

```python
# pip install requests
from urllib.parse import quote

import requests

HOST = "gw.eurocityproxies.com"
PORT = 7777
USER = "USERNAME-country-fr-city-paris-session-paris1-ttl-10"
PASSWORD = quote("PASSWORD", safe="")  # encodes @, : and / in the password

proxy = f"http://{USER}:{PASSWORD}@{HOST}:{PORT}"
proxies = {"http": proxy, "https": proxy}

# proxies= on each call wins over HTTP_PROXY / HTTPS_PROXY set on your machine
r = requests.get("https://ipinfo.io/json", proxies=proxies, timeout=30)
r.raise_for_status()
info = r.json()
print(info["ip"], info.get("city"), info.get("country"), info.get("org"))
```

*Python httpx: mesmo IP por cliente, novo IP por cliente*

```python
# pip install httpx
from urllib.parse import quote

import httpx

USER = "USERNAME-country-fr-city-paris"
PASSWORD = quote("PASSWORD", safe="")
PROXY = f"http://{USER}:{PASSWORD}@gw.eurocityproxies.com:7777"

# One client keeps its connection open (keep-alive): the three lines show one IP
with httpx.Client(proxy=PROXY, timeout=30, trust_env=False) as client:
    for _ in range(3):
        print("same client:", client.get("https://ipinfo.io/json").json()["ip"])

# A new client per request opens a new connection: usually a different Paris IP
for _ in range(3):
    with httpx.Client(proxy=PROXY, timeout=30, trust_env=False) as client:
        print("new client: ", client.get("https://ipinfo.io/json").json()["ip"])
```

*Node.js 22 ou mais recente, undici ProxyAgent (salve como paris.mjs)*

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

const user = "USERNAME-country-fr-city-paris-session-paris1-ttl-10";
const password = encodeURIComponent("PASSWORD");
const dispatcher = new ProxyAgent(
  `http://${user}:${password}@gw.eurocityproxies.com:7777`
);

try {
  const res = await fetch("https://ipinfo.io/json", {
    dispatcher,
    signal: AbortSignal.timeout(30000), // stop after 30 s
  });
  const info = await res.json();
  console.log(info.ip, info.city, info.country, info.org);
} finally {
  await dispatcher.close();
}
```

*Python requests via SOCKS5 com socks5h*

```python
# pip install "requests[socks]"
from urllib.parse import quote

import requests

HOST = "gw.eurocityproxies.com"
SOCKS_PORT = 7778
USER = "USERNAME-country-fr-city-paris"
PASSWORD = quote("PASSWORD", safe="")

# socks5h: the proxy resolves the hostname, not your machine
proxy = f"socks5h://{USER}:{PASSWORD}@{HOST}:{SOCKS_PORT}"
r = requests.get("https://ipinfo.io/json", proxies={"http": proxy, "https": proxy}, timeout=30)
print(r.json())
```

## Quais detalhes esses exemplos tratam?

Os exemplos tratam os detalhes que mais costumam quebrar uma primeira conexão:

- **Codifique a senha.** `quote("PASSWORD", safe="")` em Python e `encodeURIComponent` em Node impedem que caracteres como `@` ou `:` quebrem a URL do proxy.
- **Variáveis de proxy na sua máquina.** Em requests, um valor definido em `session.proxies` pode ser sobrescrito por `HTTPS_PROXY`. Passe `proxies=` em cada chamada ou defina `trust_env = False` na sessão.
- **Sempre um timeout.** Cada exemplo para após 30 segundos em vez de travar.
- **Top-level await precisa de um módulo.** Salve o exemplo Node como `.mjs` e execute com Node.js 22 ou mais recente.
- **socks5h, não socks5.** Com `socks5://`, requests e curl resolvem o hostname na sua máquina. Com `socks5h://`, o proxy resolve.

## Posso usar a porta SOCKS5 em um navegador?

Use a porta HTTP `7777` nos navegadores. A documentação de proxy do Chromium diz que o Chrome não oferece suporte a nenhum método de autenticação para SOCKS5. Um nome de usuário e senha na porta `7778` não funcionarão ali.

No iPhone ou iPad, as configurações de Wi-Fi oferecem um proxy HTTP manual com autenticação. Para o emulador Android, inicie-o com `-http-proxy http://USERNAME-country-fr-city-paris:PASSWORD@gw.eurocityproxies.com:7777`. A [página de testes geográficos do app](https://eurocityproxies.com/pt/use-cases/app-geo-testing/) cobre dispositivos com mais detalhes.

## O que a saída deve mostrar?

O JSON de `https://ipinfo.io/json` deve mostrar `"country": "FR"` e, na maioria das vezes, `Paris` ou uma cidade da região de Paris como `city`. O campo `org` começa com o ASN da rede, como um provedor de banda larga francês.

Uma cidade vizinha em vez de Paris é normal: os bancos de dados de geolocalização colocam muitos IPs residenciais no hub local do provedor. O [guia de cidade de saída](https://eurocityproxies.com/pt/guides/verify-exit-city/) mostra como comparar duas fontes, e [por que um IP mostra uma cidade vizinha](https://eurocityproxies.com/pt/guides/ip-geolocation-accuracy/) explica as causas.

> **Com verificação de sintaxe, não executado contra um alvo real** Em 18 de outubro de 2026, os exemplos em Python foram verificados com python -I -m py_compile e o exemplo em Node com node --check. Substitua USERNAME e PASSWORD pelos valores do seu painel.

## Perguntas do quickstart

### Por que minha requisição falha com 407 Proxy Authentication Required?

Um 407 significa que o proxy não aceitou o usuário ou a senha. Verifique se o usuário começa com o nome de usuário da sua conta, se `-country-` está presente e se os caracteres especiais da senha estão com URL encoding. Copie os dois valores novamente do painel.

### Por que recebo um IP alemão quando pedi Paris?

Normalmente é um erro de digitação no usuário, como `-country-de` deixado de outro teste, ou um id de cidade que não existe. Imprima o usuário antes da requisição. Se `ipinfo.io` e uma segunda fonte mostrarem outro país, escreva para o suporte com o horário e o IP de saída.

### Quanto tempo pode durar uma sessão sticky de Paris?

Uma sessão sticky mantém o mesmo IP por até 30 minutos (o IP pode mudar antes, por exemplo se o dispositivo residencial ficar offline). Defina a duração com `-ttl-` em minutos, por exemplo `-ttl-10` ou `-ttl-30`. Não conte com uma sessão durando mais do que o ttl definido.

### O direcionamento por cidade tem custo extra?

Não. Segmentação por país e cidade em todos os planos; nos Estados Unidos também por estado e CEP; segmentação por ASN sem custo extra. A disponibilidade de cidades varia. O preço por GB é o mesmo com ou sem cidade. A [página de preços](https://eurocityproxies.com/pt/pricing/) lista US$ 0,95 por 1 GB e US$ 8 por 10 GB.

### Quanto tráfego esse quickstart usa?

Muito pouco: cada requisição para `https://ipinfo.io/json` move alguns kilobytes, incluindo headers e TLS. O uso conta todos os dados enviados e recebidos pelo proxy (upload e download, cabeçalhos incluídos). 1 GB = 1.000.000.000 bytes. Tentativas de conexão que falham antes de chegar ao destino não são contadas.

### Posso fazer login com uma allowlist de IP em vez de senha?

Sim. Nome de usuário e senha em todos os planos, ou uma lista de IPs permitidos (até 10 IPs). Subusuários com credenciais próprias e limite de tráfego. Chaves de API que você pode revogar a qualquer momento. A [documentação](https://eurocityproxies.com/pt/docs/) explica como definir o país e a cidade quando você se conecta a partir de um IP na allowlist. Os exemplos desta página usam usuário e senha porque funcionam de qualquer máquina.

### Como pago pelo primeiro gigabyte?

Escolha um plano e recarregue o valor dele em BTC, USDT, USDC, ETH, SOL, LTC (mínimo de US$ 25). Envie o valor exato e clique em I've sent the payment; a recarga é identificada pelo valor exato e creditada após a confirmação. Sem KYC: sem documento de identidade, sem selfie, sem documentos para se cadastrar, recarregar ou comprar.

## Fontes

1. [man page do curl: --proxy, socks5h:// e --socks5-hostname](https://curl.se/docs/manpage.html) — curl project (checked 2026-10-18)
2. [Requests: Advanced Usage, Proxies and SOCKS](https://requests.readthedocs.io/en/latest/user/advanced/) — Python Software Foundation / Requests (checked 2026-10-18)
3. [HTTPX: Proxies](https://www.python-httpx.org/advanced/proxies/) — Encode (checked 2026-10-18)
4. [documentação do ProxyAgent do undici](https://github.com/nodejs/undici/blob/main/docs/docs/api/ProxyAgent.md) — Node.js project (checked 2026-10-18)
5. [releases do Node.js (linhas de release suportadas)](https://nodejs.org/en/about/previous-releases) — OpenJS Foundation (checked 2026-10-18)
6. [suporte a proxy no Chrome (autenticação SOCKSv5)](https://chromium.googlesource.com/chromium/src/+/HEAD/net/docs/proxy.md) — The Chromium Projects (checked 2026-10-18)
7. [Configurar um proxy para o Android Emulator](https://developer.android.com/studio/run/emulator-networking-proxy) — Google / Android Developers (last updated 2026-03-12, checked 2026-10-18)
8. [Configurações de payload de gerenciamento de dispositivo do Global HTTP Proxy (iOS, iPadOS: proxy manual com nome de usuário e senha)](https://support.apple.com/guide/deployment/global-http-proxy-payload-settings-dep7ba46fcd/web) — Apple Platform Deployment (checked 2026-10-18)
9. [RFC 9110 HTTP Semantics, seção 9.3.6 CONNECT e status 407](https://www.rfc-editor.org/rfc/rfc9110.html) — IETF (June 2022, checked 2026-10-18)
10. [Endpoint JSON do IPinfo](https://ipinfo.io/json) — IPinfo (checked 2026-10-18)

---

EuroCity Proxies: EuroCity Proxies é um provedor de proxy residencial com segmentação em nível de cidade em toda a Europa, pago com cripto sem envio de documento de identidade: IPs de banda larga residencial cobrados por GB, com uma página de dados locais para cada uma das 103 cidades em 35 países.