# Proxy Endpoint

Se você já usou proxies regulares para raspagem de dados, integrar o método de entrega Proxy Endpoint será muito fácil. Tudo o que você precisa fazer é usar nosso nó de entrada como um proxy, autenticar com credenciais do Scraper API e ignorar certificados. Em `cURL`, é `-k` ou `--insecure`. Seus dados chegarão a você por uma conexão aberta.

Proxy Endpoint **funciona apenas com as fontes de dados baseadas em URL**, onde a URL completa é fornecida. Portanto, ele aceita apenas um pequeno conjunto de parâmetros adicionais do job, que [**devem ser enviados como cabeçalhos**](#accepted-parameters).

{% hint style="warning" %}
O produto não foi projetado para ser usado diretamente com instruções de navegador personalizadas (por exemplo, Chromium, PhantomJS, Splash, etc.) e seus drivers (por exemplo, Playwright, Selenium, Puppeteer, etc.).
{% endhint %}

### Endpoint

```
GET realtime.oxylabs.io:60000
```

### Entrada

Veja um exemplo de requisição abaixo.

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

```shell
curl -k -x https://realtime.oxylabs.io:60000 \
-U 'USERNAME:PASSWORD' \
-H 'x-oxylabs-user-agent-type: desktop_chrome' \
-H 'x-oxylabs-geo-location: Germany' \
'https://www.example.com'
```

{% endtab %}

{% tab title="Python" %}

```python
import requests
from pprint import pprint

# Use suas credenciais do SERP API aqui.
USERNAME, PASSWORD = 'YOUR_USERNAME', 'YOUR_PASSWORD'

# Defina o dict de proxy.
proxies = {
  'http': f'http://{USERNAME}:{PASSWORD}@realtime.oxylabs.io:60000',
  'https': f'https://{USERNAME}:{PASSWORD}@realtime.oxylabs.io:60000'
}

# Para definir uma geo-localização específica, user-agent ou para renderizar Javascript
# é necessário enviar parâmetros como cabeçalhos da requisição.
headers = {
    'x-oxylabs-user-agent-type': 'desktop_chrome',
    'x-oxylabs-geo-location': 'Germany',
    #'X-Oxylabs-Render': 'html', # Descomente se quiser renderizar JavaScript na página.
}

response = requests.request(
    'GET',
    'https://www.example.com',
    headers = headers, # Passe os cabeçalhos definidos.
    verify=False,  # Aceite nosso certificado.
    proxies=proxies,
)

# Imprima a página de resultado no stdout.
pprint(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" %}

```shell
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}@realtime.oxylabs.io:60000`
);

// Recomendamos aceitar nosso certificado em vez de permitir tráfego inseguro (http)
process.env['NODE_TLS_REJECT_UNAUTHORIZED'] = 0;

const headers = {
  'x-oxylabs-user-agent-type': 'desktop_chrome',
  'x-oxylabs-geo-location': 'Germany',
}

const response = await fetch('https://www.example.com', {
  method: 'get',
  headers: headers,
  agent: agent,
});

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

{% endtab %}

{% tab title="PHP" %}

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

curl_setopt($ch, CURLOPT_URL, 'https://www.example.com/');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_PROXY, 'https://realtime.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);
// Para definir uma geo-localização específica, user-agent ou para renderizar Javascript
// é necessário enviar parâmetros como cabeçalhos da requisição.
curl_setopt_array($ch, array(
    CURLOPT_HTTPHEADER  => array(
        'x-oxylabs-user-agent-type: desktop_chrome',
        'x-oxylabs-geo-location: Germany',
        //'X-Oxylabs-Render: html', // Descomente se quiser renderizar JavaScript na página.
    )
));

$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@realtime.oxylabs.io:60000",
			Username,
			Password,
		),
	)
	customTransport := &http.Transport{Proxy: http.ProxyURL(proxyUrl)}

	// Recomendamos aceitar nosso certificado em vez de permitir tráfego inseguro (http)
	customTransport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}

	client := &http.Client{Transport: customTransport}
	request, _ := http.NewRequest("GET",
		"https://www.example.com",
		nil,
	)

	request.Header.Add("x-oxylabs-user-agent-type", "desktop_chrome")
	request.Header.Add("x-oxylabs-geo-location", "Germany")
	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.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://realtime.oxylabs.io:60000"),
                BypassProxyOnLocal = false,
                UseDefaultCredentials = false,

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

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

            // Recomendamos aceitar nosso certificado em vez de permitir tráfego inseguro (http)
            httpClientHandler.ClientCertificateOptions = ClientCertificateOption.Manual;
            httpClientHandler.ServerCertificateCustomValidationCallback =
                (httpRequestMessage, cert, cetChain, policyErrors) =>
                {
                    return true;
                };


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

            client.DefaultRequestHeaders.Add("x-oxylabs-user-agent-type", "desktop_chrome");
            client.DefaultRequestHeaders.Add("x-oxylabs-geo-location", "Germany");

            Uri baseUri = new Uri("https://www.example.com");
            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("realtime.oxylabs.io", 60000), "USERNAME", "PASSWORD".toCharArray())
                .build();
        final HttpHost target = new HttpHost("https", "example.com", 443);
        final HttpHost proxy = new HttpHost("https", "realtime.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("/");
            request.addHeader("x-oxylabs-user-agent-type","desktop_chrome");
            request.addHeader("x-oxylabs-geo-location","Germany");
            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 %}

### Saída

Abaixo você encontrará uma resposta de exemplo de `https://example.com`:

