# Realización de solicitudes

La forma más fácil de empezar es enviar una consulta simple sin opciones personalizadas. Añadiremos todos los encabezados estándar de nuestro lado, elegiremos el proxy más rápido y te entregaremos el cuerpo de la respuesta.

```bash
curl -k -x https://unblock.oxylabs.io:60000 \
-U 'USERNAME:PASSWORD' \
'https://ip.oxylabs.io/location'
```

{% hint style="info" %}
Si observas tasas de éxito bajas o recuperas contenido vacío, intenta añadir adicionalmente `"x-oxylabs-render: html"` el encabezado con tu solicitud. Puedes encontrar más información sobre el renderizado de JavaScript [**aquí**](/products/es/web-unblocker/custom-browser-instructions/javascript-rendering.md).
{% endhint %}

Para utilizar funcionalidades adicionales de [**Web Unblocker**](https://github.com/oxylabs/web-unblocker), como configurar la ubicación del proxy o reutilizar la misma IP durante unas pocas solicitudes consecutivas, envía encabezados adicionales con la solicitud.

{% hint style="info" %}
Para un desbloqueo óptimo de sitios web, Web Unblocker utiliza cookies, encabezados y sesiones predefinidos. Por favor, **evita enviar cualquier parámetro personalizado que se use comúnmente para el desbloqueo**, ya que pueden interferir con la capacidad de Web Unblocker para obtener datos de calidad.
{% endhint %}

Aquí está la lista completa de funcionalidades y encabezados compatibles:

### Funciones adicionales

| Parámetro                           | Descripción                                                                                                                                                                                                                                         | Enlace para leer más                                                                                            |
| ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| `X-Oxylabs-Session-Id`              | Si deseas reutilizar la misma IP para varias solicitudes, añade un ID de sesión que puede ser una cadena aleatoria de caracteres.                                                                                                                   | [**Sesión**](/products/es/web-unblocker/making-requests/session.md)                                             |
| `X-Oxylabs-Geo-Location`            | Para usar una dirección IP de una ubicación específica, especifica un país o una ciudad, por ejemplo, Alemania. Puedes encontrar los valores de geolocalización compatibles [**aquí**](/products/es/web-unblocker/making-requests/geo-location.md). | [**Geolocalización**](/products/es/web-unblocker/making-requests/geo-location.md)                               |
| Encabezados                         | Si quieres enviar encabezados personalizados, usa `x-oxylabs-force-headers: 1` encabezado al enviar tu solicitud.                                                                                                                                   | [**Encabezados**](/products/es/web-unblocker/making-requests/headers.md)                                        |
| cookies                             | Puedes añadir tus cookies, por ejemplo, `Cookie: NID=1234567890`, a tus solicitudes.                                                                                                                                                                | [**cookies**](/products/es/web-unblocker/making-requests/headers.md)                                            |
| `X-Oxylabs-Successful-Status-Codes` | Si tu sitio objetivo devuelve un código de estado no estándar con una respuesta exitosa, puedes enviar el código de estado de la respuesta, y nuestro sistema no volverá a intentar la solicitud.                                                   | [**Código de estado personalizado**](/products/es/web-unblocker/making-requests/custom-status-code.md)          |
| `X-Oxylabs-Render`                  | Si deseas renderizar JavaScript, usa `html` para obtener un HTML renderizado o `png` para obtener una captura de pantalla de la página.                                                                                                             | [**renderizado de JavaScript**](/products/es/web-unblocker/custom-browser-instructions/javascript-rendering.md) |

{% hint style="info" %}
Para ejemplos de código más avanzados, consulta las páginas de funcionalidades individuales enlazadas en la tabla anterior.
{% endhint %}

#### Ejemplos de código

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

```shell
curl -k -x https://unblock.oxylabs.io:60000 \
-U 'USERNAME:PASSWORD' \
'https://ip.oxylabs.io/headers'
```

{% endtab %}

{% tab title="Python" %}

```python
import requests

# Usa aquí tus credenciales de Web Unblocker.
USERNAME, PASSWORD = 'YOUR_USERNAME', 'YOUR_PASSWORD'

# Define el diccionario de proxies.
proxies = {
  'http': f'http://{USERNAME}:{PASSWORD}@unblock.oxylabs.io:60000',
  'https': f'https://{USERNAME}:{PASSWORD}@unblock.oxylabs.io:60000',
}

response = requests.request(
    'GET',
    'https://ip.oxylabs.io/headers',
    verify=False,  # Ignore the SSL certificate
    proxies=proxies,
)

# Imprime la página de resultados en stdout
print(response.text)

# Guarda el HTML devuelto en el archivo result.html
with open('result.html', 'w') as f:
    f.write(response.text)
```

{% endtab %}

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

```javascript
import fetch from 'node-fetch';
import { HttpsProxyAgent } from 'https-proxy-agent';

const username = 'YOUR_USERNAME';
const password = 'YOUR_PASSWORD';

const agent = new HttpsProxyAgent(
  `https://${username}:${password}@unblock.oxylabs.io:60000`
);

