ProxyGate , Buy API Access

intent

use this skill when a user needs to purchase API access through ProxyGate. covers the full buyer workflow: checking balance, depositing USDC stablecoin, discovering available APIs across categories and sellers, making authenticated proxy requests to third-party APIs, streaming responses, consuming credits, and rating seller performance. trigger on mentions of "proxy request", "buy API", "deposit USDC", "browse APIs", "call API through proxygate", "make an API call", "find an API", "search APIs", or any intent to consume an API via ProxyGate, even if the user doesn't explicitly say "buy".

inputs

Solana wallet & keypair

• location: ~/.proxygate/keypair.json (auto-created during pg-setup)
• requirement: USDC balance in connected Solana wallet for deposits
• fallback: use --keypair <path> flag to specify custom keypair location

ProxyGate CLI or SDK

• CLI: installed via pg-update skill or npm (npm install -g @proxygate/cli)
• SDK: installed via npm (npm install @proxygate/sdk)
• version: must be current (check with proxygate --version)

RPC endpoint (optional)

• default: ProxyGate's public RPC
• custom: pass --rpc <url> to any CLI command for custom Solana RPC
• env var: PROXYGATE_RPC_URL (auto-loaded if set)

API credentials for specific services (conditional)

• some proxied APIs require upstream auth (API keys, OAuth tokens)
• credentials stored: ProxyGate vault (encrypted)
• setup: typically handled by service listing documentation

procedure

1. check balance

run:

proxygate balance

output includes: total balance, pending settlement, available credits, cooldown status, withdrawal eligibility.

input: keypair location (default ~/.proxygate/keypair.json) output: balance object with numeric fields in lamports (1 USDC = 1,000,000 lamports)

if balance is 0 or insufficient for intended requests, proceed to step 2 (deposit).

2. deposit USDC

run:

proxygate deposit -a 5000000      # deposits 5 USDC
proxygate deposit -a 1000000      # deposits 1 USDC
proxygate deposit --rpc <custom-url>

input:

• -a <amount>: lamport amount (1 USDC = 1,000,000 lamports)
• --rpc <url>: optional custom Solana RPC endpoint
• keypair: must have USDC balance in Solana wallet

output:

• tx signature (blockchain confirmation)
• vault address (auto-initialized on first deposit)
• updated available balance after settlement

vault auto-initializes on first deposit if it doesn't exist. user must have USDC in their Solana wallet before depositing.

3. discover APIs

list all APIs:

proxygate apis                    # all available listings

filter by service name:

proxygate apis -s weather-api     # exact service match

filter by category:

proxygate apis -c ai-models       # e.g., "ai-models", "weather", "fintech"

semantic search:

proxygate apis -q "code review"   # free-text query
proxygate search weather          # shorthand alias

verified sellers only:

proxygate apis --verified

sort and limit:

proxygate apis --sort price_asc   # options: price_asc, price_desc, popular, newest
proxygate apis -l 50              # limit to 50 results

browse metadata:

proxygate services                # stats: cheapest, avg latency, rating per service
proxygate categories              # list all category slugs
proxygate listings docs <id>      # fetch upstream API documentation by listing UUID

input: optional filters (service, category, search query, verified flag, sort order, limit) output: list of API listings with: service name, description, price (lamports per request), latency, seller rating, category, verification status

4. proxy a request

resolve the API by service name, slug, or listing UUID. CLI auto-resolves:

by service name (recommended):

proxygate proxy weather-api /v1/forecast \
  -d '{"latitude":52.37,"longitude":4.90,"hourly":"temperature_2m"}'

simple GET request:

proxygate proxy agent-postal-lookup /nl/1012

stream server-sent events (SSE):

proxygate proxy weather-api /v1/forecast --stream \
  -d '{"latitude":52.37,"longitude":4.90,"hourly":"temperature_2m"}'

with shield content moderation:

proxygate proxy weather-api /path --shield monitor   # log threats, no block (default)
proxygate proxy weather-api /path --shield strict    # block threats, refund credits
proxygate proxy weather-api /path --shield off       # disable scanning, no surcharge

input:

• service name, slug, or listing UUID
• endpoint path
• request body (JSON, optional, via -d or stdin)
• --stream: enable SSE parsing
• --shield <mode>: monitor (default), strict, or off
• headers: pass via -H "X-Custom: value" (optional)

output:

• upstream API response (status, body, headers)
• cost in lamports (displayed as cost: $0.0155 | request: <req-id>)
• request ID (used for rating, tracking, disputes)

after each call, capture the request ID displayed in the response footer.

5. rate a seller

use the request ID from step 4's response:

proxygate rate --request-id 905b1a53 --up      # positive rating
proxygate rate --request-id 905b1a53 --down    # negative rating

input:

• --request-id <id>: from previous proxy response
• --up or --down: boolean flag

output: confirmation message, updated seller reputation score

ratings are immutable once submitted.

6. check usage and settlements

recent request history:

