# 发起请求

开始的最简单方法是发送一个不带自定义选项的简单查询。我们会在我们这边添加所有标准请求头，选择最快的代理，并返回响应正文。

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

{% hint style="info" %}
如果您观察到成功率较低或获取到空内容，请尝试添加额外的 `"x-oxylabs-render: html"` 请求头。有关 JavaScript 渲染的更多信息可以在 [**这里**](/products/cn/web-unblocker/custom-browser-instructions/javascript-rendering.md).
{% endhint %}

要使用 [**网页解锁器**](https://github.com/oxylabs/web-unblocker)的其他功能，例如设置代理位置或在连续几次请求中复用同一个 IP，请随请求发送额外的请求头。

{% hint style="info" %}
为了实现最佳的网站解锁，网页解锁器使用预定义的 Cookie、请求头和会话。请 **避免发送任何通常用于解锁的自定义参数**，因为它们可能会干扰网页解锁器获取高质量数据的能力。
{% endhint %}

以下是支持的全部功能和请求头列表：

### 其他功能

| 参数                                  | 描述                                                                                                                     | 阅读更多的链接                                                                                             |
| ----------------------------------- | ---------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
| `X-Oxylabs-Session-Id`              | 如果您想在多个请求中复用同一个 IP，请添加一个会话 ID，它可以是一串随机字符。                                                                              | [**会话**](/products/cn/web-unblocker/making-requests/session.md)                                     |
| `X-Oxylabs-Geo-Location`            | 要使用来自特定位置的 IP 地址，请指定国家或城市，例如德国。您可以在此处找到受支持的地理位置值 [**这里**](/products/cn/web-unblocker/making-requests/geo-location.md). | [**地理位置**](/products/cn/web-unblocker/making-requests/geo-location.md)                              |
| 请求头                                 | 如果您想发送自定义请求头，请在提交请求时使用 `x-oxylabs-force-headers: 1` 请求头。                                                               | [**请求头**](/products/cn/web-unblocker/making-requests/headers.md)                                    |
| Cookie                              | 您可以添加您的 Cookie，例如 `Cookie: NID=1234567890`到您的请求中。                                                                      | [**Cookie**](/products/cn/web-unblocker/making-requests/headers.md)                                 |
| `X-Oxylabs-Successful-Status-Codes` | 如果您的目标网站返回了非标准状态码，但响应成功，您可以发送响应状态码，我们的系统将不会重试该请求。                                                                      | [**自定义状态码**](/products/cn/web-unblocker/making-requests/custom-status-code.md)                      |
| `X-Oxylabs-Render`                  | 如果您想渲染 JavaScript，请使用 `html` 以获取渲染后的 HTML，或使用 `png` 以获取页面截图。                                                           | [**JavaScript 渲染**](/products/cn/web-unblocker/custom-browser-instructions/javascript-rendering.md) |

{% hint style="info" %}
如需更高级的代码示例，请参阅上方表格中链接的各个功能页面。
{% endhint %}

#### 代码示例

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

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

{% endtab %}

{% tab title="Python" %}

```python
import requests

# 在这里使用你的网页解锁器凭据。
USERNAME, PASSWORD = 'YOUR_USERNAME', 'YOUR_PASSWORD'

# 定义代理字典。
代理 = {
  '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/headers',
    verify=False，# 忽略 SSL 证书
    代理=代理,
)

# 将结果页面打印到标准输出
print(response.text)

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

// 忽略证书
process.env['NODE_TLS_REJECT_UNAUTHORIZED'] = 0;

const response = await fetch('https://ip.oxylabs.io/headers', {
  method: 'get',
  代理：agent,
});

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

{% endtab %}

{% tab title="PHP" %}

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

curl_setopt($ch, CURLOPT_URL, 'https://ip.oxylabs.io/headers');
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)}

	// 忽略证书
	customTransport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}

	client := &http.Client{Transport: customTransport}
	request, _ := http.NewRequest("GET",
		"https://ip.oxylabs.io/headers",
		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,
            };

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


---

# 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-unblocker/making-requests.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.