> For the complete documentation index, see [llms.txt](https://developers.oxylabs.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://developers.oxylabs.io/products/pt-br/web-scraper-api/features/localization/proxy-location.md).

# Localização do proxy

Descubra como usar o parâmetro geo\_location para acessar dados da web como se você estivesse navegando de outro país.

Use o `geo_location` parâmetro para selecionar o local do servidor proxy. Isso permite que você extraia dados como se estivesse navegando de um país diferente.

<details>

<summary>Lista de valores geo_location suportados</summary>

```
Ilhas Åland
Afeganistão
Albânia
Argélia
Samoa Americana
Andorra
Angola
Anguila
Antártida
Antígua e Barbuda
Argentina
Armênia
Aruba
Austrália
Áustria
Azerbaijão
Bahamas
Bahrein
Bangladesh
Barbados
Bielorrússia
Bélgica
Belize
Benin
Bermudas
Butão
Bolívia (Estado Plurinacional da)
Bonaire, Santo Eustáquio e Saba
Bósnia e Herzegovina
Botsuana
Ilha Bouvet
Brasil
Território Britânico do Oceano Índico
Brunei Darussalam
Bulgária
Burkina Faso
Burundi
Cabo Verde
Camboja
Camarões
Canadá
Ilhas Cayman
República Centro-Africana
Chade
Chile
China
Ilha Christmas
Ilhas Cocos (Keeling)
Colômbia
Comores
Congo
Congo, República Democrática do
Ilhas Cook
Costa Rica
Costa do Marfim
Croácia
Cuba
Curaçao
Chipre
Tchéquia
Dinamarca
Djibuti
Dominica
República Dominicana
Equador
Egito
El Salvador
Guiné Equatorial
Eritreia
Estônia
Eswatini
Etiópia
Ilhas Falkland [Malvinas]
Ilhas Faroé
Fiji
Finlândia
França
Guiana Francesa
Polinésia Francesa
Territórios Franceses do Sul
Gabão
Gâmbia
Geórgia
Alemanha
Gana
Gibraltar
Grécia
Groenlândia
Granada
Guadalupe
Guam
Guatemala
Guernsey
Guiné
Guiné-Bissau
Guiana
Haiti
Ilha Heard e Ilhas McDonald
Santa Sé
Honduras
Hong Kong
Hungria
Islândia
Índia
Indonésia
Irã (República Islâmica do)
Iraque
Irlanda
Ilha de Man
Israel
Itália
Jamaica
Japão
Jersey
Jordânia
Cazaquistão
Quênia
Kiribati
Coreia
Kuwait
Quirguistão
República Democrática Popular do Laos
Letônia
Líbano
Lesoto
Libéria
Líbia
Liechtenstein
Lituânia
Luxemburgo
Macau
Madagascar
Malawi
Malásia
Maldivas
Mali
Malta
Ilhas Marshall
Martinica
Mauritânia
Maurício
Maiote
México
Micronésia (Estados Federados da)
Moldávia (República da)
Mônaco
Mongólia
Montenegro
Montserrat
Marrocos
Moçambique
Mianmar
Namíbia
Nauru
Nepal
Países Baixos
Nova Caledônia
Nova Zelândia
Nicarágua
Níger
Nigéria
Niue
Ilha Norfolk
Ilhas Marianas do Norte
Noruega
Omã
Paquistão
Palau
Palestina (Estado da)
Panamá
Papua-Nova Guiné
Paraguai
Peru
Filipinas
Pitcairn
Polônia
Portugal
Porto Rico
Catar
República da Macedônia do Norte
Reunião
Romênia
Rússia
Ruanda
São Bartolomeu
Santa Helena, Ascensão e Tristão da Cunha
São Cristóvão e Nevis
Santa Lúcia
São Martinho (parte francesa)
São Pedro e Miquelon
São Vicente e Granadinas
Samoa
San Marino
São Tomé e Príncipe
Arábia Saudita
Senegal
Sérvia
Seicheles
Serra Leoa
Singapura
Sint Maarten (parte holandesa)
Eslováquia
Eslovênia
Ilhas Salomão
Somália
África do Sul
Geórgia do Sul e Ilhas Sandwich do Sul
Sudão do Sul
Espanha
Sri Lanka
Sudão
Suriname
Svalbard e Jan Mayen
Suécia
Suíça
República Árabe Síria
Taiwan, Província da China
Tadjiquistão
Tanzânia, República Unida da
Tailândia
Timor-Leste
Togo
Tokelau
Tonga
Trinidad e Tobago
Tunísia
Turquia
Turcomenistão
Ilhas Turks e Caicos
Tuvalu
Uganda
Ucrânia
Emirados Árabes Unidos
Reino Unido
Estados Unidos
Ilhas Menores Distantes dos Estados Unidos
Uruguai
Uzbequistão
Vanuatu
Venezuela (República Bolivariana da)
Vietnã
Ilhas Virgens Britânicas
Ilhas Virgens Americanas
Wallis e Futuna
Saara Ocidental
Iêmen
Zâmbia
Zimbábue
```

</details>

{% hint style="warning" %}
`geo_location` o parâmetro funciona de forma diferente para [**SERP**](/products/pt-br/web-scraper-api/features/localization/serp-localization.md) e [**E-Commerce**](/products/pt-br/web-scraper-api/features/localization/e-commerce-localization.md) localização. Leia mais nas seções correspondentes.
{% endhint %}

### Exemplo de solicitação

Este exemplo recupera uma página de produto usando um proxy na Alemanha.

{% tabs %}
{% tab title="cURL" %}

```shell
curl 'https://realtime.oxylabs.io/v1/queries' \
--user 'USERNAME:PASSWORD' \
-H 'Content-Type: application/json' \
-d '{
        "source": "universal",
        "url": "https://sandbox.oxylabs.io/products/1",
        "geo_location": "Germany"
    }'
```

{% endtab %}

{% tab title="Python" %}

```python
import requests
from pprint import pprint


# Structure payload.
payload = {
    'source': 'universal',
    'url': 'https://sandbox.oxylabs.io/products/1',
    'geo_location': 'Germany',
}

# Get response.
response = requests.request(
    'POST',
    'https://realtime.oxylabs.io/v1/queries',
    auth=('USERNAME', 'PASSWORD'),
    json=payload,
)

# Instead of response with job status and results url, this will return the
# JSON response with the result.
pprint(response.json())
```

{% endtab %}

{% tab title="Node.js" %}

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

const username = "USERNAME";
const password = "PASSWORD";
const body = {
    source: "universal",
    url: "https://sandbox.oxylabs.io/products/1",
    geo_location: "Germany",
};

const options = {
    hostname: "realtime.oxylabs.io",
    path: "/v1/queries",
    method: "POST",
    headers: {
        "Content-Type": "application/json",
        Authorization:
            "Basic " + Buffer.from(`${username}:${password}`).toString("base64"),
    },
};

const request = https.request(options, (response) => {
    let data = "";

    response.on("data", (chunk) => {
        data += chunk;
    });

    response.on("end", () => {
        const responseData = JSON.parse(data);
        console.log(JSON.stringify(responseData, null, 2));
    });
});

request.on("error", (error) => {
    console.error("Error:", error);
});

request.write(JSON.stringify(body));
request.end();
```

{% endtab %}

{% tab title="PHP" %}

```php
<?php

$params = array(
    'source' => 'universal',
    'url' => 'https://sandbox.oxylabs.io/products/1',
    'geo_location' => 'Germany',
);

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, "https://realtime.oxylabs.io/v1/queries");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($params));
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, "USERNAME" . ":" . "PASSWORD");

