Need more data?

No worries—we’ve got bigger plans ready for you.

Contact Us

Unlimited Scale

Premium SLA

Free Proxy Manager

Custom price per GB

Unlimited seats

99.97% Network Uptime

Complete data coverage

Custom solutions

We accept these payment methods:

Need more data?
Testimonials

What Our Clients Say

Intuitive Proxy Dashboard

All your data, one powerful platform.

Everyday use cases powered by our proxies.

import requests

url = "https://api.floxy.io/purchase/residential/bandwidth"
payload = {
    "bandwidth": 1
}
headers = {
    "Content-Type": "application/json",
    "X-API-Key": "{api_key}"
}

response = requests.post(url, json=payload, headers=headers)
print(response.text)
Copy
const url = "https://api.floxy.io/purchase/residential/bandwidth";
const payload = {
    bandwidth: 1
};
const headers = {
    "Content-Type": "application/json",
    "X-API-Key": "{api_key}"
};
fetch(url, {
    method: 'POST',
    headers: headers,
    body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data));
Copy
require 'net/http'
require 'json'

uri = URI('https://api.floxy.io/purchase/residential/bandwidth')
payload = {
    bandwidth: 1
}

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request['X-API-Key'] = '{api_key}'
request.body = payload.to_json

response = http.request(request)
puts response.body
Copy
use reqwest;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let payload = json!({
        "bandwidth": 1
    });
    let response = client
        .post("https://api.floxy.io/purchase/residential/bandwidth")
        .header("Content-Type", "application/json")
        .header("X-API-Key", "{api_key}")
        .json(&payload)
        .send()
        .await?;
    println!("{}", response.text().await?);
    Ok(())
}
Copy
<?php
$url = "https://api.floxy.io/purchase/residential/bandwidth";
$payload = json_encode([
    "bandwidth" => 1
]);
$headers = [
    "Content-Type: application/json",
    "X-API-Key: {api_key}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>
Copy
#include <curl/curl.h>
#include <iostream>
#include <string>

int main() {
    CURL *curl = curl_easy_init();
    if(curl) {
        std::string payload = R"({"bandwidth": 1})";
        struct curl_slist *headers = nullptr;
        headers = curl_slist_append(headers, "Content-Type: application/json");
        headers = curl_slist_append(headers, "X-API-Key: {api_key}");
        curl_easy_setopt(curl, CURLOPT_URL, "https://api.floxy.io/purchase/residential/bandwidth");
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload.c_str());
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_perform(curl);
        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }
    return 0;
}
Copy
import requests

url = "https://api.floxy.io/purchase/mobile"
payload = {
    "bandwidth": 1
}
headers = {
    "Content-Type": "application/json",
    "X-API-Key": "{api_key}"
}

response = requests.post(url, json=payload, headers=headers)
print(response.text)
Copy
const url = "https://api.floxy.io/purchase/mobile";
const payload = {
    bandwidth: 1
};
const headers = {
    "Content-Type": "application/json",
    "X-API-Key": "{api_key}"
};

fetch(url, {
    method: 'POST',
    headers: headers,
    body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data));
Copy
require 'net/http'
require 'json'

uri = URI('https://api.floxy.io/purchase/mobile')
payload = {
    bandwidth: 1
}

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request['X-API-Key'] = '{api_key}'
request.body = payload.to_json

