API Prokso dla programistów: proxy z poziomu kodu

Szybki start

Utwórz klucz w panelu: „Ustawienia” → „API”. Pełny klucz pokazujemy tylko raz – od razu zapisz go w menedżerze haseł lub w zmiennej środowiskowej. Na jedno konto przypada do 5 kluczy; niepotrzebny klucz unieważnisz w tym samym miejscu.

Wszystkie adresy zaczynają się od https://prokso.com/api/v1, odpowiedzi są w JSON, kwoty – w centach dolara (USD), transfer – w bajtach i GB, czas – UTC w formacie ISO 8601.

curl https://prokso.com/api/v1/me \
  -H "Authorization: Bearer $PROKSO_KEY"

API zarządza planami. Jak łączyć się z samymi proxy – porty, formaty linii i parametry kraju lub operatora w loginie – opisuje strona o bramie; jeśli proxy nie odpowiada – sprawdzenie krok po kroku.

Autoryzacja

Przekazuj klucz w nagłówku Authorization: Bearer <klucz> lub X-API-Key. Sesja panelu w przeglądarce nie działa w API. Żądania z zablokowanego lub usuniętego konta i z unieważnionym kluczem dostają odpowiedź 401.

Ograniczenia

Do 60 żądań na minutę na jeden klucz. Powyżej – odpowiedź 429 i nagłówek Retry-After z liczbą sekund do następnej próby.
Do 20 nieudanych prób autoryzacji w ciągu 10 minut z jednego adresu IP (dla IPv6 – z sieci /64), potem – 429.
Najwyżej 1000 linii proxy w jednym żądaniu i do 5 adresów IP na białej liście planu.

Błędy

Błąd zawsze przychodzi w tym samym formacie z odpowiednim kodem HTTP:

{"error": {"code": "insufficient_balance", "message": "Not enough money on the balance. Top it up in the dashboard."}}

HTTP	code	Co oznacza
400	`validation_error, invalid_json, below_minimum_order`	Błędne parametry albo zamówienie nie spełnia warunków z GET /api/v1/prices.
401	`unauthorized`	Brak klucza, klucz błędny lub unieważniony.
402	`insufficient_balance`	Za mało środków na saldzie. Nic nie pobrano.
404	`not_found`	Planu lub zamówienia nie ma albo należą do innego konta.
409 / 422	`idempotency_in_progress, idempotency_key_reused`	Żądanie z tym Idempotency-Key jeszcze trwa albo klucz użyto już z innymi danymi.
429	`rate_limited`	Przekroczono limit żądań – odczekaj tyle sekund, ile podaje Retry-After.
503	`service_unavailable`	Sieć proxy chwilowo nie odpowiada – ponów za minutę.

Zakupy bez duplikatów

Zakup przez API pobiera pieniądze tylko z salda (doładowujesz je w panelu). Żeby ponowienie żądania po zerwaniu połączenia nie kupiło gigabajtów dwa razy, dodaj nagłówek Idempotency-Key – dowolny unikalny ciąg do 100 znaków. Przez 24 godziny powtórne żądanie z tym samym kluczem zwróci pierwsze zamówienie (nagłówek Idempotent-Replayed: true), zamiast tworzyć nowe. Jeśli żądanie zostało odrzucone (na przykład z braku środków), klucz można użyć ponownie.

Przykłady kodu

Jeden scenariusz w czterech językach: pobrać plany z pozostałym transferem, wziąć linię proxy z nowym IP przy każdym żądaniu i sprawdzić, jaki adres widzi strona: https://prokso.com/ip zwraca IP, kraj, miasto i dostawcę. Klucz kod pobiera ze zmiennej środowiskowej PROKSO_KEY. Przy odpowiedziach 429 i 503 czeka tyle sekund, ile podaje nagłówek Retry-After, i ponawia żądanie, maksymalnie pięć razy.

Python 3 (requests)

import os
import time

import requests

API = "https://prokso.com/api/v1"
AUTH = {"Authorization": f"Bearer {os.environ['PROKSO_KEY']}"}


