Q token mark QUADRPC Endpoints

QUAD RPC / Developer quickstart

Use QUAD RPC in five minutes.

Curl a free public endpoint in seconds with no key, then add a CU key when you need dedicated production throughput. Examples for curl, JavaScript, and Go.

Five Minute Path

This is the shortest usable path from intent to authenticated endpoint call.

  1. Curl it free.Hit an enabled chain with no key — free public tier, rate-limited (~300 req/min/IP).
  2. Hitting the ceiling? Buy CU.For production throughput, create a quote and pay through the quote-issued rail, address, amount, and matching rule.
  3. Claim the API key.Use the private browser claim path after the matched payment is observed.
  4. Call with your key.Send X-Wallet-Address and X-API-Key headers for dedicated throughput.
  5. Top up by quote.Top-up is another quote-matched payment into the same wallet-bound customer surface.

Curl Quickstart

Free tier needs no key — just curl an enabled chain. Add your CU key for production.

Free (no key, rate-limited):

curl https://cosmos.rpc.uquad.org/status
curl https://akash.rpc.uquad.org/cosmos/base/tendermint/v1beta1/syncing

Production (CU key, dedicated throughput):

curl \
  -H "X-Wallet-Address: <wallet>" \
  -H "X-API-Key: <api-key>" \
  https://cosmos.rpc.uquad.org/status

JavaScript Quickstart

Use this pattern in a backend service or local script. Keep API keys out of public browser code.

const endpoint = 'https://cosmos.rpc.uquad.org/status';
const response = await fetch(endpoint, {
  headers: {
    'X-Wallet-Address': process.env.UQUAD_RPC_WALLET,
    'X-API-Key': process.env.UQUAD_RPC_KEY
  }
});

if (!response.ok) {
  throw new Error(`RPC request failed: ${response.status}`);
}

console.log(await response.json());

Go Quickstart

A minimal authenticated HTTP request. Handle retries, status-gated lanes, and CU budgeting in your own integration.

package main

import (
  "fmt"
  "io"
  "net/http"
  "os"
)

func main() {
  req, err := http.NewRequest("GET", "https://cosmos.rpc.uquad.org/status", nil)
  if err != nil { panic(err) }
  req.Header.Set("X-Wallet-Address", os.Getenv("UQUAD_RPC_WALLET"))
  req.Header.Set("X-API-Key", os.Getenv("UQUAD_RPC_KEY"))

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

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

Keep The Boundary

These examples show access mechanics, not economic or chain guarantees.

No Browser Secrets

Do not embed API keys in public frontend code.

Free Tier Is Rate-Limited

Free public tier is rate-limited (~300 req/min/IP), best-effort. Gated chains and dedicated, production throughput use CU.

No Chain Finality

RPC responses are observations, not consensus or final settlement guarantees.

No Token Claim

Buying CU does not create reward eligibility, allocation, yield, redemption, governance, or future entitlement.