Plans API

List the plans available to your account and their pricing. Regular plans are one-time traffic purchases; subscription plans bill on a recurring period; ISP plans are dedicated ISP proxies. Each endpoint returns a plain plan object (or array of plan objects) — these responses are not wrapped in the standard {success, payload, meta, errors, description} envelope. Public pricing endpoints require no authentication and are safe to call from a landing page.

Plan names are their identifiers. Regular plans are named by size (e.g. 10GB, 50GB); subscription plans embed their period (e.g. monthly-100GB, annual-100GB). Use the exact name value from a list response when calling the by-name endpoints or when creating a payment with plan_id.

Regular Plans

GET /v1/regular-options Requires Auth

List Regular Plans

Retrieve every regular (one-time purchase) plan visible to the authenticated user. General plans are merged with any personal plans assigned to the account. Returns a flat array of plan objects.

No input needed — runs live with your key

curl https://api.proxyhat.com/v1/regular-options \
  -H "Authorization: Bearer __API_KEY__" \
  -H "Accept: application/json"

import requests

response = requests.get(
    "https://api.proxyhat.com/v1/regular-options",
    headers={
        "Authorization": "Bearer __API_KEY__",
        "Accept": "application/json",
    },
)

plans = response.json()
for plan in plans:
    print(f"{plan[\"name\"]}: {plan[\"gb\"]}GB at ${plan[\"price_total\"]}")

const response = await fetch("https://api.proxyhat.com/v1/regular-options", {
  headers: {
    "Authorization": "Bearer __API_KEY__",
    "Accept": "application/json",
  },
});

const plans = await response.json();
plans.forEach(p => console.log(`${p.name}: ${p.gb}GB at $${p.price_total}`));

req, _ := http.NewRequest("GET", "https://api.proxyhat.com/v1/regular-options", nil)
req.Header.Set("Authorization", "Bearer __API_KEY__")
req.Header.Set("Accept", "application/json")

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

var plans []map[string]interface{}
json.NewDecoder(resp.Body).Decode(&plans)
for _, p := range plans {
    fmt.Printf("%s: %vGB at $%v\n", p["name"], p["gb"], p["price_total"])
}

Personal plans. When a plan is assigned to your account (user_id is your UUID) and it carries a purchase cap, the list adds two extra fields to that plan object: payment_limit (the maximum number of paid purchases allowed) and purchases_remaining (how many you have left). General plans never include purchases_remaining.

GET /v1/plans/regular/{name} Requires Auth

Get Regular Plan

Retrieve a single regular plan by its name. Personal plans are only visible to the user they belong to — requesting another user's personal plan returns 404. Returns a flat plan object.

We filled these in for you: name

Tweak any value if you like — or just press Try.

Path Parameters

Name	Type	Required	Description
name	string	Required	The name identifier of the regular plan (e.g. "10GB").

curl https://api.proxyhat.com/v1/plans/regular/10GB \
  -H "Authorization: Bearer __API_KEY__" \
  -H "Accept: application/json"

import requests

plan_name = "10GB"

response = requests.get(
    f"https://api.proxyhat.com/v1/plans/regular/{plan_name}",
    headers={
        "Authorization": "Bearer __API_KEY__",
        "Accept": "application/json",
    },
)

plan = response.json()
print(f"{plan[\"name\"]}: {plan[\"gb\"]}GB at ${plan[\"price_total\"]}")

const planName = "10GB";

const response = await fetch(`https://api.proxyhat.com/v1/plans/regular/${planName}`, {
  headers: {
    "Authorization": "Bearer __API_KEY__",
    "Accept": "application/json",
  },
});

const plan = await response.json();
console.log(`${plan.name}: ${plan.gb}GB at $${plan.price_total}`);

planName := "10GB"
url := fmt.Sprintf("https://api.proxyhat.com/v1/plans/regular/%s", planName)

req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer __API_KEY__")
req.Header.Set("Accept", "application/json")

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

var plan map[string]interface{}
json.NewDecoder(resp.Body).Decode(&plan)
fmt.Printf("%s: %vGB at $%v\n", plan["name"], plan["gb"], plan["price_total"])

Subscription Plans

GET /v1/subscription-plans Requires Auth

List Subscription Plans

Retrieve every subscription plan visible to the authenticated user (general plans merged with any personal plans). Optionally filter by billing period. Returns a flat array of plan objects.

We filled these in for you: period

Tweak any value if you like — or just press Try.

Query Parameters