def call(method, path, headers=None, **kw):
    for attempt in range(5):
        r = requests.request(method, API + path, headers={**AUTH, **(headers or {})}, timeout=30, **kw)
        if r.status_code not in (429, 503):
            break
        time.sleep(int(r.headers.get("Retry-After", "5")))
    if r.status_code >= 400:
        raise RuntimeError(r.json()["error"])
    return r.json()


plans = call("GET", "/plans")["plans"]
for p in plans:
    print(p["id"], p["label"], p["status"], (p["traffic"] or {}).get("left_gb"), "GB")

plan = plans[0]
line = call("GET", f"/plans/{plan['id']}/proxies",
            params={"country": "pl", "count": 1, "session": "rotating", "format": "url"})["lines"][0]
ip = requests.get("https://prokso.com/ip", proxies={"http": line, "https": line}, timeout=30).json()
print(ip["ip"], ip["country"], ip["city"])

Node.js 18+ (undici)

Zapisz jako plik .mjs i zainstaluj pakiet: npm i undici. Wbudowany fetch w Node.js nie obsługuje proxy, dlatego żądanie do /ip idzie przez ProxyAgent.

import { fetch, ProxyAgent } from "undici";

const API = "https://prokso.com/api/v1";
const AUTH = { Authorization: `Bearer ${process.env.PROKSO_KEY}` };

async function call(path, init = {}) {
  for (let attempt = 0; attempt < 5; attempt++) {
    const r = await fetch(API + path, { ...init, headers: { ...AUTH, ...init.headers } });
    if (r.status === 429 || r.status === 503) {
      const wait = Number(r.headers.get("retry-after") || 5);
      await new Promise((ok) => setTimeout(ok, wait * 1000));
      continue;
    }
    const body = await r.json();
    if (!r.ok) throw new Error(`${body.error.code}: ${body.error.message}`);
    return body;
  }
  throw new Error("rate_limited");
}

const { plans } = await call("/plans");
for (const p of plans) console.log(p.id, p.label, p.status, p.traffic?.left_gb, "GB");

const q = new URLSearchParams({ country: "pl", count: "1", session: "rotating", format: "url" });
const [line] = (await call(`/plans/${plans[0].id}/proxies?${q}`)).lines;
const u = new URL(line);
const login = `${decodeURIComponent(u.username)}:${decodeURIComponent(u.password)}`;
const agent = new ProxyAgent({ uri: `${u.protocol}//${u.host}`, token: "Basic " + Buffer.from(login).toString("base64") });
const ip = await (await fetch("https://prokso.com/ip", { dispatcher: agent })).json();
console.log(ip.ip, ip.country, ip.city);

PHP 8 (cURL)

<?php
const API = "https://prokso.com/api/v1";

function call(string $path): array
{
    for ($attempt = 0; $attempt < 5; $attempt++) {
        $wait = 5;
        $ch = curl_init(API . $path);
        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_TIMEOUT => 30,
            CURLOPT_HTTPHEADER => ["Authorization: Bearer " . getenv("PROKSO_KEY")],
            CURLOPT_HEADERFUNCTION => function ($ch, $h) use (&$wait) {
                if (stripos($h, "Retry-After:") === 0) {
                    $wait = (int) trim(substr($h, 12));
                }
                return strlen($h);
            },
        ]);
        $body = json_decode(curl_exec($ch), true);
        $code = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
        if ($code == 429 || $code == 503) {
            sleep(max($wait, 1));
            continue;
        }
        if ($code >= 400) {
            throw new RuntimeException($body["error"]["code"] . ": " . $body["error"]["message"]);
        }
        return $body;
    }
    throw new RuntimeException("rate_limited");
}

$plans = call("/plans")["plans"];
foreach ($plans as $p) {
    printf("%d %s %s %s GB\n", $p["id"], $p["label"], $p["status"], $p["traffic"]["left_gb"] ?? "-");
}

$q = http_build_query(["country" => "pl", "count" => 1, "session" => "rotating", "format" => "url"]);
$line = call("/plans/" . $plans[0]["id"] . "/proxies?" . $q)["lines"][0];

