POST 请求

网页解锁器 (Web Unblocker) 不仅支持发送 GET 请求，还允许您向您选择的 Web 端点发送 POST。您可以将数据发送到目标网站，从而使其返回不同的结果。

代码示例

curl -k -v -x https://unblock.oxylabs.io:60000 \
-U 'USERNAME:PASSWORD' \
'https://ip.oxylabs.io/location' \
-d '您的 POST JSON：data'

# 网页解锁器不仅支持发送 GET 请求，还允许您向您选择的 Web 端点发送 POST。这意味着您可以将数据发送到目标网站，从而使网站返回不同的结果。
import requests

# 在此使用您的 Web Unblocker 凭证。
USERNAME, PASSWORD = 'YOUR_USERNAME', 'YOUR_PASSWORD'

# 定义 proxy 字典。
proxies = {
  'http': f'http://{USERNAME}:{PASSWORD}@unblock.oxylabs.io:60000',
  'https': f'https://{USERNAME}:{PASSWORD}@unblock.oxylabs.io:60000',
}

data = {
    '您的 POST JSON': 'data'
}

response = requests.post(
    'https://ip.oxylabs.io/location',
    verify=False,  # 需要忽略证书
    proxies=proxies,
    json=data,
)

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

# 将返回的 HTML 保存到 result.html 文件
with open('result.html', 'w') as f:
    f.write(response.text)

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`
);

// 我们建议接受我们的证书，而不是允许不安全的 (http) 流量
process.env['NODE_TLS_REJECT_UNAUTHORIZED'] = 0;

const headers = {
  'Content-Type': 'application/json',
}

const body = {
  '您的 POST JSON': 'data'
};

const response = await fetch('https://ip.oxylabs.io/location', {
  method: 'post',
  body: JSON.stringify(body),
  headers: headers,
  agent: agent,
});

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

<?php
$ch = curl_init();

// 设置请求以通过 POST 发送 json
$data = [
    '您的 POST JSON' => 'data'
];
$payload = json_encode($data);

// 将编码后的 JSON 字符串附加到 POST 字段
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_POST, true);
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);

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:%[email protected]:60000",
			Username,
			Password,
		),
	)
	customTransport := &http.Transport{Proxy: http.ProxyURL(proxyUrl)}

	// 我们建议接受我们的证书，而不是允许不安全的 (http) 流量
	customTransport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
	
	payload := map[string]string{
		"您的 POST JSON": "data",
	}

	jsonValue, _ := json.Marshal(payload)

	client := &http.Client{Transport: customTransport}
	request, _ := http.NewRequest("POST",
		"https://ip.oxylabs.io/location",
		bytes.NewBuffer(jsonValue),
	)
        
	response, _ := client.Do(request)

	responseText, _ := ioutil.ReadAll(response.Body)
	fmt.Println(string(responseText))
}

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,
            };

            // 我们建议接受我们的证书，而不是允许不安全的 (http) 流量
            httpClientHandler.ClientCertificateOptions = ClientCertificateOption.Manual;
            httpClientHandler.ServerCertificateCustomValidationCallback =
                (httpRequestMessage, cert, cetChain, policyErrors) =>
                {
                    return true;
                };
                
            var client = new HttpClient(handler: httpClientHandler, disposeHandler: true);
            var payload = new Dictionary<string, string>()
            {
                { "您的 POST JSON", "data" }
            };
            
            Uri baseUri = new Uri("https://ip.oxylabs.io/location");
            client.BaseAddress = baseUri;

            var requestMessage = new HttpRequestMessage(HttpMethod.Post, "");
            requestMessage.Content = JsonContent.Create(payload);

            var response = await client.SendAsync(requestMessage);
            var contents = await response.Content.ReadAsStringAsync();

            Console.WriteLine(contents);
        }
    }
}

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.HttpPost;
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.io.entity.StringEntity;
import org.apache.hc.core5.http.message.StatusLine;
import org.apache.hc.core5.ssl.SSLContextBuilder;

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 HttpPost request = new HttpPost("/location");
            final String json = "{'data':'您的 POST JSON'}";
            final StringEntity entity = new StringEntity(json);
            request.setEntity(entity);
            request.setHeader("Content-type", "application/json; charset=utf-8");
            request.setConfig(config);

            System.out.println("Executing request " + request.getMethod() + " " + request.getUri() +
                    " via " + proxy);

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

上一页自定义状态码下一页无头浏览器 (Headless Browser)

最后更新于1年前

这有帮助吗？

早上好

代码示例