Name	Type	Required	Description
period	string	Optional	Filter by billing period: "monthly" or "annual". Omit to return all periods.

curl "https://api.proxyhat.com/v1/subscription-plans?period=monthly" \
  -H "Authorization: Bearer __API_KEY__" \
  -H "Accept: application/json"

import requests

response = requests.get(
    "https://api.proxyhat.com/v1/subscription-plans",
    headers={
        "Authorization": "Bearer __API_KEY__",
        "Accept": "application/json",
    },
    params={
        "period": "monthly",
    },
)

plans = response.json()
for plan in plans:
    print(f"{plan[\"name\"]}: {plan[\"gb\"]}GB at ${plan[\"price_total\"]}/{plan[\"period\"]}")

const params = new URLSearchParams({ period: "monthly" });

const response = await fetch(`https://api.proxyhat.com/v1/subscription-plans?${params}`, {
  headers: {
    "Authorization": "Bearer __API_KEY__",
    "Accept": "application/json",
  },
});

const plans = await response.json();
plans.forEach(p => console.log(`${p.name}: ${p.gb}GB at $${p.price_total}/${p.period}`));

req, _ := http.NewRequest("GET", "https://api.proxyhat.com/v1/subscription-plans?period=monthly", nil)
req.Header.Set("Authorization", "Bearer __API_KEY__")
req.Header.Set("Accept", "application/json")

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

var plans []map[string]interface{}
json.NewDecoder(resp.Body).Decode(&plans)
for _, p := range plans {
    fmt.Printf("%s: %vGB at $%v/%s\n", p["name"], p["gb"], p["price_total"], p["period"])
}

GET /v1/plans/subscription/{name} Requires Auth

Get Subscription Plan

Retrieve a single subscription plan by its name. The result is cached for one hour. Returns a flat plan object including billing period and rollover configuration.

We filled these in for you: name

Tweak any value if you like — or just press Try.

Path Parameters

Name	Type	Required	Description
name	string	Required	The name identifier of the subscription plan (e.g. "monthly-100GB").

curl https://api.proxyhat.com/v1/plans/subscription/monthly-100GB \
  -H "Authorization: Bearer __API_KEY__" \
  -H "Accept: application/json"

import requests

plan_name = "monthly-100GB"

response = requests.get(
    f"https://api.proxyhat.com/v1/plans/subscription/{plan_name}",
    headers={
        "Authorization": "Bearer __API_KEY__",
        "Accept": "application/json",
    },
)

plan = response.json()
print(f"{plan[\"name\"]}: {plan[\"gb\"]}GB at ${plan[\"price_total\"]}/{plan[\"period\"]}")

const planName = "monthly-100GB";

const response = await fetch(`https://api.proxyhat.com/v1/plans/subscription/${planName}`, {
  headers: {
    "Authorization": "Bearer __API_KEY__",
    "Accept": "application/json",
  },
});

const plan = await response.json();
console.log(`${plan.name}: ${plan.gb}GB at $${plan.price_total}/${plan.period}`);

planName := "monthly-100GB"
url := fmt.Sprintf("https://api.proxyhat.com/v1/plans/subscription/%s", planName)

req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer __API_KEY__")
req.Header.Set("Accept", "application/json")

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

var plan map[string]interface{}
json.NewDecoder(resp.Body).Decode(&plan)
fmt.Printf("%s: %vGB at $%v/%s\n", plan["name"], plan["gb"], plan["price_total"], plan["period"])

ISP Plans

Requires ISP proxy access. This endpoint is only available to accounts with has_isp_proxy_access enabled (check the has_isp_proxy_access field on GET /v1/auth/user). Without it the endpoint returns 403 in the standard envelope: { "success": false, "payload": null, "errors": { "access": "..." }, "description": "Access denied" }. To browse the full ISP catalog use GET /v1/isp-store/catalog.

GET /v1/plans/isp/{id} Requires Auth

Get ISP Plan

Retrieve a single active ISP plan by its UUID. Internal cost and markup fields are stripped from the response. A `name` alias (equal to `isp_name`) is added for convenience. Returns a flat plan object; 404 if the plan does not exist or is inactive.

We filled these in for you: id

Tweak any value if you like — or just press Try.

Path Parameters

Name	Type	Required	Description
id	string	Required	The UUID of the ISP plan (from the ISP store catalog).

curl https://api.proxyhat.com/v1/plans/isp/8d2e1f4a-6b3c-4e9d-a12f-7c5b0e3d9a84 \
  -H "Authorization: Bearer __API_KEY__" \
  -H "Accept: application/json"