// Ignorar el certificado
process.env['NODE_TLS_REJECT_UNAUTHORIZED'] = 0;

const response = await fetch('https://ip.oxylabs.io/headers', {
  method: 'get',
  agent: agent,
});

console.log(await response.text());
```

{% endtab %}

{% tab title="PHP" %}

```php
<?php
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://ip.oxylabs.io/headers');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_PROXY, 'https://unblock.oxylabs.io:60000');
curl_setopt($ch, CURLOPT_PROXYUSERPWD, 'YOUR_USERNAME' . ':' . 'YOUR_PASSWORD');
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);

$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 (
	"crypto/tls"
	"fmt"
	"io/ioutil"
	"net/http"
	"net/url"
)

func main() {
	const Username = "YOUR_USERNAME"
	const Password = "YOUR_PASSWORD"

	proxyUrl, _ := url.Parse(
		fmt.Sprintf(
			"https://%s:%s@unblock.oxylabs.io:60000",
			Username,
			Password,
		),
	)
	customTransport := &http.Transport{Proxy: http.ProxyURL(proxyUrl)}

	// Ignorar el certificado
	customTransport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}

	client := &http.Client{Transport: customTransport}
	request, _ := http.NewRequest("GET",
		"https://ip.oxylabs.io/headers",
		nil,
	)

	response, _ := client.Do(request)

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

```

{% endtab %}

{% tab title="C#" %}

```csharp
using System;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;

namespace OxyApi
{
    class Program
    {
        static async Task Main(string[] args)
        {
            var webProxy = new WebProxy
            {
                Address = new Uri("https://unblock.oxylabs.io:60000"),
                BypassProxyOnLocal = false,
                UseDefaultCredentials = false,

                Credentials = new NetworkCredential(
                userName: "YOUR_USERNAME",
                password: "YOUR_PASSWORD"
                )
            };

            var httpClientHandler = new HttpClientHandler
            {
                Proxy = webProxy,
            };

            // Ignorar el certificado
            httpClientHandler.ClientCertificateOptions = ClientCertificateOption.Manual;
            httpClientHandler.ServerCertificateCustomValidationCallback =
                (httpRequestMessage, cert, cetChain, policyErrors) =>
                {
                    return true;
                };


            var client = new HttpClient(handler: httpClientHandler, disposeHandler: true);

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

            var requestMessage = new HttpRequestMessage(HttpMethod.Get, "");

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

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

{% endtab %}

{% tab title="Java" %}

```java
package org.example;

import org.apache.hc.client5.http.auth.AuthScope;
import org.apache.hc.client5.http.auth.CredentialsProvider;
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.config.RequestConfig;
import org.apache.hc.client5.http.impl.auth.CredentialsProviderBuilder;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder;
import org.apache.hc.client5.http.ssl.NoopHostnameVerifier;
import org.apache.hc.client5.http.ssl.SSLConnectionSocketFactoryBuilder;
import org.apache.hc.client5.http.ssl.TrustAllStrategy;
import org.apache.hc.core5.http.HttpHost;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.http.message.StatusLine;
import org.apache.hc.core5.ssl.SSLContextBuilder;

import java.util.Arrays;
import java.util.Properties;


public class Main {

    public static void main(final String[] args)throws Exception {
        final CredentialsProvider credsProvider = CredentialsProviderBuilder.create()
                .add(new AuthScope("unblock.oxylabs.io", 60000), "USERNAME", "PASSWORD".toCharArray())
                .build();
        final HttpHost target = new HttpHost("https", "ip.oxylabs.io", 443);
        final HttpHost proxy = new HttpHost("https", "unblock.oxylabs.io", 60000);
        try (final CloseableHttpClient httpclient = HttpClients.custom()
                .setDefaultCredentialsProvider(credsProvider)
                .setProxy(proxy)
                // Recomendamos aceptar nuestro certificado en lugar de permitir tráfico inseguro (http)
                .setConnectionManager(PoolingHttpClientConnectionManagerBuilder.create()
                        .setSSLSocketFactory(SSLConnectionSocketFactoryBuilder.create()
                                .setSslContext(SSLContextBuilder.create()
                                        .loadTrustMaterial(TrustAllStrategy.INSTANCE)
                                        .build())
                                .setHostnameVerifier(NoopHostnameVerifier.INSTANCE)
                                .build())
                        .build())
                .build()) {

            final RequestConfig config = RequestConfig.custom()
                    .build();
            final HttpGet request = new HttpGet("/headers");
            request.setConfig(config);

            System.out.println("Executing request " + request.getMethod() + " " + request.getUri() +
                    " via " + proxy + " headers: " + Arrays.toString(request.getHeaders()));

            httpclient.execute(target, request, response -> {
                System.out.println("----------------------------------------");
                System.out.println(request + "->" + new StatusLine(response));
                EntityUtils.consume(response.getEntity());
                return null;
            });
        }
    }
}
```

{% endtab %}
{% endtabs %}


---

# 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-unblocker/making-requests.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.