<details>

<summary>Resposta de exemplo</summary>

```html
<!doctype html>
<html>
<head>
    <title>Example Domain</title>

    <meta charset="utf-8" />
    <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <style type="text/css">
    body {
        background-color: #f0f0f2;
        margin: 0;
        padding: 0;
        font-family: -apple-system, system-ui, BlinkMacSystemFont, "Segoe UI", "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
        
    }
    div {
        width: 600px;
        margin: 5em auto;
        padding: 2em;
        background-color: #fdfdff;
        border-radius: 0.5em;
        box-shadow: 2px 3px 7px 2px rgba(0,0,0,0.02);
    }
    a:link, a:visited {
        color: #38488f;
        text-decoration: none;
    }
    @media (max-width: 700px) {
        div {
            margin: 0 auto;
            width: auto;
        }
    }
    </style>    
</head>

<body>
<div>
    <h1>Example Domain</h1>
    <p>Este domínio é para uso em exemplos ilustrativos em documentos. Você pode usar este
    domínio na literatura sem coordenação prévia ou pedir permissão.</p>
    <p><a href="https://www.iana.org/domains/example">Mais informações...</a></p>
</div>
</body>
</html>
```

</details>

### Parâmetros aceitos

Ao fazer sua requisição, junto com a URL, você pode nos enviar alguns parâmetros de job que usaremos ao executar seu trabalho. Os parâmetros do job devem ser enviados nos cabeçalhos da sua requisição - veja um exemplo [**aqui**](#input)**.**

Aqui está a lista de parâmetros de job que você pode enviar com requisições do Proxy Endpoint:

| Parâmetro                   | Descrição                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `x-oxylabs-user-agent-type` | Não há como indicar um User-Agent específico, mas você pode nos informar qual tipo de user-agent você gostaria que usássemos. Uma lista dos tipos de User-Agent suportados pode ser encontrada [**aqui**](https://developers.oxylabs.io/documentation/pt-br/solucoes-de-scraping/web-scraper-api/features/http-context-and-job-management/user-agent-type).                                                                                           |
| `x-oxylabs-geo-location`    | Em alguns casos, pode ser necessário indicar a localização geográfica para a qual o resultado deve ser adaptado. Este parâmetro corresponde ao `geo_location` parâmetro, descrito separadamente na documentação a nível de fonte. Os valores aceitos dependem da URL que você deseja que raspemos. Leia mais [**aqui**](https://developers.oxylabs.io/documentation/pt-br/solucoes-de-scraping/web-scraper-api/features/localization/proxy-location). |
| `x-oxylabs-render`          | Execução de JavaScript. Leia mais [**aqui**](https://developers.oxylabs.io/documentation/pt-br/solucoes-de-scraping/web-scraper-api/features/js-rendering-and-browser-control/javascript-rendering).                                                                                                                                                                                                                                                  |