$ch = curl_init("https://prokso.com/ip");
curl_setopt_array($ch, [CURLOPT_PROXY => $line, CURLOPT_RETURNTRANSFER => true, CURLOPT_TIMEOUT => 30]);
$ip = json_decode(curl_exec($ch), true);
echo $ip["ip"], " ", $ip["country"], " ", $ip["city"], "\n";

Go 1.21+

Tylko biblioteka standardowa: login i hasło z linii url Go sam przekazuje do proxy.

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"os"
	"strconv"
	"time"
)

const api = "https://prokso.com/api/v1"

func call(path string, out any) error {
	for attempt := 0; attempt < 5; attempt++ {
		req, _ := http.NewRequest("GET", api+path, nil)
		req.Header.Set("Authorization", "Bearer "+os.Getenv("PROKSO_KEY"))
		resp, err := http.DefaultClient.Do(req)
		if err != nil {
			return err
		}
		if resp.StatusCode == 429 || resp.StatusCode == 503 {
			wait, _ := strconv.Atoi(resp.Header.Get("Retry-After"))
			resp.Body.Close()
			time.Sleep(time.Duration(max(wait, 1)) * time.Second)
			continue
		}
		defer resp.Body.Close()
		if resp.StatusCode >= 400 {
			var e struct{ Error struct{ Code, Message string } }
			json.NewDecoder(resp.Body).Decode(&e)
			return fmt.Errorf("%s: %s", e.Error.Code, e.Error.Message)
		}
		return json.NewDecoder(resp.Body).Decode(out)
	}
	return fmt.Errorf("rate_limited")
}

func main() {
	var list struct {
		Plans []struct {
			ID      int    `json:"id"`
			Label   string `json:"label"`
			Status  string `json:"status"`
			Traffic *struct {
				LeftGB float64 `json:"left_gb"`
			} `json:"traffic"`
		} `json:"plans"`
	}
	if err := call("/plans", &list); err != nil {
		panic(err)
	}
	for _, p := range list.Plans {
		left := 0.0
		if p.Traffic != nil {
			left = p.Traffic.LeftGB
		}
		fmt.Println(p.ID, p.Label, p.Status, left, "GB")
	}

	q := url.Values{"country": {"pl"}, "count": {"1"}, "session": {"rotating"}, "format": {"url"}}
	var px struct {
		Lines []string `json:"lines"`
	}
	if err := call(fmt.Sprintf("/plans/%d/proxies?%s", list.Plans[0].ID, q.Encode()), &px); err != nil {
		panic(err)
	}
	proxy, _ := url.Parse(px.Lines[0])
	client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxy)}, Timeout: 30 * time.Second}
	resp, err := client.Get("https://prokso.com/ip")
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	var ip map[string]any
	json.NewDecoder(resp.Body).Decode(&ip)
	fmt.Println(ip["ip"], ip["country"], ip["city"])
}

Zakup z ponowieniem bez duplikatów

Klucz Idempotency-Key utwórz raz, przed pierwszą próbą, i wysyłaj ten sam przy każdym ponowieniu: jeśli połączenie zerwie się po płatności, powtórne żądanie zwróci to samo zamówienie, a nie kupi gigabajtów drugi raz. Ciąg dalszy przykładu w Pythonie:

import uuid

key = str(uuid.uuid4())
order = call("POST", f"/plans/{plan['id']}/topup", json={"gb": 10}, headers={"Idempotency-Key": key})
print(order["order"]["id"], order["order"]["amount"], order["balance"])

OpenAPI i Postman

Opis API w formacie OpenAPI 3.1 to openapi.json: otwierają go Postman, Insomnia, Swagger UI i generatory klientów. Gotowa kolekcja Postman to prokso.postman_collection.json: zaimportuj plik i wpisz klucz do zmiennej kolekcji api_key, a numer planu do plan_id.

Metody

`GET /api/v1/me`

E-mail konta i saldo.

curl https://prokso.com/api/v1/me \
  -H "Authorization: Bearer $PROKSO_KEY"

{
  "email": "you@example.com",
  "balance_cents": 4250,
  "balance": "$42.50",
  "currency": "USD"
}

`GET /api/v1/prices`

