Demos › Cross-Geography Network

New York calls Paris

Response in under 100ms. No central server in the data path. Routed through the Opsalis 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 Opsalis New York Opsalis Paris Opsalis (London) Media Relay (Tokyo) 47–98ms
Opsalis Node
New York
Consumer's Opsalis
Opsalis Node
Paris
API owner's Opsalis
Opsalis Node
London
Another Opsalis node
Media Relay
Anywhere
Video relay node
How This Works

The Call Path

Consumer Premises
Your Opsalis
Control Center
New York
▼ Request ▲ Response
Opsalis Global Network
🔒 Encrypted 🔗 Automatic Payment 🌐 5 Delivery Methods
Proprietary fully encrypted protocol with automatic payment settlement
▼ Request ▲ Response
Owner Premises
Their Opsalis
Control Center
Paris

What is the Opsalis 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 Opsalis 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-opsalis -p 3000:3000 -p 3002:3002 opsalis/wrapper:latest

The Opsalis 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

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

Typical Network Latencies

Round-trip time for a typical Opsalis 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 Opsalis, discovery uses the catalog to find the API owner's Opsalis address. After that, every call is routed through the Opsalis Global Network using the network's proprietary encrypted protocol.

The Opsalis 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 Opsalis and the owner's Opsalis. No relay, no Opsalis 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 Opsalis 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 Opsalis 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 Opsalis instances submit receipts to the OpsalisRouter 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 Opsalis control center. Here is the complete flow from installation to first cross-geography call:

1

Install your Opsalis control center

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

$ docker run -d --name my-opsalis -p 3000:3000 -p 3002:3002 opsalis/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 Opsalis 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 Opsalis is in Paris # SERVICE_UUID: copy from your catalog. YOUR_CONSUMER_SECRET: from Settings tab. # Your local Opsalis 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 Opsalis (Paris) in ~70ms { "current_weather": { "temperature": 14.2, "windspeed": 18.5, "weathercode": 1 }, "_opsalis": { "consumer_node": "New York", "owner_node": "Paris", "latency_ms": 68, "settled": true } }
// JavaScript — your Opsalis in New York, owner's Opsalis 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 Opsalis resolved the owner's address from the catalog, // routed the request through the Opsalis 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 Opsalis 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 Opsalis A (the "owner" in Paris)

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

Register an API on Opsalis 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 Opsalis B (the "consumer" in New York) on the second Pi

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

Call Opsalis A's API from Opsalis B

Opsalis B discovers Opsalis A via the catalog and connects directly. Payment flows to Opsalis 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 Opsalis A, routed through the Opsalis Global Network, paid automatically.

Explore More Demos

REST API GraphQL Smart Contract Streaming