How Cross-Geography Routing Works
Control Center
Control Center
New York to Paris in under 100ms. No central server — routed through the Sertone Global Network, paid automatically.
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
Why Cross-Geography Matters
Traditional API marketplaces route every call through a central server. That server becomes a bottleneck, a single point of failure, and a data surveillance point. Sertone eliminates the middleman: consumer and owner establish a direct encrypted connection, regardless of where they are in the world.
In this demo, the API owner's Sertone runs in New York, US, and the consumer's Sertone runs in London, UK. Despite crossing international borders, API calls complete in under 100ms — because there's no third-party server adding latency in the middle.
This architecture is ideal for latency-sensitive applications (trading, IoT, gaming), data sovereignty requirements (data never touches a third country), and enterprise deployments where compliance mandates direct data flows between known endpoints.
Live Demo — Run All 6 Protocols Across Borders
Multi-Protocol Latency Test
Run all 6 protocol APIs simultaneously from London to New York. See real latencies for each protocol on the map.
Code Samples
# Call REST API via your local Sertone wrapper
$ curl -w "\nLatency: %{time_total}s\n" \
-X POST https://localhost:3000/internal/call \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_CONSUMER_SECRET" \
-d '{"api_id_public": "bb-webhook-receiver", "method": "GET", "path": "/status"}'
# Run all 6 protocols in parallel
$ for api in bb-webhook-receiver bb-graphql bb-soap bb-xmlrpc bb-sse-ticker bb-jsonrpc; do
curl -s -o /dev/null -w "$api: %{time_total}s\n" \
-X POST https://localhost:3000/internal/call \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_CONSUMER_SECRET" \
-d "{\"api_id_public\": \"$api\", \"method\": \"GET\", \"path\": \"/\"}" &
done
wait// JavaScript — parallel cross-geography calls
const protocols = [
{ name: 'REST', api_id_public: 'bb-webhook-receiver', path: '/status' },
{ name: 'GraphQL', api_id_public: 'bb-graphql', path: '/', params: { query: '{ users { id } }' } },
{ name: 'SOAP', api_id_public: 'bb-soap', path: '/balance' },
{ name: 'XML-RPC', api_id_public: 'bb-xmlrpc', path: '/' },
{ name: 'SSE', api_id_public: 'bb-sse-ticker', path: '/quote/AAPL' },
{ name: 'JSON-RPC', api_id_public: 'bb-jsonrpc', path: '/' }
];
const results = await Promise.all(
protocols.map(async (p) => {
const start = performance.now();
const res = await fetch('https://localhost:3000/internal/call', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': 'Bearer YOUR_CONSUMER_SECRET'
},
body: JSON.stringify({ api_id_public: p.api_id_public, method: 'GET', path: p.path, params: p.params })
});
return { name: p.name, latency: Math.round(performance.now() - start), status: res.status };
})
);
results.forEach(r => console.log(`${r.name}: ${r.latency}ms (HTTP ${r.status})`));# Python — parallel cross-geography latency test
import asyncio
import aiohttp
import time
protocols = [
("REST", "bb-webhook-receiver", "/status", {}),
("GraphQL", "bb-graphql", "/", {"query": "{ users { id } }"}),
("SOAP", "bb-soap", "/balance", {}),
("XML-RPC", "bb-xmlrpc", "/", {}),
("SSE", "bb-sse-ticker", "/quote/AAPL", {}),
("JSON-RPC", "bb-jsonrpc", "/", {}),
]
async def call(session, name, api_id, path, params):
start = time.monotonic()
async with session.post(
"https://localhost:3000/internal/call",
json={"api_id_public": api_id, "method": "GET", "path": path, "params": params},
headers={"Authorization": "Bearer YOUR_CONSUMER_SECRET"}
) as resp:
ms = round((time.monotonic() - start) * 1000)
return f"{name}: {ms}ms (HTTP {resp.status})"
async def main():
async with aiohttp.ClientSession() as s:
tasks = [call(s, *p) for p in protocols]
for result in await asyncio.gather(*tasks):
print(result)
asyncio.run(main())Deploy Globally in Minutes
Run the Docker Container
Pull and run the free Sertone wrapper on your own infrastructure. One command sets everything up.
docker run -d --name sertone \
-p 3000-3003:3000-3003 -p 3005-3006:3005-3006 \
-v sertone-data:/app/data \
sertone/wrapper:latestOpen the Web Console
Navigate to https://localhost:3002/panel to access your Sertone control center. Create your account and connect your wallet on first launch.
Browse the Catalog
Click Catalog & SDKs in the sidebar. Search for APIs, try them in demo mode (free), then switch to production when ready.
Make Your First Call
Copy your consumer secret from Settings > Security, then use the code samples above to call any API from your own code.