> 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/es/web-unblocker.md).

# Web Unblocker

Aprende a usar Web Unblocker, una solución de proxy impulsada por IA que te permite acceder incluso a los sitios más difíciles.

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

{% hint style="info" %}
Puedes probar Web Unblocker gratis con un crédito de bienvenida de $5. Regístrate en Oxylabs [**panel de control**](https://dashboard.oxylabs.io/en/registration) para comenzar.
{% endhint %}

El producto no es un proxy normal, sino un sistema más avanzado que gestiona varios 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 normales. También admite **encabezados personalizados** definidos por el usuario y **persistencia de IP** junto con **cookies reutilizables** y **solicitudes POST**.

### Primeros pasos

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

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 de código completos en nuestro [**GitHub**](https://github.com/oxylabs/product-integrations/tree/master/web-unblocker).

{% hint style="info" %}
Utilice [**ip.oxylabs.io/location**](https://ip.oxylabs.io/location) para comprobar los parámetros de tus IPs – este dominio ofrece 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 metadatos (cuando la base de datos los divulga).
{% 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

# Use your Web Unblocker credentials here.
USERNAME, PASSWORD = 'YOUR_USERNAME', 'YOUR_PASSWORD'

# Define proxy dict.
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,
)

# Print result page to stdout
print(response.text)

# Save returned HTML to result.html file
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`
);

// Ignore the certificate
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)}

	// Ignore the certificate
	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,
            };

            // Ignore the certificate
            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)
                // We recommend accepting our certificate instead of allowing insecure (http) traffic
                .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 bajas tasas de éxito o recuperas contenido vacío, intenta añadir el encabezado adicional `"x-oxylabs-render: html"` con tu solicitud.
{% endhint %}

{% hint style="warning" %}
Si Web Unblocker se está usando para extraer datos de 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 headless (p. ej., Chromium, PhantomJS, Splash, etc.) ni con sus controladores (p. ej., Playwright, Selenium, Puppeteer, etc.).
{% endhint %}

Mira el video a continuación para un ejemplo de scraping de un objetivo difícil sin interrupciones:

{% 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
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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://developers.oxylabs.io/products/es/web-unblocker.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.