$headers = array();
$headers[] = "Content-Type: application/json";
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
echo $result;

if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);
```

{% endtab %}

{% tab title="Golang" %}

```go
package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
)

func main() {
	const Username = "USERNAME"
	const Password = "PASSWORD"

	payload := map[string]interface{}{
		"source":       "universal",
		"url":          "https://sandbox.oxylabs.io/products/1",
		"geo_location": "Germany",
	}

	jsonValue, _ := json.Marshal(payload)

	client := &http.Client{}
	request, _ := http.NewRequest("POST",
		"https://realtime.oxylabs.io/v1/queries",
		bytes.NewBuffer(jsonValue),
	)

	request.SetBasicAuth(Username, Password)
	response, _ := client.Do(request)

	responseText, _ := ioutil.ReadAll(response.Body)
	fmt.Println(string(responseText))
}

```

{% endtab %}

{% tab title="C#" %}

```csharp
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Json;
using System.Threading.Tasks;

namespace OxyApi
{
    class Program
    {
        static async Task Main()
        {
            const string Username = "USERNAME";
            const string Password = "PASSWORD";

            var parameters = new {
                source = "universal",
                url = "https://sandbox.oxylabs.io/products/1",
                geo_location = "Germany"
            };

            var client = new HttpClient();

            Uri baseUri = new Uri("https://realtime.oxylabs.io");
            client.BaseAddress = baseUri;

            var requestMessage = new HttpRequestMessage(HttpMethod.Post, "/v1/queries");
            requestMessage.Content = JsonContent.Create(parameters);

            var authenticationString = $"{Username}:{Password}";
            var base64EncodedAuthenticationString = Convert.ToBase64String(System.Text.ASCIIEncoding.UTF8.GetBytes(authenticationString));
            requestMessage.Headers.Add("Authorization", "Basic " + base64EncodedAuthenticationString);

            var response = await client.SendAsync(requestMessage);
            var contents = await response.Content.ReadAsStringAsync();

            Console.WriteLine(contents);
        }
    }
}
```

{% endtab %}

{% tab title="Java" %}

```java
package org.example;

