# Web Unblocker

[**Web Unblocker**](https://oxylabs.io/products/web-unblocker) es una **Solución de proxy impulsada por IA** que gestiona el proceso de desbloqueo para extraer datos públicos incluso de los sitios web más difíciles. 

{% hint style="info" %}
Puedes probar Web Unblocker por **1 semana gratis**. Regístrate en Oxylabs [**panel de control**](https://dashboard.oxylabs.io/en/registration) para empezar.
{% endhint %}

El producto no es un proxy común, sino un sistema más avanzado que gestiona múltiples procesos de scraping, como:

* Gestión automática del tipo de proxy
* Generación de huella digital del navegador
* Reintentos automáticos
* Mantenimiento de sesiones
* renderizado de JavaScript

[**Web Unblocker**](https://github.com/oxylabs/web-unblocker) garantiza una tasa de éxito mucho mayor en comparación con los proxies regulares. También admite **encabezados personalizados** definidos por el usuario y **sticky IP** junto con **cookies reutilizables** y **Solicitudes POST**.

### Empezando

Integrar [**Web Unblocker**](https://oxylabs.io/products/web-unblocker) es fácil, especialmente si antes has usado [**Proxies**](https://oxylabs.io/products/residential-proxy-pool) regulares para web scraping. La única diferencia es que te pedimos que ignores el certificado SSL usando los `-k` o `--insecure` flags de cURL (o una expresión equivalente en el lenguaje de tu elección).

Para hacer una solicitud con Web Unblocker, necesitas usar el `unblock.oxylabs.io:60000` Proxy Endpoint. Consulta un ejemplo de cURL a continuación. Puedes encontrar ejemplos de código en otros lenguajes [**aquí**](/products/es/web-unblocker/making-requests.md) o ejemplos completos de código en nuestro [**GitHub**](https://github.com/oxylabs/product-integrations/tree/master/web-unblocker).

{% hint style="info" %}
Usa [**ip.oxylabs.io/location**](https://ip.oxylabs.io/location) para comprobar los parámetros de tus IP: este dominio proporciona información de cuatro bases de datos de geolocalización: MaxMind, IP2Location, DB-IP e IPinfo.io. Los parámetros incluyen dirección IP, proveedor, país, ciudad, código postal, ASN, nombre de la organización, zona horaria y meta (cuando lo divulga la base de datos).
{% endhint %}

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

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

{% 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/location',
    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/location', {
  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/location');
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/location",
		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/location");
            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("/location");
            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 %}

{% hint style="info" %}
Si observas tasas de éxito bajas o recuperas contenido vacío, intenta añadir adicionalmente `"x-oxylabs-render: html"` encabezado con tu solicitud.
{% endhint %}

{% hint style="warning" %}
Si Web Unblocker se está usando para extraer sitios web que dependen de cargar datos mediante JavaScript, consulta la [**renderizado de JavaScript**](/products/es/web-unblocker/custom-browser-instructions/javascript-rendering.md) sección. El producto no está diseñado para usarse directamente con navegadores sin interfaz gráfica (p. ej., Chromium, PhantomJS, Splash, etc.) ni con sus controladores (p. ej., Playwright, Selenium, Puppeteer, etc.).
{% endhint %}

Mira el video a continuación para ver un ejemplo de cómo extraer un objetivo difícil sin ser bloqueado:

{% embed url="<https://www.youtube.com/watch?v=KGOsWPF4Wfs>" %}

#### Lección

Si quieres aprender más sobre cómo obtener datos a gran escala con [**Web Unblocker**](https://github.com/oxylabs/web-unblocker) - te sugerimos ver esta lección de Scraping Experts:

{% embed url="<https://experts.oxylabs.io/pages/bypassing-sophisticated-anti-bot-systems>" %}


---

# 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.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.