Get Residential Pools

Returns a list of all available residential proxy pools with their corresponding subdomains and ports.

GET/resi/pools

Authentication

Basic username/password authentication

Code Example

NodeJS

const axios = require('axios');

const url = "https://api.unknownproxies.com/api/v1/resi/pools";
const headers = {
  "Authorization": "Basic dXNlcjpwYXNz",
  "Content-Type": "application/json"
};

try {
  const response = await axios.get(url, {
    headers
  });
  console.log(response.data);
} catch (error) {
  console.error('Error:', error.response?.data || error.message);
}

Python

import requests
import json

url = "https://api.unknownproxies.com/api/v1/resi/pools"
headers = {
    "Authorization": "Basic dXNlcjpwYXNz",
    "Content-Type": "application/json"
}

response = requests.get(
    url,
    headers=headers
)

print(response.json())

PHP

<?php
$url = "https://api.unknownproxies.com/api/v1/resi/pools";
$headers = [
    "Authorization: Basic dXNlcjpwYXNz",
    "Content-Type: application/json"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");

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

echo $response;

Java

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class ApiClient {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        
        String url = "https://api.unknownproxies.com/api/v1/resi/pools";
        String auth = "Basic dXNlcjpwYXNz";
        
        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", auth)
            .header("Content-Type", "application/json");
        
        HttpRequest request = requestBuilder
            .get(HttpRequest.BodyPublishers.noBody())
            .build();
        
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

C#

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Net.Http.Headers;

public class Program
{
    public static async Task Main()
    {
        using var client = new HttpClient();
        
        var url = "https://api.unknownproxies.com/api/v1/resi/pools";
        
        // Set basic auth
        var authToken = Convert.ToBase64String(Encoding.UTF8.GetBytes("user:pass"));
        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", authToken);
        
        
        
        var response = await client.getAsync(url);
        var result = await response.Content.ReadAsStringAsync();
        
        Console.WriteLine(result);
    }
}

cURL

curl -X GET "https://api.unknownproxies.com/api/v1/resi/pools" \
  -H "Authorization: Basic dXNlcjpwYXNz" \
  -H "Content-Type: application/json"

Javascript

const response = await fetch("https://api.unknownproxies.com/api/v1/resi/pools", {
  method: "GET",
  headers: {
    "Authorization": "Basic dXNlcjpwYXNz",
    "Content-Type": "application/json"
  }
});

const data = await response.json();
console.log(data);

Go

package main

import (
    "bytes"
    "encoding/base64"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    url := "https://api.unknownproxies.com/api/v1/resi/pools"
    reqBody := ""

    var body io.Reader
    if reqBody != "" {
        var buf bytes.Buffer
        if err := json.Compact(&buf, []byte(reqBody)); err == nil {
            body = bytes.NewBuffer(buf.Bytes())
        } else {
            body = bytes.NewBuffer([]byte(reqBody))
        }
    }

    req, _ := http.NewRequest("GET", url, body)
    token := base64.StdEncoding.EncodeToString([]byte("user:pass"))
    req.Header.Set("Authorization", "Basic "+token)
    req.Header.Set("Content-Type", "application/json")

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

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

Response Example

[
  {
    "subdomain": "us-s",
    "port": 8890
  },
  {
    "subdomain": "us-r",
    "port": 8891
  },
  {
    "subdomain": "gb-s",
    "port": 8892
  }
]

Pool Information

Each pool object in the response contains:

• subdomain - The subdomain identifier for the pool (e.g., "us-s", "us-r", "gb-s", "gb-r"). This is the value you'll use when specifying pools in token operations.
• port - Port number to use when connecting to proxies in this pool

Using Pools with Tokens

When creating or modifying a residential token, you can restrict access to specific pools using the allowedPools parameter:

• If allowedPools is empty ([]), the token can access all available pools
• If allowedPools contains specific pool subdomains (as returned by this endpoint), the token can only use those pools

Related Operations

• Create Residential Token - Create a token with access to all pools by default
• Modify Residential Token - Update the allowedPools to restrict or expand pool access
• Residential Token Schema - See how allowedPools affects token behavior