response = http.request(request)
puts response.body
Copy
use reqwest;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let payload = json!({
        "bandwidth": 1
    });

    let response = client
        .post("https://api.floxy.io/purchase/mobile")
        .header("Content-Type", "application/json")
        .header("X-API-Key", "{api_key}")
        .json(&payload)
        .send()
        .await?;

    println!("{}", response.text().await?);
    Ok(())
}
Copy
<?php
$url = "https://api.floxy.io/purchase/mobile";
$payload = json_encode([
    "bandwidth" => 1
]);
$headers = [
    "Content-Type: application/json",
    "X-API-Key: {api_key}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>
Copy
#include <curl/curl.h>
#include <iostream>
#include <string>

int main() {
    CURL *curl = curl_easy_init();
    if(curl) {
        std::string payload = R"({"bandwidth": 1})";
        
        struct curl_slist *headers = nullptr;
        headers = curl_slist_append(headers, "Content-Type: application/json");
        headers = curl_slist_append(headers, "X-API-Key: {api_key}");
        
        curl_easy_setopt(curl, CURLOPT_URL, "https://api.floxy.io/purchase/mobile");
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload.c_str());
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        
        curl_easy_perform(curl);
        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }
    return 0;
}
Copy
import requests
url = "https://api.pingproxies.com/1.0/public/user/proxy_user/create"
payload = {
    "proxy_user_id": "SteveJobs",
    "proxy_user_residential_bytes_limit": 1073741824 #1GB Residential Bandwidth Limit and some other stuff
}
headers = {
    "Content-Type": "application/json",
    "X-API-Private-Key": "{private_api_key}",
    "X-API-Public-Key": "{public_api_key}"
}
response = requests.post(url, json=payload, headers=headers)
print(response.text)
Copy
import requests

url = "https://api.floxy.io/purchase/datacenter/dedicated"
payload = {
    "bandwidth": 250,
    "num_ips": 100
}
headers = {
    "Content-Type": "application/json",
    "X-API-Key": "{api_key}"
}

response = requests.post(url, json=payload, headers=headers)
print(response.text)
Copy
const url = "https://api.floxy.io/purchase/datacenter/dedicated";
const payload = {
    bandwidth: 250,
    num_ips: 100
};
const headers = {
    "Content-Type": "application/json",
    "X-API-Key": "{api_key}"
};
fetch(url, {
    method: 'POST',
    headers: headers,
    body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data));
Copy
require 'net/http'
require 'json'

uri = URI('https://api.floxy.io/purchase/datacenter/dedicated')
payload = {
    bandwidth: 250,
    num_ips: 100
}

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request['X-API-Key'] = '{api_key}'
request.body = payload.to_json

response = http.request(request)
puts response.body
Copy
use reqwest;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let payload = json!({
        "bandwidth": 250,
        "num_ips": 100
    });
    let response = client
        .post("https://api.floxy.io/purchase/datacenter/dedicated")
        .header("Content-Type", "application/json")
        .header("X-API-Key", "{api_key}")
        .json(&payload)
        .send()
        .await?;
    println!("{}", response.text().await?);
    Ok(())
}
Copy
<?php
$url = "https://api.floxy.io/purchase/datacenter/dedicated";
$payload = json_encode([
    "bandwidth" => 250,
    "num_ips" => 100
]);
$headers = [
    "Content-Type: application/json",
    "X-API-Key: {api_key}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>
Copy
#include <curl/curl.h>
#include <iostream>
#include <string>

int main() {
    CURL *curl = curl_easy_init();
    if(curl) {
        std::string payload = R"({"bandwidth": 250, "num_ips": 100})";
        struct curl_slist *headers = nullptr;
        headers = curl_slist_append(headers, "Content-Type: application/json");
        headers = curl_slist_append(headers, "X-API-Key: {api_key}");
        curl_easy_setopt(curl, CURLOPT_URL, "https://api.floxy.io/purchase/datacenter/dedicated");
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload.c_str());
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_perform(curl);
        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }
    return 0;
}
Copy
import requests
url = "https://api.pingproxies.com/1.0/public/user/proxy_user/create"
payload = {
    "proxy_user_id": "SteveJobs",
    "proxy_user_residential_bytes_limit": 1073741824 #1GB Residential Bandwidth Limit and some other stuff
}
headers = {
    "Content-Type": "application/json",
    "X-API-Private-Key": "{private_api_key}",
    "X-API-Public-Key": "{public_api_key}"
}
response = requests.post(url, json=payload, headers=headers)
print(response.text)
import requests