import requests

plan_id = "8d2e1f4a-6b3c-4e9d-a12f-7c5b0e3d9a84"

response = requests.get(
    f"https://api.proxyhat.com/v1/plans/isp/{plan_id}",
    headers={
        "Authorization": "Bearer __API_KEY__",
        "Accept": "application/json",
    },
)

plan = response.json()
print(f"{plan[\"name\"]} ({plan[\"country_code\"]}): ${plan[\"price_total\"]}")

const planId = "8d2e1f4a-6b3c-4e9d-a12f-7c5b0e3d9a84";

const response = await fetch(`https://api.proxyhat.com/v1/plans/isp/${planId}`, {
  headers: {
    "Authorization": "Bearer __API_KEY__",
    "Accept": "application/json",
  },
});

const plan = await response.json();
console.log(`${plan.name} (${plan.country_code}): $${plan.price_total}`);

planID := "8d2e1f4a-6b3c-4e9d-a12f-7c5b0e3d9a84"
url := fmt.Sprintf("https://api.proxyhat.com/v1/plans/isp/%s", planID)

req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer __API_KEY__")
req.Header.Set("Accept", "application/json")

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

var plan map[string]interface{}
json.NewDecoder(resp.Body).Decode(&plan)
fmt.Printf("%s (%s): $%v\n", plan["name"], plan["country_code"], plan["price_total"])

Public Pricing

These endpoints require no authentication and return only general plans (never personal plans). Both are cached for five minutes. Use them to render pricing on public pages.

GET /v1/pricing/regular

Public Regular Pricing

Public endpoint, no auth required. Returns all general regular plans (ordered by GB) for display on landing pages.

No input needed — runs live with your key

curl https://api.proxyhat.com/v1/pricing/regular \
  -H "Accept: application/json"

import requests

response = requests.get(
    "https://api.proxyhat.com/v1/pricing/regular",
    headers={
        "Accept": "application/json",
    },
)

plans = response.json()
for plan in plans:
    print(f"{plan[\"name\"]}: {plan[\"gb\"]}GB at ${plan[\"price_total\"]}")

const response = await fetch("https://api.proxyhat.com/v1/pricing/regular", {
  headers: {
    "Accept": "application/json",
  },
});

const plans = await response.json();
plans.forEach(p => console.log(`${p.name}: ${p.gb}GB at $${p.price_total}`));

req, _ := http.NewRequest("GET", "https://api.proxyhat.com/v1/pricing/regular", nil)
req.Header.Set("Accept", "application/json")

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

var plans []map[string]interface{}
json.NewDecoder(resp.Body).Decode(&plans)
for _, p := range plans {
    fmt.Printf("%s: %vGB at $%v\n", p["name"], p["gb"], p["price_total"])
}

GET /v1/pricing/subscriptions

Public Subscription Pricing

Public endpoint, no auth required. Returns all general subscription plans (ordered by GB). Optionally filter by billing period.

We filled these in for you: period

Tweak any value if you like — or just press Try.

Query Parameters

Name	Type	Required	Description
period	string	Optional	Filter by billing period: "monthly" or "annual".

curl "https://api.proxyhat.com/v1/pricing/subscriptions?period=monthly" \
  -H "Accept: application/json"

import requests

response = requests.get(
    "https://api.proxyhat.com/v1/pricing/subscriptions",
    headers={
        "Accept": "application/json",
    },
    params={
        "period": "monthly",
    },
)

plans = response.json()
for plan in plans:
    print(f"{plan[\"name\"]}: {plan[\"gb\"]}GB at ${plan[\"price_total\"]}/{plan[\"period\"]}")

const params = new URLSearchParams({ period: "monthly" });

const response = await fetch(`https://api.proxyhat.com/v1/pricing/subscriptions?${params}`, {
  headers: {
    "Accept": "application/json",
  },
});

const plans = await response.json();
plans.forEach(p => console.log(`${p.name}: ${p.gb}GB at $${p.price_total}/${p.period}`));

req, _ := http.NewRequest("GET", "https://api.proxyhat.com/v1/pricing/subscriptions?period=monthly", nil)
req.Header.Set("Accept", "application/json")

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

var plans []map[string]interface{}
json.NewDecoder(resp.Body).Decode(&plans)
for _, p := range plans {
    fmt.Printf("%s: %vGB at $%v/%s\n", p["name"], p["gb"], p["price_total"], p["period"])
}