REST API — Live Demo

Pick a minimum magnitude, hit Run, and watch a live earthquake dataset come back through the Sertone Global Network in under 150ms. The same call, billed per-request, paid automatically.

How This Works

The Call Path

Consumer Premises

Your App

→

Your Sertone
Control Center

On your premises

▼ Request ▲ Response

Sertone Global Network

🔒 Encrypted 🔗 Automatic Payment 🌐 5 Delivery Methods

Proprietary fully encrypted protocol with automatic payment settlement

▼ Request ▲ Response

Owner Premises

Their Sertone
Control Center

→

Earthquake
Data Service

On their premises

What is the Sertone control center? A single Docker container you run on your own machine — a laptop, a Raspberry Pi, a cloud server. It connects you to the Sertone Global Network. Through its built-in web console, you browse services, register your own, manage your wallet, and monitor your earnings. Installation takes minutes. It is completely free, forever.

docker run -d --name my-sertone -p 3000:3000 -p 3002:3002 sertone/wrapper:latest

The Sertone Global Network uses a proprietary fully encrypted protocol. All traffic is end-to-end encrypted. Settlement is automatic.

What the owner did: installed their Sertone control center, registered their earthquake data service through the web console, set their price, and started earning USDC on every call. The Sertone Global Network handles the rest.

For Consumers

How to use this service

Any developer worldwide can consume this service from their own Sertone control center. Here is the complete flow from installation to first call:

Install your Sertone control center

One Docker command on any machine -- your laptop, a Raspberry Pi, a cloud VM.

$ docker run -d --name my-sertone -p 3000:3000 -p 3002:3002 sertone/wrapper:latest

Browse the catalog

Open your web console at https://localhost:3002/panel. Go to the Catalog tab. Search for the service you need -- use keywords, tags, or browse by category.

Preview with demo samples

Click on any service to see its full description, available endpoints, and sample data. Try it in the Swagger sandbox -- demo samples are free, no payment needed. See exactly what the data looks like before you spend a cent.

Fund your wallet

Go to the Finance tab. Deposit USDC and a small amount of ETH for gas. Your control center shows both balances and alerts you when they are low.

Call it from your code

Copy your consumer secret from Settings. Use the service UUID from the catalog. Make your first real call:

$ curl -X POST https://localhost:3000/internal/call \
  -H "Authorization: Bearer YOUR_CONSUMER_SECRET" \
  -H "Content-Type: application/json" \
  -d '{"api_id_public": "SERVICE_UUID", "path": "/v1/earthquakes/recent", "method": "GET"}'

Or generate an SDK in your preferred language (Python, TypeScript, Go, Rust, Kotlin, and more) -- the web console generates ready-to-use client code with the UUID pre-filled.

You are in business

Every call settles automatically in USDC. You pay the service owner's price. No invoices, no payment terms, no chargebacks. Your Finance tab shows every transaction.

Try It

Run a Live Query

GET /v1/earthquakes/recent - routed through the Sertone Global Network

Minimum Magnitude

Max Results

Time Window

Waiting

Select parameters above and click Run Demo

Live call through the Sertone Global Network. Install your own Sertone to make unlimited calls.

Code Samples

Call It From Your Code

Your Sertone runs at localhost:3000. The API ID comes from the catalog. Everything else is standard HTTP.

# Query earthquakes magnitude 5.0+ over the last 30 days # Your Sertone runs at localhost:3000 # SERVICE_UUID: copy from your catalog (Catalog tab → click the service) $ curl -X POST https://localhost:3000/internal/call \ -H "Authorization: Bearer YOUR_CONSUMER_SECRET" \ -H "Content-Type: application/json" \ -d '{"api_id_public": "SERVICE_UUID", "path": "/v1/earthquakes/recent", "method": "GET", "params": {"format": "geojson", "minmagnitude": "5.0", "limit": "5"}}' # Response (routed through the Sertone Global Network, paid automatically): { "place": "127km SSE of Kamchatka", "mag": 5.4, "time": 1743200400000 }

// Node.js or browser — plain fetch(), no SDK needed // SERVICE_UUID: copy from your catalog (Catalog tab → click the service) // YOUR_CONSUMER_SECRET: copy from Settings tab const response = await fetch('https://localhost:3000/internal/call', { method: 'POST', headers: { 'Authorization': 'Bearer YOUR_CONSUMER_SECRET', 'Content-Type': 'application/json', }, body: JSON.stringify({ api_id_public: 'SERVICE_UUID', path: '/v1/earthquakes/recent', method: 'GET', params: { format: 'geojson', minmagnitude: '5.0', limit: '5' }, }), }); const data = await response.json(); data.features.forEach(f => { const { place, mag, time } = f.properties; console.log(`M${mag} — ${place}`); }); // Your Sertone handles routing, billing, and settlement automatically. // Check your balance in the Finance tab of your web console.

# Python — standard requests library # pip install requests # SERVICE_UUID: copy from your catalog. YOUR_CONSUMER_SECRET: from Settings tab. import requests r = requests.post('https://localhost:3000/internal/call', headers={'Authorization': 'Bearer YOUR_CONSUMER_SECRET'}, json={ 'api_id_public': 'SERVICE_UUID', 'path': '/v1/earthquakes/recent', 'method': 'GET', 'params': {'format': 'geojson', 'minmagnitude': '5.0', 'limit': '5'}, }) r.raise_for_status() for feature in r.json()["features"]: p = feature["properties"] print(f"M{p['mag']} — {p['place']}") # Output: # M5.4 — 127km SSE of Kamchatka # M5.1 — Southern Mid-Atlantic Ridge # M5.3 — off the coast of Oregon

Replicate This on Your Raspberry Pi

This exact demo — an earthquake data endpoint earning per-call revenue — can run on a Raspberry Pi 4 with 4 GB of RAM. You need Docker, an internet connection, and about five minutes.

Install Docker on your Raspberry Pi

Official one-liner. Works on Raspberry Pi OS (64-bit) and Ubuntu for Pi.

$ curl -fsSL https://get.docker.com | sh
$ sudo usermod -aG docker $USER
$ newgrp docker

Start your Sertone

The container auto-generates a wallet, registers on the network, and starts listening. Your Sertone gets a unique identity that persists across restarts.

$ docker run -d \
  --name sertone \
  -p 3000:3000 \
  -p 3001:3001 \
  -v sertone-data:/data \
  sertone/wrapper:latest

Data (keys, config, DB) is in the sertone-data volume — never deleted when the container restarts.

Register your API

Open your Sertone web console and register your service:

Go to your web console (https://localhost:3002/panel)
Click "Register" in the My APIs section
Select "API Service"
Fill in your service name, description, and price
Upload your OpenAPI spec or let Sertone scan your server
Click "Register" - your service is live on the network

Call your own API

Your service is now discoverable on the Sertone Global Network. Other users can find it in their catalog, call it, and you earn USDC on every request - settled automatically.

$ # From any Sertone control center worldwide:
curl -X POST https://localhost:3000/internal/call \
  -H "Authorization: Bearer YOUR_CONSUMER_SECRET" \
  -d '{"api_id_public":"SERVICE_UUID","path":"/v1/earthquakes/recent","method":"GET"}'

Expose it to the internet (optional)

For other Sertone instances to reach you, forward port 3001 on your router, or use any tunnel (Cloudflare Tunnel, ngrok, etc.). Your Sertone uses its wallet address as its identity — no domain name required.

Explore More Demos

GraphQL Demo Smart Contract Streaming Cross-Geography