Join the waiting listJoin
Products
Company
About TelyneWho operates the platform. White labelSell under your own brand. Who it is forSix kinds of business.
Join the waiting list Sign in Explore the platform
Home/Capabilities/Developer platform/Sandbox

A telecom API sandbox
that works before you are verified

sk_test_ keys work from the first minute, before any verification, and simulated resources behave exactly like live ones because the sandbox mocks from the same specification the server validates against.

Start in the sandbox See how it works

Sandbox profiles are simulated and cost nothing. No card, no commitment.

Join the waiting list for production access

Take the key. Start calling.

Five things that are true before anybody has checked who you are.

KEY

sk_test_

VERIFICATION

Not required

RESOURCES

Simulated

MOCKED FROM

The OpenAPI spec

COST

None
Your test accountYour key, your calls, your mistakes
sk_test_…unverified · free
MOCKED FROMthe published spec
BEHAVIOURas live

# The first call, with no account review
POST /v1/esim  { "key": "sk_test_", "verified": false, "resources": "simulated", "source": "openapi", "cost": 0 }

BEFORE VERIFICATION

The usual order is backwards.

Sign, integrate, then discover. This inverts it.

NOW

Take a test key

It is on the dashboard. No verification, no review, nothing to request.

MIN

Make a call

Time to first call is minutes, because there is nothing between you and the endpoint.

BUILD

Build the integration

Against the real API shape, with the real error shapes and the real events.

THEN

Decide

Having seen whether it fits, rather than having committed before you could.

Nothing about the integration changes when the key does.

WHO IT IS FOR

For anyone who has integrated first and found out later

Telecom procurement usually puts the contract before the code. That order suits the supplier and nobody else.

Teams evaluatingProve it fits before anybody signs anything.
Teams with procurementBring a working integration to the meeting rather than a proposal.
Teams testing failureDrive the error paths deliberately, which is the half nobody gets to rehearse.
AgenciesBuild a client's integration before the client has an account.
No verificationsk_test_ works first
No cardNothing to enter
No expiryTest keys do not lapse
No reworkSame call, different key

Build first, decide second. Take a test key today and send a real call, at no cost.

Start in the sandbox Join the waiting list

WHAT YOU GET

Simulated resources that behave exactly like live ones

The sandbox mocks from the published specification, which is the same one the server validates against and the SDKs are generated from.

THE CAPABILITY
Keys
sk_test_ works before any verification. It reaches simulated resources and cannot reach live ones.
Behaviour
Objects, validation, errors and events are the same. What differs is that nothing is carried on a network.
Mocking
From the published OpenAPI specification, so a sandbox response and a live response cannot disagree.
Cost
Nothing is rated and nothing is invoiced. There is no bill to be surprised by.
Events
Webhooks fire on the same transitions, to your endpoint, in the same envelope.
BUILDING ON IT
Environments
One key per environment, and the platform enforces the boundary rather than trusting you to.
Retries
Idempotency behaves as it does in production, so a retry can be rehearsed rather than discovered.
Errors
One shape everywhere: a type, a code, a message, the parameter at fault and a link. Never a bare 500 with a stack trace.
Reference
One published OpenAPI specification. The server validates against it, the SDKs are generated from it and the sandbox mocks from it.

WORKS WITH

Switch on the next one the same way

Nothing new to sign and nothing new to integrate. The same call with a different noun.

Test dataWhat to drive against a simulated resource. API keysThe prefix that keeps the two apart. API explorerCalls without writing any code yet.

QUESTIONS

Sandbox on Telyne

Do I need to be verified to use it?

No. sk_test_ keys work from the first minute, before any verification. That is deliberate: nobody should have to be approved before they can find out whether the API fits.

How close is it to production?

The objects, the validation, the errors and the events are the same, because the sandbox mocks from the same published specification the server validates against. What differs is that resources are simulated rather than carried.

Does it cost anything?

No. Nothing is rated and nothing is invoiced. There is no card to enter and nothing to pay.

Can I test failures as well as successes?

Yes, and you should. The error shapes are the same, and usage can be driven against a simulated resource so thresholds, caps and suspensions all fire as they will in production.

What changes when I go live?

The key. The integration you built is the one you ship, which is the whole point of building it first.

Join

Take a test key before anybody has verified anything

No approval step and nothing to sign. The sandbox is open now, and production access opens in the order requests arrive.

One email at launch. Nothing else, and unsubscribe in one click.

We send a link to confirm the address. Unconfirmed addresses are deleted after 30 days.

Complex requirement or an existing estate to move? Talk to us.