# Proxy Endpoint

如果您曾经使用过常规代理进行数据抓取，集成 Proxy Endpoint 交付方式将会轻而易举。您需要做的只是将我们的入口节点用作代理，使用网页爬虫API 凭证进行授权，并忽略证书。在 `cURL`中，它是 `-k` 或 `--insecure`。您的数据将通过开放连接传送给您。

Proxy Endpoint **仅适用于基于 URL 的数据源**，即提供完整 URL 的情况。因此，它只接受少量附加任务参数，这些参数 [**应作为标头发送**](#accepted-parameters).

{% hint style="warning" %}
该产品并非设计为直接与自定义浏览器指令（例如 Chromium、PhantomJS、Splash 等）及其驱动程序（例如 Playwright、Selenium、Puppeteer 等）一起使用。
{% endhint %}

### 端点

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

### 输入

请参见下面的请求示例。

{% 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

# 请在此使用您的 SERP API 凭证。
USERNAME, PASSWORD = 'YOUR_USERNAME', 'YOUR_PASSWORD'

# 定义代理字典。
代理 = {
  'http': f'http://{USERNAME}:{PASSWORD}@realtime.oxylabs.io:60000',
  'https': f'https://{USERNAME}:{PASSWORD}@realtime.oxylabs.io:60000'
}

# 如需设置特定地理位置、user-agent 或渲染 Javascript
# 则必须将参数作为请求标头发送。
headers = {
    'x-oxylabs-user-agent-type': 'desktop_chrome',
    'x-oxylabs-geo-location': 'Germany',
    #'X-Oxylabs-Render': 'html', # 如果您想在页面内渲染 JavaScript，请取消注释。
}

response = requests.request(
    'GET',
    'https://www.example.com',
    headers = headers, # 传递已定义的标头。
    verify=False,  # 接受我们的证书。
    代理=代理,
)

# 将结果页面打印到 stdout。
pprint(response.text)

# 将返回的 HTML 保存到 '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`
);

// 我们建议接受我们的证书，而不是允许不安全（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,
});

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);
// 如需设置特定地理位置、user-agent 或渲染 Javascript
// 则必须将参数作为请求标头发送。
curl_setopt_array($ch, array(
    CURLOPT_HTTPHEADER  => array(
        'x-oxylabs-user-agent-type: desktop_chrome',
        'x-oxylabs-geo-location: Germany',
        //'X-Oxylabs-Render: html', // 如果您想在页面内渲染 JavaScript，请取消注释。
    )
));

$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)}

	// 我们建议接受我们的证书，而不是允许不安全（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,
            };

            // 我们建议接受我们的证书，而不是允许不安全（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)
                // 我们建议接受我们的证书，而不是允许不安全（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("正在执行请求 " + request.getMethod() + " " + request.getUri() +
                    " 通过 " + proxy + " 请求头: " + Arrays.toString(request.getHeaders()));

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

{% endtab %}
{% endtabs %}

### 输出

下面您将看到来自以下地址的示例响应 `https://example.com`:

<details>

<summary>示例响应</summary>

```html
<!doctype html>
<html>
<head>
    <title>示例域名</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>示例域名</h1>
    <p>此域名用于文档中的说明性示例。您可以在
    文学作品中使用此域名，无需事先协调或请求许可。</p>
    <p><a href="https://www.iana.org/domains/example">更多信息...</a></p>
</div>
</body>
</html>
```

</details>

### 接受的参数

在发出请求时，除了 URL 之外，您还可以向我们发送一些任务参数，我们会在执行您的任务时使用这些参数。任务参数应在您的请求标头中发送——请参见示例 [**这里**](#input)**.**

以下是您可以随 Proxy Endpoint 请求发送的任务参数列表：

| 参数                          | 描述                                                                                                                                                                            |
| --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `x-oxylabs-user-agent-type` | 无法指定特定的 User-Agent，但您可以告知我们希望使用哪种 user-agent 类型。支持的 User-Agent 类型列表可在此处找到 [**这里**](/products/cn/web-scraper-api/features/http-context-and-job-management/user-agent-type.md). |
| `x-oxylabs-geo-location`    | 在某些情况下，您可能需要指明结果应适配的地理位置。此参数对应于 `geo_location` 参数，该参数在源级文档中单独说明。可接受的值取决于您希望我们抓取的 URL。阅读更多 [**这里**](/products/cn/web-scraper-api/features/localization/proxy-location.md).     |
| `x-oxylabs-render`          | JavaScript 执行。阅读更多 [**这里**](/products/cn/web-scraper-api/features/js-rendering-and-browser-control.md).                                                                       |


---

# 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/cn/web-scraper-api/integration-methods/proxy-endpoint.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.