Ceny za 1 GB i warunki jednego zamówienia dla każdego typu proxy – aktualne, jak w panelu.

curl https://prokso.com/api/v1/prices -H "Authorization: Bearer $PROKSO_KEY"

{
  "currency": "USD",
  "max_gb_per_order": 5000,
  "pools": {
    "residential": {
      "tiers": [
        {
          "from_gb": 1,
          "price_per_gb_cents": 159,
          "price_per_gb": "$1.59"
        }
      ],
      "min_order_cents": 100,
      "min_order": "$1.00",
      "min_gb": 1
    },
    "mobile": {...},
    "datacenter": {...}
  }
}

`GET /api/v1/plans`

Wszystkie plany: typ, status (active, paused, limited), login, kupione GB i pozostały transfer.

curl https://prokso.com/api/v1/plans -H "Authorization: Bearer $PROKSO_KEY"

{
  "plans": [{
    "id": 17, "label": "Instagram UA", "pool": "residential",
    "status": "active", "paused": false, "login": "a1b2c3d4", "gb_bought": 10,
    "traffic": {"left_bytes": 8053063680, "used_bytes": 2684354560, "total_bytes": 10737418240,
                "left_gb": 7.5, "used_gb": 2.5, "total_gb": 10.0},
    "created_at": "2026-10-05T09:12:44Z"
  }]
}

`GET /api/v1/plans/{id}`

Jeden plan: host, porty, login i hasło, biała lista IP, ustawienia puli.

curl https://prokso.com/api/v1/plans/17 -H "Authorization: Bearer $PROKSO_KEY"

{
  "id": 17, "label": "Instagram UA", "pool": "residential", "status": "active", ...,
  "host": "gw.prokso.com", "login": "a1b2c3d4", "password": "********",
  "ports": {"http_rotating": 823, "socks5_rotating": 824, "sticky_from": 10000, "sticky_to": 20000},
  "ip_whitelist": ["203.0.113.7"], "ip_whitelist_max": 5,
  "pool_settings": {"countries": [], "exclude_countries": [], "exclude_asn": [], "anonymous_filter": false,
                    "rotation_interval_minutes": null, "blocked_hosts": [], "traffic_limit": null}
}

`POST /api/v1/plans`

Nowy plan opłacony z salda. pool – residential, mobile lub datacenter; gb – liczba całkowita; label i promo – opcjonalne.

curl -X POST https://prokso.com/api/v1/plans \
  -H "Authorization: Bearer $PROKSO_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: 6f1c2a90-order-1" \
  -d '{"pool": "residential", "gb": 10, "label": "Instagram UA"}'

201 Created
{
  "order": {"id": 311, "kind": "new", "status": "fulfilled", "pool": "residential", "gb": 10,
            "plan_id": 18, "amount_cents": 1590, "amount": "$15.90", ...},
  "plan": {"id": 18, "login": "e5f6a7b8", ...},
  "balance_cents": 2350, "balance": "$23.50"
}

`POST /api/v1/plans/{id}/topup`

Dokupić GB do istniejącego planu z salda. Te same zasady co dla nowego planu.

curl -X POST https://prokso.com/api/v1/plans/17/topup \
  -H "Authorization: Bearer $PROKSO_KEY" \
  -H "Idempotency-Key: 6f1c2a90-topup-1" \
  -d '{"gb": 50}'

201 Created
{"order": {"id": 312, "kind": "topup", "status": "fulfilled", "gb": 50, ...}, "plan": {...}, ...}

`GET /api/v1/plans/{id}/proxies`

Linie proxy dla planu. JSON lub zwykły tekst.

Dodaj nagłówek Accept: text/plain – dostaniesz linie zwykłym tekstem, po jednej w wierszu.

curl "https://prokso.com/api/v1/plans/17/proxies?country=ua&count=3&protocol=http&session=sticky" \
  -H "Authorization: Bearer $PROKSO_KEY"

{
  "lines": [
    "a1b2c3d4__cr.ua:********@gw.prokso.com:10000",
    "a1b2c3d4__cr.ua:********@gw.prokso.com:10001",
    "a1b2c3d4__cr.ua:********@gw.prokso.com:10002"
  ],
  "count": 3,
  "precise_geo": false
}