import okhttp3.*;
import org.json.JSONObject;
import java.util.concurrent.TimeUnit;

public class Main implements Runnable {
    private static final String AUTHORIZATION_HEADER = "Authorization";
    public static final String USERNAME = "USERNAME";
    public static final String PASSWORD = "PASSWORD";

    public void run() {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("source", "universal");
        jsonObject.put("url", "https://sandbox.oxylabs.io/products/1");
        jsonObject.put("geo_location", "Germany");

        Authenticator authenticator = (route, response) -> {
            String credential = Credentials.basic(USERNAME, PASSWORD);
            return response
                    .request()
                    .newBuilder()
                    .header(AUTHORIZATION_HEADER, credential)
                    .build();
        };

        var client = new OkHttpClient.Builder()
                .authenticator(authenticator)
                .readTimeout(180, TimeUnit.SECONDS)
                .build();

        var mediaType = MediaType.parse("application/json; charset=utf-8");
        var body = RequestBody.create(jsonObject.toString(), mediaType);
        var request = new Request.Builder()
                .url("https://realtime.oxylabs.io/v1/queries")
                .post(body)
                .build();

        try (var response = client.newCall(request).execute()) {
            if (response.body() != null) {
                try (var responseBody = response.body()) {
                    System.out.println(responseBody.string());
                }
            }
        } catch (Exception exception) {
            System.out.println("Error: " + exception.getMessage());
        }

        System.exit(0);
    }

    public static void main(String[] args) {
        new Thread(new Main()).start();
    }
}
```

{% endtab %}

{% tab title="JSON" %}

```json
{
    "source": "universal", 
    "url": "https://sandbox.oxylabs.io/products/1",
    "geo_location": "Germany"
}
```

{% endtab %}
{% endtabs %}

Usamos o método de integração [**Realtime**](/products/pt-br/web-scraper-api/integration-methods/realtime.md)  síncrono em nossos exemplos. Se você quiser usar [**Proxy Endpoint**](/products/pt-br/web-scraper-api/integration-methods/proxy-endpoint.md)  ou a integração assíncrona [**Push-Pull**](/products/pt-br/web-scraper-api/integration-methods/push-pull.md) , consulte a [ **seção de métodos de integração**](/products/pt-br/web-scraper-api/integration-methods.md) .

### Sessões

Você pode forçar o mesmo endereço IP de proxy para várias solicitações incluindo o `session_id`  parâmetro **dentro de  `context`**. Defina o ID da sessão como qualquer string alfanumérica (ex.: `abc123`), e todos os trabalhos de scraping com esse ID de sessão usarão o mesmo IP. Uma sessão permanece ativa por até 25 minutos ou 100 solicitações, o que ocorrer primeiro. Isso é útil para gerenciamento de sessão quando combinado com [cookies personalizados](/products/pt-br/web-scraper-api/features/http-context-and-job-management/headers-cookies-method.md#custom-cookies).

Aqui está um exemplo:

```json
{
    "source": "universal",
    "url": "https://sandbox.oxylabs.io/products",
    "geo_location": "Germany",
    "context": [
        {
            "key": "session_id",
            "value": "abc123"
        }
    ]
}
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://developers.oxylabs.io/products/pt-br/web-scraper-api/features/localization/proxy-location.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.