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

# Web Unblocker

Aprenda a usar Web Unblocker, uma solução de proxy com IA que permite acessar até os sites mais difíceis.

[**Web Unblocker**](https://oxylabs.io/products/web-unblocker) é uma **Solução de proxy com IA** que gerencia o processo de requisições para extrair dados públicos mesmo dos sites mais difíceis.

{% hint style="info" %}
Você pode experimentar o Web Unblocker por **gratuitamente por 1 semana**. Cadastre-se na Oxylabs [**painel**](https://dashboard.oxylabs.io/en/registration) para começar.
{% endhint %}

O produto não é um proxy comum, mas um sistema mais avançado que gerencia vários processos de scraping, como:

* Gerenciamento automático do tipo de proxy
* Geração da impressão digital do navegador
* Tentativas automáticas
* Manutenção de sessões
* renderização de JavaScript

[**Web Unblocker**](https://github.com/oxylabs/web-unblocker) garante uma taxa de sucesso muito maior em comparação com Proxies regulares. Ele também oferece suporte a **cabeçalhos personalizados** definidos pelo usuário e **persistência de IP** junto com **cookies reutilizáveis** e **Requisições POST**.

### Primeiros passos

Integrar [**Web Unblocker**](https://oxylabs.io/products/web-unblocker) é fácil, especialmente se você já usou Proxies regulares [**para web scraping. A única diferença é que exigimos que você ignore o certificado SSL usando as**](https://oxylabs.io/products/residential-proxy-pool) flags do cURL (ou uma expressão equivalente na linguagem de sua escolha). `-k` ou `--insecure` cURL flags (ou uma expressão equivalente na linguagem de sua escolha).

Para fazer uma requisição com o Web Unblocker, você precisa usar o `unblock.oxylabs.io:60000` Proxy Endpoint. Veja um exemplo de cURL abaixo. Você pode encontrar exemplos de código em outras linguagens [**aqui**](/products/pt-br/web-unblocker/making-requests.md) ou exemplos completos de código em nosso [**GitHub**](https://github.com/oxylabs/product-integrations/tree/master/web-unblocker).

{% hint style="info" %}
Use [**ip.oxylabs.io/location**](https://ip.oxylabs.io/location) para verificar os parâmetros dos seus IPs – este domínio entrega informações de quatro bancos de dados de geolocalização: MaxMind, IP2Location, DB-IP e IPinfo.io. Os parâmetros incluem endereço IP, provedor, país, cidade, CEP, ASN, nome da organização, fuso horário e meta (quando divulgado pelo banco de dados).
{% 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 suas credenciais do Web Unblocker aqui.
USERNAME, PASSWORD = 'YOUR_USERNAME', 'YOUR_PASSWORD'

# Defina o dicionário de proxy.
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,
)

# Imprima a página de resultado na saída padrão
print(response.text)

# Salve o HTML retornado no arquivo 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`
);

// 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)
                // Recomendamos aceitar nosso certificado em vez de permitir tráfego 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" %}
Se você estiver observando taxas de sucesso baixas ou recebendo conteúdo vazio, tente adicionar um adicional `"x-oxylabs-render: html"` cabeçalho com sua requisição.
{% endhint %}

{% hint style="warning" %}
Se o Web Unblocker estiver sendo usado para extrair dados de sites que dependem de carregamento de dados via JavaScript, consulte a [**renderização de JavaScript**](/products/pt-br/web-unblocker/custom-browser-instructions/javascript-rendering.md) seção. O produto não foi projetado para ser usado diretamente com navegadores headless (por exemplo, Chromium, PhantomJS, Splash etc.) e seus drivers (por exemplo, Playwright, Selenium, Puppeteer etc.).
{% endhint %}

Assista ao vídeo abaixo para um exemplo de extração de um alvo difícil sem interrupções:

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

#### Lição

Se você quiser aprender mais sobre obtenção de dados em larga escala com [**Web Unblocker**](https://github.com/oxylabs/web-unblocker) - sugerimos assistir a esta lição 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 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-unblocker.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.