One request places a real phone call.

A result, not a recording.

When the call ends, that call carries the whole record: the transcript, a summary of what happened, and the signals pulled out of it — how interested they were, what they objected to, when to call back, and how they reacted to being told they were speaking with an AI. Nobody has to listen to anything.

You get there by polling GET /api/v1/calls/:id until status is completed or failed. Reads are unlimited, never rate limited, and never counted against anything — poll as often as you like. A call runs until it's finished or until the ten-minute cap ends it, whichever comes first.

You could assemble this yourself. It's a voice-orchestration account, a SIP trunk, a phone number that survives carrier filtering, a prompt that holds together when someone interrupts it, a webhook that catches the end of the call, a retry path for when that webhook never arrives — and then the part nobody budgets for: turning a raw transcript into interestLevel, objections and callbackTime reliably enough that you'd branch your pipeline on them. That last part is what you're buying. The rest is what you're not operating.

GET /api/v1/calls/123

{
  "status": "completed",
  "transcript": "Hi, is this Sam? ...",
  "summary": "Saw the email, hasn't read it properly. Asked to be called back next week.",
  "extractedSignals": {
    "interestLevel": "medium",
    "objections": ["price / too expensive"],
    "callbackTime": "next week",
    "disclosureReaction": {
      "reaction": "curious",
      "hungUpNearDisclosure": false
    }
  }
}

What stops it spending your money.

Six things stand between a mistake in your code and your balance, and every one of them is already on. There is no safety page to find, no ceiling to set before your first call, and nothing you can forget to switch on. The only way past any of them is to raise it deliberately.

The one doing most of the work is the first. Ringspine commits the money when a call is dialled, not when it hangs up. A loop that goes wrong is therefore spending a balance that has already shrunk, rather than finding out afterwards what it spent. That is how the system is built; it is not a limit you configure.

1. 1.Credit is committed at dial, not at hang-up. The most the call could cost is moved out of your spendable balance the moment it's placed — a hold — and the unused part comes back when the call settles. Twenty calls started in the same minute see each other's money already gone.

2. 2.Every call is dialled with a hard duration cap: ten minutes. The cap goes to the telephony vendor with the call, and the vendor ends the call at it. If your balance can't afford ten minutes, the cap is lowered to what it can. A call cannot outrun your credit.

3. 3.Three of your calls can be in flight at once. The fourth is refused until one of the first three settles. It's a per-organization setting, so it can be raised — deliberately, not by accident.

4. 4.A zero balance refuses the call. Reading your balance always works; placing a call on an empty one does not.

   What a zero balance returns

   402 Payment Required
   
   {
     "error": "Credit balance is 0.0000 EUR. Top up to place calls.",
     "reason": "insufficient-balance"
   }

5. 5.Ringspine only dials destinations it has cleared. Cleared means we have confirmed we're allowed to dial that country and have a number to dial it from. It is not the same as priced: GET /api/v1/rates lists what has a price, several priced countries are not cleared, and a request to one of them is refused before the call is placed rather than failing on the phone. Today, exactly one destination is cleared — Lithuania.

   What an uncleared destination returns

   400 Bad Request
   
   {
     "error": "This destination is not currently available for calling (LT -> DE)."
   }

6. 6.A call whose result never arrives still gets settled. If the end-of-call webhook is lost, a sweep closes the call out at its cap, releases the hold and gives back the concurrency slot — rather than stranding your money and one of your three slots forever.

Two more limits you'll meet before any of the above: 20 requests a minute and 200 placed calls a month by default, both per organization, both raisable. Reads don't count against either.

One country, on purpose.

Ringspine dials Lithuanian numbers, from a real local +370 line. Lithuania is the only destination cleared to dial today. Other countries have prices in the system, but a price is not clearance, and an uncleared destination is refused before the call is placed rather than failing on the phone.

A market gets opened when its calling is legally cleared and its voice has been judged acceptable by a native speaker on a real phone call — not when a vendor's language list says the language is supported. Lithuanian is the harder of our two languages to get right, which is why it's the one that's live.

English and Lithuanian. Set language on counterpartContext; leave it out and the call speaks English.

Ringspine     Labas, čia Alex iš Acme. Kalbate su dirbtinio intelekto
              asistentu, pokalbį įrašome.

The person    Taip, klausau.

Heading toward

Next: calls you can steer while they're running — updating a call's context from what's actually happening in the conversation, not only from what was known when it started. That's the direction, not something a call does today.

After that, more countries — each one opened on the same two conditions as the first.

From here to a placed call.

1. 1

   Sign in with your email.

   A one-time link, no password. Signing in creates your organization and your billing customer — there is no manual step, no sales call, and nobody has to approve you.

2. 2

   Mint your key.

   Dashboard → API keys → Create key. It's shown once, on the screen that creates it, so copy it then. Only a SHA-256 hash is stored — nobody at Ringspine can read your key back to you, and a lost key is replaced rather than recovered.

3. 3

   Top up.

   Card payment from the billing page, €10 minimum. Credit is what calls draw against.

4. 4

   Point the first one at your own phone.

   POST /api/v1/calls with your own number in counterpartContext.phoneNumber. You'll hear exactly what the person on the other end hears — greeting, disclosure, the lot — and the transcript and signals come back the same way they will in production. Nobody's first call should be at a stranger. Or attach the MCP server to Claude and ask for the same thing in plain language.

curl -s -X POST https://ringspine.com/api/v1/calls \
  -H "Authorization: Bearer rs_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "personaContext": { "name": "Alex" },
    "counterpartContext": { "phoneNumber": "+37060000000" },
    "objective": "Ask if they saw the follow-up email and what they thought."
  }'