proxygate usage                                   # all requests, most recent first
proxygate usage -s weather-api -l 50              # filter by service, limit
proxygate usage --from 2026-03-01 --to 2026-03-14 # date range (ISO 8601)
proxygate usage --json                            # machine-readable output

cost and settlement breakdown:

proxygate settlements -r buyer                    # cost per service
proxygate settlements -s weather-api --from 2026-03-01 # filtered by service + date

input: optional service filter, date range, limit, output format (json) output: request log with timestamps, costs, request IDs, status codes; or settlement summary with total cost and pending/completed amounts

7. withdraw USDC (optional)

convert earned credits or unused balance back to USDC:

proxygate withdraw -a 2000000     # withdraw 2 USDC
proxygate withdraw                # withdraw all available balance

input: -a <amount> in lamports (optional; omit to withdraw full available balance) output: tx signature, withdrawn amount, new balance

recovery (if CLI crashes mid-withdrawal):

proxygate withdraw-confirm --tx <tx_signature>

resubmit a pending withdrawal using its tx signature. use if the CLI process dies before confirming.

decision points

if balance is zero or insufficient for the intended request:

• do: deposit USDC (step 2) before proceeding to proxy calls.
• check: proxygate balance to see available credits.

if user doesn't know which API to use:

• do: browse with proxygate apis, search with proxygate search <keyword>, or filter by category with proxygate apis -c <category>.
• if semantic search is unclear: use proxygate services to inspect pricing and latency stats.

if a proxy request fails (4xx/5xx upstream response):

• check: is the endpoint path correct? (compare against proxygate listings docs <id>)
• check: does the request body match the upstream API schema?
• check: is the service experiencing downtime? (use proxygate services to check avg latency for that API)
• refund: if the failure is due to seller error (Shield identified threats, or upstream misconfiguration), file a dispute via proxygate disputes (not in this skill; escalate to support).

if streaming a response and the connection drops mid-stream:

• behavior: parseSSE() will stop iteration at disconnect. client must reconnect or retry.
• cost: already charged for the initial request, even if stream terminated early.

if rate-limiting occurs (429 from upstream API or ProxyGate):

• advice: wait before retrying. ProxyGate enforces per-service rate limits; check proxygate services for actual limits.
• cost: if ProxyGate rate-limits you (not the upstream API), no credit is deducted.

if withdrawal is pending and user wants to cancel:

• behavior: once tx is signed and submitted to blockchain, it cannot be cancelled. wait for settlement.
• fallback: user can re-deposit immediately and use those credits for new requests.

if keypair or credentials are lost:

• do: refer to pg-setup skill to restore or regenerate keypair.
• funds: any balance in the vault remains accessible with the recovery keypair.

if using SDK (programmatic) instead of CLI:

• init: instantiate ProxyGateClient with keypair path or private key.
• auth: client handles all signing internally.
• error handling: SDK throws exceptions (catch and handle in calling code).

output contract

successful skill execution produces:

on deposit:

• tx signature (string, Solana blockchain tx ID)
• vault address (string, Solana account pubkey)
• new balance in lamports (integer)

on API discovery:

• JSON array of listing objects with keys: service, slug, description, price_per_request_lamports, latency_ms, seller_rating, category, verified (boolean), listing_id (UUID)

on proxy request:

• upstream API response body (passthrough, any format)
• status code (3-digit integer)
• response headers (object)
• cost in lamports (integer)
• request_id (string, UUID)
• footer: human-readable cost display (e.g., "cost: $0.0155 | request: 905b1a53")

on rating:

• confirmation message (string)
• updated seller reputation score (floating-point, 0.0-5.0)

on usage query:

• array of request records: request_id, service_name, endpoint, timestamp, cost_lamports, status_code, upstream_latency_ms

on settlements query:

• object with keys: total_spent_lamports, total_spent_usd, by_service (object mapping service names to costs), pending_amount_lamports, last_settlement_timestamp

on withdraw:

• tx signature (Solana blockchain tx ID)
• withdrawn amount in lamports (integer)
• remaining balance in lamports (integer)

all numeric amounts are in lamports (1 USDC = 1,000,000 lamports) unless explicitly converted to USD for display.

outcome signal

the skill succeeds when:

• proxygate balance returns non-zero available balance
• proxygate apis (or filtered search) returns at least one listing matching the user's intent
• proxygate proxy <service> <path> executes without error and returns a response from the upstream API
• response includes a request ID and cost breakdown
• proxygate usage reflects the completed request in the user's history
• (optional) proxygate rate --request-id <id> --up successfully submits rating
• (optional) proxygate withdraw shows updated balance after tx confirmation

user observes: API response is delivered, cost is deducted from available balance, request appears in usage log, and (if attempted) rating is recorded.

related skills

need	skill
first-time setup & keypair generation	pg-setup
buy API access (this skill)	pg-buy
sell API capacity and earn fees	pg-sell
browse job marketplace	pg-jobs
check ProxyGate service status	pg-status
update CLI or SDK to latest version	pg-update