url = "https://api.floxy.io/purchase/isp"
payload = {
    "ip": 1
}
headers = {
    "Content-Type": "application/json",
    "X-API-Key": "{api_key}"
}

response = requests.post(url, json=payload, headers=headers)
print(response.text)
Copy
const url = "https://api.floxy.io/purchase/isp";
const payload = {
    ip: 1
};
const headers = {
    "Content-Type": "application/json",
    "X-API-Key": "{api_key}"
};
fetch(url, {
    method: 'POST',
    headers: headers,
    body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data));
Copy
require 'net/http'
require 'json'

uri = URI('https://api.floxy.io/purchase/isp')
payload = {
    ip: 1
}

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request['X-API-Key'] = '{api_key}'
request.body = payload.to_json

response = http.request(request)
puts response.body
Copy
use reqwest;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let payload = json!({
        "ip": 1
    });
    let response = client
        .post("https://api.floxy.io/purchase/isp")
        .header("Content-Type", "application/json")
        .header("X-API-Key", "{api_key}")
        .json(&payload)
        .send()
        .await?;
    println!("{}", response.text().await?);
    Ok(())
}
Copy
<?php
$url = "https://api.floxy.io/purchase/isp";
$payload = json_encode([
    "ip" => 1
]);
$headers = [
    "Content-Type: application/json",
    "X-API-Key: {api_key}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>
Copy
#include <curl/curl.h>
#include <iostream>
#include <string>

int main() {
    CURL *curl = curl_easy_init();
    if(curl) {
        std::string payload = R"({"ip": 1})";
        struct curl_slist *headers = nullptr;
        headers = curl_slist_append(headers, "Content-Type: application/json");
        headers = curl_slist_append(headers, "X-API-Key: {api_key}");
        curl_easy_setopt(curl, CURLOPT_URL, "https://api.floxy.io/purchase/isp");
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload.c_str());
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_perform(curl);
        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }
    return 0;
}
Copy
import requests
url = "https://api.pingproxies.com/1.0/public/user/proxy_user/create"
payload = {
    "proxy_user_id": "SteveJobs",
    "proxy_user_residential_bytes_limit": 1073741824 #1GB Residential Bandwidth Limit and some other stuff
}
headers = {
    "Content-Type": "application/json",
    "X-API-Private-Key": "{private_api_key}",
    "X-API-Public-Key": "{public_api_key}"
}
response = requests.post(url, json=payload, headers=headers)
print(response.text)
API Integrations

Easy Integration For Rotating Proxies with Developer Friendly API

Works with many common languages such as PHP, Phthon, Net, Java, Javascript, C/C++, and C#

Works with many common languages such as PHP, Python, Net, Java, Javascript, C/C++, and C#.

Manage proxy users and orders easily with our API.

View Documentation

Effortless Data Extraction
at Any Scale

Extract the data you need—quickly and reliably.

Get Started

Proxies for United States

Learn more

Proxies for United Kingdom

Learn more

Proxies for Canada

Learn more

Proxies for Australia

Learn more

Proxies for France

Learn more

Proxies for Germany

Learn more

Proxies for Netherlands

Learn more

Proxies for Sweden

Learn more

Proxies for Denmark

Learn more

Proxies for Latvia

Learn more

Proxies for Portugal

Learn more

Proxies for Austria

Learn more

Proxies for Brazil

Learn more

Proxies for Vietnam

Learn more

Proxies for Romania

Learn more

Proxies for Norway

Learn more

Proxies for Russia

Learn more

Proxies for Poland

Learn more

Proxies for Hong Kong

Learn more

Proxies for Switzerland

Learn more

Proxies for Pakistan

Learn more

Proxies for Taiwan

Learn more

Proxies for Italy

Learn more

Proxies for Spain

Learn more

Proxies for Singapore

Learn more

Proxies for India

Learn more

Proxies for Ukraine

Learn more