Demos › Cross-Geography Network

New York calls Paris

Response in under 100ms. No central server in the data path. Routed through the Sertone Global Network — proprietary fully encrypted protocol. Payment automatic.

Network Topology

Four Nodes, Four Continents

The demo network. All node names are internal labels — no real IP addresses or cloud providers are exposed.

Request Response Sertone New York Sertone Paris Sertone (London) Media Relay (Tokyo) 47–98ms
Sertone Node
New York
Consumer's Sertone
Sertone Node
Paris
API owner's Sertone
Sertone Node
London
Another Sertone node
Media Relay
Anywhere
Video relay node
How This Works

The Call Path

Consumer Premises
Your Sertone
Control Center
New York
▼ 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
Paris

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.

Try It

Simulate a Cross-Geography Call

Sertone Global Network — New York → Paris
Waiting
Select nodes and click Run Demo to trace the call
Live call through the Sertone Global Network. Install your own Sertone to make unlimited calls.
Latency Reference

Typical Network Latencies

Round-trip time for a typical Sertone call between nodes. Includes TLS handshake overhead on first call; persistent connections are faster.

Route Typical RTT
New York → Paris 47–98ms
New York → London 42–85ms
Paris → London 8–18ms
New York → Tokyo 110–160ms
Paris → Tokyo 95–140ms
Same city 2–8ms
What "No Central Server" Means

The Path Is Direct

Traditional API marketplaces route every call through their own servers. That adds latency, creates a single point of failure, and means they can read your traffic.

In Sertone, discovery uses the catalog to find the API owner's Sertone address. After that, every call is routed through the Sertone Global Network using the network's proprietary encrypted protocol.

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

Privacy guarantee: The only parties who see the API request are the consumer's Sertone and the owner's Sertone. No relay, no Sertone server, no log aggregator.

Payment happens asynchronously — it does not block the API response. The payment and the data travel independently.

Settlement

What Happens After the Call

1

Consumer sends signed request

The consumer's Sertone node (New York) signs the request with its wallet private key. The signature proves the request origin without revealing the key.

2

Owner's node responds

The API owner's Sertone node (Paris) verifies the signature, serves the API response, and signs a receipt. The data is back in New York within ~70ms.

3

Receipts submitted for settlement

Both Sertone instances submit receipts to the SertoneRouter smart contract. This happens in the background — the consumer does not wait for it.

4

USDC transferred automatically

The contract verifies both receipts, deducts the consumer's pre-funded balance, and credits the owner's wallet. 5% protocol fee is deducted from the owner's payout. Fully automated.

For Consumers

How to use this service

Any developer worldwide can call services across the globe from their own Sertone control center. Here is the complete flow from installation to first cross-geography call:

1

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
2

Browse the catalog

Open your web console at https://localhost:3002/panel. Go to the Catalog tab. Services from all geographies appear in the same list -- Paris, Tokyo, Sydney, wherever the owner runs their control center.

3

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.

4

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.

5

Call it from your code

Copy your consumer secret from Settings. Use the service UUID from the catalog. Your control center routes the request through the Sertone Global Network to the owner's control center in Paris, Tokyo, or anywhere else:

$ 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/weather/current", "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.

6

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.

Code Samples

Calling an API in Paris From New York

# From New York — call an API whose owner's Sertone is in Paris # SERVICE_UUID: copy from your catalog. YOUR_CONSUMER_SECRET: from Settings tab. # Your local Sertone handles all routing — zero geography awareness needed. $ 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": "/forecast", "method": "GET", "params": {"latitude": "48.8566", "longitude": "2.3522", "current_weather": "true"}}' # Response arrives from owner's Sertone (Paris) in ~70ms { "current_weather": { "temperature": 14.2, "windspeed": 18.5, "weathercode": 1 }, "_sertone": { "consumer_node": "New York", "owner_node": "Paris", "latency_ms": 68, "settled": true } }
// JavaScript — your Sertone in New York, owner's Sertone in Paris // SERVICE_UUID: copy from your catalog. YOUR_CONSUMER_SECRET: from Settings tab. const t0 = Date.now(); const res = 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: '/forecast', method: 'GET', params: { latitude: '48.8566', longitude: '2.3522', current_weather: 'true' }, }), }); const data = await res.json(); const elapsed = Date.now() - t0; console.log(`Paris weather: ${data.current_weather.temperature}°C`); console.log(`Round trip: ${elapsed}ms (NY → Paris → NY)`); // The Sertone resolved the owner's address from the catalog, // routed the request through the Sertone Global Network, and handled settlement automatically.
# Python — measure the actual cross-Atlantic latency # SERVICE_UUID: copy from your catalog. YOUR_CONSUMER_SECRET: from Settings tab. import requests, time t0 = time.monotonic() r = requests.post( "https://localhost:3000/internal/call", headers={"Authorization": "Bearer YOUR_CONSUMER_SECRET"}, json={ "api_id_public": "SERVICE_UUID", "path": "/forecast", "method": "GET", "params": {"latitude": "48.8566", "longitude": "2.3522", "current_weather": "true"}, }, ) elapsed_ms = (time.monotonic() - t0) * 1000 data = r.json() print(f"Temp in Paris: {data['current_weather']['temperature']}°C") print(f"Round trip: {elapsed_ms:.0f}ms (NY → Paris → NY)")

Replicate With Two Raspberry Pis

You do not need Sertone instances in different countries to test network routing. Two Raspberry Pis on the same LAN demonstrate the full protocol — just with 1ms instead of 70ms latency.

1

Start Sertone A (the "owner" in Paris)

pi-a $ docker run -d --name sertone-owner \ -p 3000:3000 -p 3001:3001 \ -v sertone-owner:/data \ sertone/wrapper:latest # Note the wallet address from the logs: pi-a $ docker logs sertone-owner | grep "wallet" # Wallet address: 0xABC...DEF
2

Register an API on Sertone A

pi-a $ curl -X POST http://localhost:3001/api/register \ -H "Content-Type: application/json" \ -d '{"name":"Weather Pi-A","endpoint":"https://api.open-meteo.com/v1", "price_usdc":"0.0001","description":"Weather from Pi-A"}'
3

Start Sertone B (the "consumer" in New York) on the second Pi

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

Call Sertone A's API from Sertone B

Sertone B discovers Sertone A via the catalog and connects directly. Payment flows to Sertone A's wallet automatically.

pi-b $ curl -X POST https://localhost:3000/internal/call \ -H "Authorization: Bearer YOUR_CONSUMER_SECRET" \ -d '{"api_id_public":"SERVICE_UUID","path":"/forecast","method":"GET", "params":{"latitude":"48.85","longitude":"2.35"}}' # Response from Sertone A, routed through the Sertone Global Network, paid automatically.

Explore More Demos

REST API GraphQL Smart Contract Streaming