`GET /api/v1/plans/{id}/whitelist`
`POST /api/v1/plans/{id}/whitelist`
`DELETE /api/v1/plans/{id}/whitelist?ip=…`

Biała lista IP planu: podgląd, dodanie (POST z polem ip) i usunięcie (DELETE z parametrem ip).

curl -X POST https://prokso.com/api/v1/plans/17/whitelist \
  -H "Authorization: Bearer $PROKSO_KEY" \
  -d '{"ip": "203.0.113.7"}'

{"ips": ["203.0.113.7"], "max": 5}

`POST /api/v1/plans/{id}/pause`
`POST /api/v1/plans/{id}/resume`

Wstrzymać plan (proxy nie działają, transfer się nie zużywa) lub wznowić.

curl -X POST https://prokso.com/api/v1/plans/17/pause -H "Authorization: Bearer $PROKSO_KEY"

{"id": 17, "status": "paused", "paused": true, ...}

`PATCH /api/v1/plans/{id}`

Zmienić nazwę planu (label, do 60 znaków).

curl -X PATCH https://prokso.com/api/v1/plans/17 \
  -H "Authorization: Bearer $PROKSO_KEY" \
  -d '{"label": "Ads Poland"}'

{"id": 17, "label": "Ads Poland", ...}

`GET /api/v1/orders`
`GET /api/v1/orders/{id}`

Ostatnie zamówienia konta (limit – do 100) i jedno zamówienie po numerze.

curl "https://prokso.com/api/v1/orders?limit=20" -H "Authorization: Bearer $PROKSO_KEY"

{"orders": [{"id": 312, "kind": "topup", "status": "fulfilled", "gb": 50, "amount": "$79.50", ...}]}

Parametry generatora proxy

Te same zasady co w generatorze w panelu (tryb zaawansowany). Dokładna lokalizacja – stan, miasto, kod pocztowy, dostawca – zużywa transfer podwójnie.

Parametr	Wartość
`country`	Kod kraju (pl) lub do 10 kodów po przecinku; puste – dowolny kraj.
`count`	Liczba linii, 1–1000 (domyślnie 10). Dla session=rotating wystarczy jedna linia.
`protocol`	http lub socks5.
`session`	sticky – osobny port 10000–20000 na każdą linię i ten sam IP; rotating – nowy IP przy każdym żądaniu (port 823 HTTP, 824 SOCKS5); session – port rotacyjny z numerem sesji w loginie.
`format`	lp@hp, hp:lp, url, hp@lp, lp:hp lub hp (tylko host i port – do dostępu po IP).
`start_port`	Pierwszy port dla sticky, 10000–20000.
`state, city, zip, asn`	Dokładna lokalizacja i dostawca (ASN) – dla jednego kraju; stan – tylko dla USA.
`exclude_state, exclude_city, exclude_zip`	Wykluczyć stany, miasta lub kody pocztowe.
`session_prefix`	Prefiks numerów sesji dla session, litery łacińskie i cyfry.

Proxy statyczne

Stały adres IP na tydzień lub miesiąc: ISP, serwerowe IPv4 i mobilne na modemie 4G/5G. Płatność tylko z salda, cena – za jeden adres. Idempotency-Key działa tak samo jak przy zakupie gigabajtów.

Postęp zamówienia w polu status: paid (środki pobrane) → preparing (przygotowujemy adresy, zwykle do 10 minut) → configuring (tworzymy login i sprawdzamy proxy) → ready. failed – zamówienie nie zostało zrealizowane, pieniądze wróciły na saldo (refunded: true).

Osobne kody: product_unavailable (404) – produkt nie jest teraz w sprzedaży; out_of_stock (409) – kraju lub operatora nie ma w ofercie; price_changed (409) – cena jest wyższa niż expected_price_cents, nowa cena jest w polu price_cents; rotation_not_available (409) i rotate_too_often (429, retry_after) – przy zmianie IP.

`GET /api/v1/static/products`

Które produkty są teraz w sprzedaży, okresy i ceny za IP (w centach i dolarach). Cena mobilnych nie ma progów: liczymy ją dla każdego kraju, operatora, typu modemu, rotacji i okresu.

