# Ubicación del proxy

Use el `geo_location` parámetro para seleccionar la ubicación del servidor proxy. Esto te permite extraer datos como si estuvieras navegando desde otro país. 

<details>

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

```
Islas Åland
Afganistán
Albania
Argelia
Samoa Americana
Andorra
Angola
Anguila
Antártida
Antigua y Barbuda
Argentina
Armenia
Aruba
Australia
Austria
Azerbaiyán
Bahamas
Baréin
Bangladés
Barbados
Bielorrusia
Bélgica
Belice
Benín
Bermudas
Bután
Bolivia Estado Plurinacional de
Bonaire San Eustaquio y Saba
Bosnia y Herzegovina
Botsuana
Isla Bouvet
Brasil
Territorio Británico del Océano Índico
Brunéi Darussalam
Bulgaria
Burkina Faso
Burundi
Cabo Verde
Camboya
Camerún
Canadá
Islas Caimán
República Centroafricana
Chad
Chile
China
Isla de Navidad
Islas Cocos Keeling
Colombia
Comoras
Congo
Congo la República Democrática del
Islas Cook
Costa Rica
Côte dIvoire
Croacia
Cuba
Curazao
Chipre
Chequia
Dinamarca
Yibuti
Dominica
República Dominicana
Ecuador
Egipto
El Salvador
Guinea Ecuatorial
Eritrea
Estonia
Esuatini
Etiopía
Islas Malvinas [Falkland]
Islas Feroe
Fiyi
Finlandia
Francia
Guayana Francesa
Polinesia Francesa
Territorios Australes Franceses
Gabón
Gambia
Georgia
Alemania
Ghana
Gibraltar
Grecia
Groenlandia
Granada
Guadalupe
Guam
Guatemala
Guernesey
Guinea
Guinea-Bisáu
Guyana
Haití
Isla Heard e Islas McDonald
Santa Sede
Honduras
Hong Kong
Hungría
Islandia
India
Indonesia
Irán República Islámica de
Irak
Irlanda
Isla de Man
Israel
Italia
Jamaica
Japón
Jersey
Jordania
Kazajistán
Kenia
Kiribati
Corea
Kuwait
Kirguistán
República Democrática Popular Lao
Letonia
Líbano
Lesoto
Liberia
Libia
Liechtenstein
Lituania
Luxemburgo
Macao
Madagascar
Malaui
Malasia
Maldivas
Malí
Malta
Islas Marshall
Martinica
Mauritania
Mauricio
Mayotte
México
Micronesia Estados Federados de
Moldova República de
Mónaco
Mongolia
Montenegro
Montserrat
Marruecos
Mozambique
Myanmar
Namibia
Nauru
Nepal
Países Bajos
Nueva Caledonia
Nueva Zelanda
Nicaragua
Níger
Nigeria
Niue
Isla Norfolk
Islas Marianas del Norte
Noruega
Omán
Pakistán
Palaos
Palestina Estado de
Panamá
Papúa Nueva Guinea
Paraguay
Perú
Filipinas
Pitcairn
Polonia
Portugal
Puerto Rico
Catar
República de Macedonia del Norte
Reunión
Rumanía
Rusia
Ruanda
San Bartolomé
Santa Elena Ascensión y Tristan da Cunha
San Cristóbal y Nieves
Santa Lucía
San Martín parte francesa
San Pedro y Miquelón
San Vicente y las Granadinas
Samoa
San Marino
Santo Tomé y Príncipe
Arabia Saudita
Senegal
Serbia
Seychelles
Sierra Leona
Singapur
Sint Maarten parte neerlandesa
Eslovaquia
Eslovenia
Islas Salomón
Somalia
Sudáfrica
Islas Georgias del Sur y Sandwich del Sur
Sudán del Sur
España
Sri Lanka
Sudán
Surinam
Svalbard y Jan Mayen
Suecia
Suiza
República Árabe Siria
Taiwán Provincia de China
Tayikistán
Tanzania República Unida de
Tailandia
Timor-Leste
Togo
Tokelau
Tonga
Trinidad y Tobago
Túnez
Turquía
Turkmenistán
Islas Turcas y Caicos
Tuvalu
Uganda
Ucrania
Emiratos Árabes Unidos
Reino Unido
Estados Unidos
Islas Menores Alejadas de los Estados Unidos
Uruguay
Uzbekistán
Vanuatu
Venezuela República Bolivariana de
Vietnam
Islas Vírgenes Británicas
Islas Vírgenes U.S.
Wallis y Futuna
Sahara Occidental
Yemen
Zambia
Zimbabue
```

</details>

{% hint style="warning" %}
`geo_location` el parámetro funciona de manera diferente para [**SERP**](/products/es/web-scraper-api/features/localization/serp-localization.md) y [**E-Commerce**](/products/es/web-scraper-api/features/localization/e-commerce-localization.md) localización. Lee más en las secciones correspondientes.
{% endhint %}

### Solicitar ejemplo

Este ejemplo recupera una página de producto usando un proxy en Alemania.

{% 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,
)

# En lugar de una respuesta con el estado del trabajo y la URL de resultados, esto devolverá la
# respuesta JSON con el resultado.
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="HTTP" %}

```http
# La cadena completa que envíes tiene que estar codificada en URL.

https://realtime.oxylabs.io/v1/queries?source=universal&url=https%3A%2F%2Fsandbox.oxylabs.io%2Fproducts%2F1&geo_location=Germany&access_token=12345abcde
```

{% 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 el método de integración síncrona [**Realtime**](/products/es/web-scraper-api/integration-methods/realtime.md) en nuestros ejemplos. Si deseas usar [**Proxy Endpoint**](/products/es/web-scraper-api/integration-methods/proxy-endpoint.md) o integración asíncrona [**Push-Pull**](/products/es/web-scraper-api/integration-methods/push-pull.md) consulta la [**métodos de integración**](/products/es/web-scraper-api/integration-methods.md) sección.

### Sesiones

Puedes forzar la misma dirección IP del proxy para varias solicitudes incluyendo el `session_id` parámetro. Establece el ID de sesión en cualquier cadena alfanumérica (por ejemplo, `abc123`), y todos los trabajos de extracción con ese ID de sesión usarán la misma IP. Esto es útil para la gestión de sesiones cuando se combina con [cookies personalizadas](/products/es/web-scraper-api/features/http-context-and-job-management/headers-cookies-method.md#custom-cookies).

Aquí tienes un ejemplo:

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


---

# Agent Instructions: 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:

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

The question should be specific, self-contained, and written in natural language.
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.