# 高带宽代理

## 入门

要开始使用我们的 [**高带宽代理** ](https://oxylabs.io/products/high-bandwidth-proxies)用于 视频数据和音频抓取，请联系我们的销售团队以获取您的专属端点。每位客户都会获得一个为其特定需求配置的唯一代理端点。要将此解决方案直接集成到 `yt_dlp` 库中，请查看 [示例部分](#example-integration-youtube-downloader).

## 端点配置

在从客户管理团队收到您的端点后，您将获得：

* 一个专用代理端点
* 您的用户名和密码
* 端口号（默认：60000）

## 发起请求

如需快速检查连接，请在 `-test` 参数后添加到用户名中。

{% tabs %}
{% tab title="命令行" %}

```bash
curl -x username-test:password@your-endpoint:60000 \
     https://ip.oxylabs.io/location
```

{% endtab %}

{% tab title="Python" %}

```python
import requests
导入 random

username = 'YOUR_USERNAME'
password = 'YOUR_PASSWORD'
proxy = 'your-endpoint:60000'

if not username.endswith("-test"):
    username += "-test"

代理 = {
    "http": f"http://{username}:{password}@{proxy}",
    "https": f"http://{username}:{password}@{proxy}"
}

response = requests.get(
    "https://ip.Oxylabs.io/location", 
    代理=代理
)
print(response.text)
```

{% endtab %}

{% tab title="Node.js" %}

```javascript
const axios = require('axios');
const https = require('https');

const username = 'YOUR_USERNAME';
const password = 'YOUR_PASSWORD';
const proxyHost = 'your-endpoint';
const proxyPort = 60000;

const client = axios.create({
    httpsAgent: new https.Agent({
        rejectUnauthorized: false
    })
});

const modifiedUsername = username.endsWith("-test") ? username : username + "-test";

client.get('https://ip.oxylabs.io/location', {
    proxy: {
        host: proxyHost,
        port: proxyPort,
        auth: {
            username: modifiedUsername,
            password: password
        }
    }
})
.then(response => console.log(response.data))
.catch(error => console.error(error));
```

{% endtab %}

{% tab title="PHP" %}

```php
<?php
$username = 'YOUR_USERNAME';
$password = 'YOUR_PASSWORD';
$proxyHost = 'your-endpoint';
$proxyPort = 60000;

$modifiedUsername = substr($username, -5) === "-test" ? $username : $username . "-test";

$proxy = "$proxyHost:$proxyPort";


$ch = curl_init('https://ip.oxylabs.io/location');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_PROXY, $proxy);
curl_setopt($ch, CURLOPT_PROXYUSERPWD, "$modifiedUsername:$password");

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
```

{% endtab %}

{% tab title="Go" %}

```go
package main

import (
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strings"
)

func main() {
    username, password := "YOUR_USERNAME", "YOUR_PASSWORD"
    proxyHost := "your-endpoint"
    proxyPort := "60000"

    if !strings.HasSuffix(username, "-test") {
        username += "-test"
    }

    proxyURL := fmt.Sprintf("http://%s:%s@%s:%s", username, password, proxyHost, proxyPort)

    proxy, _ := url.Parse(proxyURL)
    transport := &http.Transport{Proxy: http.ProxyURL(proxy)}
    client := &http.Client{Transport: transport}

    req, _ := http.NewRequest("GET", "https://ip.oxylabs.io/location", nil)

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}
```

{% endtab %}

{% tab title="Java" %}

```java
import java.net.Authenticator;
import java.net.InetSocketAddress;
import java.net.PasswordAuthentication;
import java.net.Proxy;
import java.net.ProxySelector;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {

    public static void main(String[] args) throws Exception {

        String username = "YOUR_USERNAME";
        String password = "YOUR_PASSWORD";

        if (!username.endsWith("-test")) {
            username += "-test";
        }


        Authenticator.setDefault(new Authenticator() {
            @Override
            protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication(username, password.toCharArray());
            }
        });

        HttpClient client = HttpClient.newBuilder()
                .proxy(ProxySelector.of(new InetSocketAddress("your-endpoint", 60000)))
                .build();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://ip.oxylabs.io/location"))
                .build();

        HttpResponse<String> response = client.send(request,
                HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}
```

{% endtab %}

{% tab title="C#" %}

```csharp
using System.Net;

var proxy = new WebProxy
{
    地址 = new Uri("http://your-endpoint:60000"),
    凭据 = new NetworkCredential("YOUR_USERNAME-test", "YOUR_PASSWORD")
};

var handler = new HttpClientHandler { Proxy = proxy };
var client = new HttpClient(handler);

var response = await client.GetStringAsync("https://ip.oxylabs.io/location");
Console.WriteLine(response);

```

{% endtab %}
{% endtabs %}

### 为每个下载设置会话

为确保最佳成功率，高带宽代理在每个会话期间都配备自动负载均衡。 `-$((1 + RANDOM % 100000))`  用户名旁边的参数会生成一个随机数作为会话 ID，并为每次下载分配不同的 IP 地址。&#x20;

{% tabs %}
{% tab title="命令行" %}

```bash
curl -x username-$((1 + RANDOM % 100000)):password@your-endpoint:60000 \
     https://ip.oxylabs.io/location
```

{% endtab %}

{% tab title="Python" %}

```python
import requests
导入 random

username = 'YOUR_USERNAME'
password = 'YOUR_PASSWORD'
proxy = 'your-endpoint:60000'

random_number = random.randint(1, 100000)  # 生成随机数
modified_username = f"{username}-{random_number}"

代理 = {
    "http": f"http://{modified_username}:{password}@{代理}",
    "https": f"http://{modified_username}:{password}@{代理}"
}

response = requests.get(
    "https://ip.Oxylabs.io/location",
    代理=代理,
)
print(response.text)
```

{% endtab %}

{% tab title="Node.js" %}

```javascript
const axios = require('axios');
const https = require('https');

const username = 'YOUR_USERNAME';
const password = 'YOUR_PASSWORD';

const randomNumber = Math.floor(Math.random() * 100000) + 1;
const modifiedUsername = `${username}-${randomNumber}`;

const client = axios.create({
    httpsAgent: new https.Agent({
        rejectUnauthorized: false
    })
});

client.get('https://ip.oxylabs.io/location', {
    proxy: {
        host: 'your-endpoint',
        port: 60000,
        auth: {
            username: username,
            password: password
        }
    },
})
.then(response => console.log(response.data))
.catch(error => console.error(error));
```

{% endtab %}

{% tab title="PHP" %}

```php
<?php
$username = 'YOUR_USERNAME';
$password = 'YOUR_PASSWORD';
$proxy = 'your-endpoint:60000';
$sessionId = rand(1, 100000);

$modifiedUsername = $username . "-" . $sessionId;

$ch = curl_init('https://ip.oxylabs.io/location');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_PROXY, $proxy);
curl_setopt($ch, CURLOPT_PROXYUSERPWD, "$modifiedUsername:$password");

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>
```

{% endtab %}

{% tab title="Go" %}

```go
package main

import (
        "fmt"
        "io"
        "math/rand"
        "net/http"
        "net/url"
)

func main() {
        username, password:= "YOUR_USERNAME", "YOUR_PASSWORD"
        proxyHost:= "your-endpoint"
        proxyPort:= "60000"

        modifiedUsername:= fmt.Sprintf("%s-%d", username, rand.Intn(100000)+1)

        proxyURL:= fmt.Sprintf("http://%s:%s@%s:%s", modifiedUsername, password, proxyHost, proxyPort)

        proxy, _:= url.Parse(proxyURL)
        transport:= &http.Transport{Proxy: http.ProxyURL(proxy)}
        client:= &http.Client{Transport: transport}

        req, _:= http.NewRequest("GET", "https://ip.oxylabs.io/location", nil)

        resp, err:= client.Do(req)
        如果 err!= nil {
                panic(err)
        }
        defer resp.Body.Close()

        body, _:= io.ReadAll(resp.Body)
        fmt.Println(string(body))
}
```

{% endtab %}

{% tab title="Java" %}

```java
import java.net.Authenticator;
import java.net.InetSocketAddress;
import java.net.PasswordAuthentication;
import java.net.ProxySelector;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.Random;

public class Main {

    public static void main(String[] args) throws Exception {

        String username = "YOUR_USERNAME";
        String password = "YOUR_PASSWORD";

        Random rand = new Random();
        int randomNumber = rand.nextInt(100000) + 1;
        String modifiedUsername = username + "-" + randomNumber;


        Authenticator.setDefault(new Authenticator() {
            @Override
            protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication(modifiedUsername, password.toCharArray());
            }
        });

        HttpClient client = HttpClient.newBuilder()
                .proxy(ProxySelector.of(new InetSocketAddress("your-endpoint", 60000)))
                .build();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://ip.oxylabs.io/location"))
                .build();

        HttpResponse<String> response = client.send(request,
                HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}
```

{% endtab %}

{% tab title="C#" %}

```csharp
using System.Net;

var random = new Random();
int sessionId = random.Next(1, 100001); // 生成 1 到 100000 之间的随机数

var proxy = new WebProxy
{
    地址 = new Uri("http://your-endpoint:60000"),
    Credentials = new NetworkCredential($"YOUR_USERNAME-{sessionId}", "YOUR_PASSWORD") // 将 sessionId 附加到用户名
};

var handler = new HttpClientHandler { Proxy = proxy };
var client = new HttpClient(handler);

var response = await client.GetStringAsync("https://ip.oxylabs.io/location");
Console.WriteLine(response);
```

{% endtab %}
{% endtabs %}

{% hint style="info" %}
调整后的端点将根据您的配置自动处理 IP 分配。使用它可确保每次下载都使用新的 IP 地址。
{% endhint %}

## 示例集成：YouTube 下载器

这里有一个使用 `yt-dlp` 我们的高带宽代理进行视频或音频数据抓取的示例：

### 基本用法

添加一个 `-test` 参数到用户名中可让用户测试连接设置。

{% tabs %}
{% tab title="命令行" %}

```bash
yt-dlp --proxy username-test:password@endpoint:60000 \
"https://www.youtube.com/watch?v=WNCl-69POro"
```

{% endtab %}

{% tab title="Python" %}

```python
import yt_dlp

username = 'YOUR_USERNAME'
password = 'YOUR_PASSWORD'

if not username.endswith("-test"):
    username += "-test"
    
proxy = f'http://{username}:{password}@your-endpoint:60000'

ydl_opts = {
    'proxy': proxy,
}

with yt_dlp.YoutubeDL(ydl_opts) as ydl:
    ydl.download(['https://www.youtube.com/watch?v=WNCl-69POro'])
```

{% endtab %}
{% endtabs %}

{% hint style="info" %}
为了获得最佳性能，请确保每个视频都使用单独的 IP 地址下载。请参考下方部分了解指导。
{% endhint %}

### 使用不同 IP 的多个 URL

在使用高带宽代理时，每个视频都会使用单独的 IP 地址下载，以确保最佳性能。这是通过为每个请求生成唯一的会话 ID 来实现的，这实际上为每次下载分配了一个新的 IP 地址。

{% tabs %}
{% tab title="命令行" %}

```bash
# 第一个视频使用一个 IP
yt-dlp --proxy username-$((1 + RANDOM % 100000)):password@endpoint:60000 \
"https://www.youtube.com/watch?v=6stlCkUDG_s"

# 第二个视频使用不同的 IP
yt-dlp --proxy username-$((1 + RANDOM % 100000)):password@endpoint:60000 \
"https://www.youtube.com/watch?v=gsnqXt7d1mU"
```

{% endtab %}

{% tab title="Python" %}

```python
导入 random
import yt_dlp

def download_with_new_ip(url, username, password):
    session_id = random.randint(1, 100000)
    proxy = f'http://{username}-{session_id}:{password}@your-endpoint:60000'

    ydl_opts = {
        'proxy': proxy
    }
    
    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
        try:
            print(f"使用新的 IP（{username}-{session_id}）下载 {url}...")
            ydl.download([url])
            print(f"已成功下载 {url}")
        except Exception as e:
            print(f"下载 {url} 时出错：{str(e)}")

def main():
    username = 'YOUR_USERNAME'
    password = 'YOUR_PASSWORD'
    
    videos = [
        'https://www.youtube.com/watch?v=6stlCkUDG_s',
        'https://www.youtube.com/watch?v=gsnqXt7d1mU'
    ]
    
    for video in videos:
        download_with_new_ip(video, username, password)

if __name__ == "__main__":
    main()

```

{% endtab %}
{% endtabs %}

{% hint style="info" %}
该函数包含基本错误处理，以确保即使某个下载失败，流程也会继续。
{% endhint %}


---

# 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/dai-li/high-bandwidth-proxies.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.