curl https://prokso.com/api/v1/static/products -H "Authorization: Bearer $PROKSO_KEY"

{
  "currency": "USD",
  "periods": [{"id": "1w", "days": 7}, {"id": "1m", "days": 30}],
  "products": {
    "isp": {"enabled": true, "max_qty": 100, "tiers": {"1w": [{"from_qty": 1, "price_per_ip_cents": 220, "price_per_ip": "$2.20"}, ...],
                                                     "1m": [...]}},
    ...
  }
}

`GET /api/v1/static/countries?product=isp`

Dostępne kraje: kod (pl), alpha-3 (POL) i nazwa. Parametr product – isp, ipv4, mobile. Dla mobile – także operatorzy według typu modemu (shared – wspólny, dedicated – dedykowany), warianty rotacji i cena za modem na 1w i 1m (null – jeszcze nie policzono; z parametrem country cenę liczymy od razu).

curl "https://prokso.com/api/v1/static/countries?product=isp" -H "Authorization: Bearer $PROKSO_KEY"

{"product": "isp", "countries": [{"code": "ua", "alpha3": "UKR", "name": "Ukraine"}, ...]}

curl "https://prokso.com/api/v1/static/countries?product=mobile&country=us" -H "Authorization: Bearer $PROKSO_KEY"

{
  "product": "mobile",
  "countries": [{
    "code": "us", "alpha3": "USA", "name": "United States",
    "service_types": {
      "shared": [{"id": "operator_a", "name": "Operator A", "traffic": "unlimited traffic",
                  "rotations": [{"id": 0, "by_link": true, "label": "By link - you change the IP yourself",
                                 "price_cents": {"1w": 3200, "1m": 6400}, "price": {"1w": "$32.00", "1m": "$64.00"}}, ...]}],
      "dedicated": [...]
    }
  }]
}

`POST /api/v1/static/orders`

Kupić adresy z salda: product, country (pl lub POL), period (1w lub 1m), qty. Odpowiedź – numer zamówienia i status; adresy pojawiają się po kilku minutach. Dla mobile – także service_type, operator, rotation i najlepiej expected_price_cents: cena za modem, którą widziałeś.

curl -X POST https://prokso.com/api/v1/static/orders \
  -H "Authorization: Bearer $PROKSO_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: 9b2e-static-1" \
  -d '{"product": "isp", "country": "ua", "period": "1m", "qty": 2}'

201 Created
{
  "order": {"id": 41, "kind": "new", "product": "isp", "status": "paid", "step": 1, "steps": 4,
            "country": "ua", "period": "1m", "qty": 2, "price_per_ip_cents": 340, "amount_cents": 680, "amount": "$6.80",
            "refunded": false, "proxy_ids": [], ...},
  "balance_cents": 3570, "balance": "$35.70"
}

curl -X POST https://prokso.com/api/v1/static/orders \
  -H "Authorization: Bearer $PROKSO_KEY" \
  -H "Idempotency-Key: 9b2e-modem-1" \
  -d '{"product": "mobile", "country": "us", "period": "1w", "qty": 1,
       "service_type": "shared", "operator": "operator_a", "rotation": 0, "expected_price_cents": 3200}'

409 Conflict
{"error": {"code": "price_changed", "message": "The price has changed - check the new amount and confirm again.",
           "price_cents": 3450, "price": "$34.50"}}

`GET /api/v1/static/orders/{id}`

Postęp jednego zamówienia i numery wydanych adresów (proxy_ids).

curl https://prokso.com/api/v1/static/orders/41 -H "Authorization: Bearer $PROKSO_KEY"

{"id": 41, "kind": "new", "product": "isp", "status": "ready", "step": 4, "proxy_ids": [57, 58], ...}

`GET /api/v1/static/proxies`

Twoje adresy: IP, porty HTTP i SOCKS5, login, hasło, kraj, okres i notatka. Adresy, których okres minął, nie mają loginu ani hasła. Mobilne mają też operatora, typ modemu, rotację i rotate_url: link do zmiany IP, tylko dla rotacji „przez link”.

curl https://prokso.com/api/v1/static/proxies -H "Authorization: Bearer $PROKSO_KEY"

{
  "proxies": [{
    "id": 57, "product": "isp", "status": "active", "ip": "203.0.113.24", "port_http": 50100, "port_socks": 50101,
    "login": "u7f3k2", "password": "********", "country": "ua", "period": "1m",
    "expires_at": "2026-11-26T10:00:00Z", "label": "", "order_id": 41
  }, ...]
}

curl https://prokso.com/api/v1/static/proxies -H "Authorization: Bearer $PROKSO_KEY"

{"proxies": [{"id": 60, "product": "mobile", ...,
  "mobile": {"operator": "Operator A", "service_type": "shared",
             "rotation": {"id": 0, "by_link": true, "label": "By link - you change the IP yourself"},
             "rotate_url": "https://prokso.com/rotate/********"}}]}

`POST /api/v1/static/proxies/renew`

Przedłużyć aktywne adresy z salda (ids, period). Różne produkty przedłuża się osobnymi żądaniami.

curl -X POST https://prokso.com/api/v1/static/proxies/renew \
  -H "Authorization: Bearer $PROKSO_KEY" \
  -H "Idempotency-Key: 9b2e-renew-1" \
  -d '{"ids": [57, 58], "period": "1m"}'

201 Created
{"order": {"id": 44, "kind": "renew", "status": "paid", "proxy_ids": [57, 58], "amount": "$6.80", ...}, ...}

`POST /api/v1/static/proxies/{id}/rotate`

Zmienić IP proxy mobilnego z rotacją „przez link”, nie częściej niż raz na minutę.

curl -X POST https://prokso.com/api/v1/static/proxies/60/rotate -H "Authorization: Bearer $PROKSO_KEY"

{"id": 60, "rotated": true, "message": "IP change requested. The new IP will be ready within a minute."}

Serwer MCP dla agentów AI

Claude, Cursor i inne aplikacje obsługujące Model Context Protocol (MCP) łączą się z Twoim kontem bezpośrednio: agent sam sprawdza pozostały transfer i pobiera linie proxy. Adres to https://prokso.com/api/v1/mcp (transport Streamable HTTP), logowanie – ten sam klucz API w nagłówku Authorization: Bearer, te same limity.

Narzędzia: get_account (e-mail i saldo), get_prices (ceny), list_plans (plany i pozostały transfer), get_plan (login, porty), get_proxy_lines (linie proxy z krajem, stanem, miastem lub dostawcą). Narzędzia tylko odczytują dane i wydają linie – nie wydają pieniędzy; zakup – w panelu lub przez REST API powyżej.

Przykład konfiguracji (Cursor – .cursor/mcp.json, Claude Code – .mcp.json w projekcie):

{
  "mcpServers": {
    "prokso": {
      "type": "http",
      "url": "https://prokso.com/api/v1/mcp",
      "headers": {"Authorization": "Bearer YOUR_API_KEY"}
    }
  }
}

Konfiguracja krok po kroku dla Claude Code, Claude Desktop, Cursor, VS Code, Windsurf, Zed i Cline – na stronie „Serwer MCP Prokso dla agentów AI”.

API dla programistów

Szybki start

Autoryzacja

Ograniczenia

Błędy

Zakupy bez duplikatów

Przykłady kodu

Python 3 (requests)

Node.js 18+ (undici)

PHP 8 (cURL)

Go 1.21+

Zakup z ponowieniem bez duplikatów

OpenAPI i Postman

Metody

GET /api/v1/me

GET /api/v1/prices

GET /api/v1/plans

GET /api/v1/plans/{id}

POST /api/v1/plans

POST /api/v1/plans/{id}/topup

GET /api/v1/plans/{id}/proxies

GET /api/v1/plans/{id}/whitelistPOST /api/v1/plans/{id}/whitelistDELETE /api/v1/plans/{id}/whitelist?ip=…

POST /api/v1/plans/{id}/pausePOST /api/v1/plans/{id}/resume

PATCH /api/v1/plans/{id}

GET /api/v1/ordersGET /api/v1/orders/{id}