Introduction

Interbank Settlement Protocol (ISP) is the settlement layer for the stablecoin economy — infrastructure that lets banks, fintechs and regulated institutions settle value instantly on stablecoin rails, replacing slow correspondent banking with programmable, always-on settlement.

What is ISP

Traditional cross-border settlement routes a payment through a chain of correspondent banks. Each hop adds delay, cost and counterparty risk, and the whole system closes outside banking hours. ISP replaces that chain with a single settlement fabric: a payment is initiated through one API, screened for compliance, settled atomically on stablecoin rails, and confirmed with deterministic finality — typically in one to two seconds.

Institutions integrate once and reach every other counterparty on the network, in any supported corridor, at any time of day.

Key capabilities

How settlement works

At a high level, every settlement moves through five stages. The settlement lifecycle covers each in depth.

Where to go next

Quickstart

Go from zero to a settled transaction in four steps. This guide uses the Node.js SDK against the test-net — no real funds move.

Prerequisites

1 · Install the SDK

# npm
npm install @isp/sdk

# or pnpm / yarn
pnpm add @isp/sdk

2 · Authenticate

Initialize the client with your test-net key. Keep secret keys server-side — never ship them to a browser.

import { ISP } from '@isp/sdk';

const isp = new ISP({
  apiKey: process.env.ISP_API_KEY,
  env: 'test',   // 'test' | 'live'
});

3 · Create a settlement

Reference two registered counterparties, an amount and an asset. The call resolves once finality is reached.

const settlement = await isp.settlements.create({
  amount:   '2500000.00',
  asset:    'USDC',
  from:     'cp_meridian',
  to:       'cp_nordbank',
  corridor: 'US-DE',
});

console.log(settlement.id, settlement.status);
// ISP-48231 settled

4 · Track the result

Retrieve a settlement any time, or subscribe to webhooks to receive status changes as they happen.

const s = await isp.settlements.retrieve('ISP-48231');

console.log(s.finalityMs); // 1420

Next steps

Authentication

The ISP API authenticates every request with a bearer token. Keys are scoped to an environment and an institution, and can be rotated at any time.

API keys

Each key has a prefix that tells you its type at a glance. Publishable keys are safe to expose; secret keys must stay server-side.

Environments

The test-net mirrors production exactly but moves no real value. Point at the right base URL for each environment.

Making authenticated requests

Pass your secret key as a bearer token in the Authorization header.

curl https://api.interbank.settlement/v1/settlements \
  -H "Authorization: Bearer sk_live_..." \
  -H "Content-Type: application/json"

Rotating keys

Create a new key before revoking the old one to rotate without downtime. Both keys stay valid during the overlap window, so you can roll deployments gradually. Revoke the previous key once traffic has fully moved over.

Security best practices

Architecture

ISP is a modular settlement fabric. Each module owns one responsibility and communicates over internal, authenticated channels — so institutions integrate against a single API while the protocol handles compliance, liquidity and finality underneath.

Request flow

A settlement request travels left to right. Every stage writes to the immutable ledger before handing off to the next.

Core modules

Availability

The protocol runs active-active across multiple regions with no scheduled downtime, targeting 99.99% availability. Settlement continues 24 / 7 / 365, independent of any single banking calendar or market's operating hours.

Settlement lifecycle

Every settlement moves through a well-defined set of states. Understanding them lets you build reliable tracking, reconciliation and retry logic.

Settlement states

Finality & timing

ISP reaches deterministic finality — once a settlement is settled it can never be reversed. There are no probabilistic confirmation windows; the median end-to-end time is 1–2 seconds.

Idempotency & retries

Pass an Idempotency-Key header on create requests. Retrying with the same key returns the original settlement instead of creating a duplicate — safe against network failures.

curl -X POST .../v1/settlements \
  -H "Idempotency-Key: a1b2c3d4-e5f6" \
  -H "Authorization: Bearer sk_live_..."

Core concepts

The vocabulary you'll use across the protocol and API. These terms appear throughout the docs and in every API response.

Glossary

API overview

The ISP API is a REST API over HTTPS. It uses predictable resource-oriented URLs, returns JSON, and relies on standard HTTP verbs, status codes and authentication.

Base URL

Use the sandbox host for test-net traffic — see Authentication.

Versioning

The version is pinned in the URL path (/v1). Backwards-incompatible changes ship under a new version; additive changes — new fields, new endpoints — roll out within the current version without notice, so write tolerant parsers.

Requests & responses

Send JSON bodies with Content-Type: application/json. Monetary amounts are strings to preserve precision. Timestamps are ISO 8601 in UTC.

{
  "id": "ISP-48231",
  "object": "settlement",
  "amount": "2500000.00",
  "asset": "USDC",
  "status": "settled",
  "created_at": "2026-07-03T09:12:04Z"
}

Pagination

List endpoints are cursor-paginated. Pass limit (max 100) and starting_after with the last object's ID to page forward. The response includes has_more.

Rate limits

Exceeding the limit returns 429. Back off using the Retry-After header.

Settlements

Create, retrieve and list settlements — the core object of the API.

Create a settlement

Body parameters:

# request
POST /v1/settlements
{ "amount":"2500000.00", "asset":"USDC",
  "from":"cp_meridian", "to":"cp_nordbank" }

# response
{ "id":"ISP-48231", "status":"settled",
  "finality_ms":1420 }

List settlements

Filter with query parameters. All are optional.

Counterparties

Register and manage the institutions you settle with. A counterparty must be onboarded and screened before it can send or receive value.

Register a counterparty

Webhooks

Webhooks push settlement events to your endpoint in real time, so you never have to poll. Register a URL in the dashboard and subscribe to the events you care about.

Events

Payload

{
  "event": "settlement.settled",
  "id": "evt_9f2a",
  "data": {
    "id": "ISP-48231",
    "corridor": "US-DE",
    "finality_ms": 1420
  }
}

Verifying signatures

Each delivery is signed with an ISP-Signature header. Verify it against your signing secret before trusting the event.

const ok = isp.webhooks.verify({
  payload: req.rawBody,
  signature: req.headers['isp-signature'],
  secret: process.env.ISP_WEBHOOK_SECRET,
});

if (!ok) return res.status(400).end();

Retries & best practices

Errors & status codes

ISP uses conventional HTTP status codes and returns a structured error object so your integration can respond programmatically.

Error object

{
  "error": {
    "type": "invalid_request",
    "code": "insufficient_liquidity",
    "message": "Not enough liquidity in corridor US-DE.",
    "param": "amount"
  }
}

HTTP status codes

Common error codes

SDKs & libraries

Official SDKs wrap authentication, retries, pagination and webhook verification so you can focus on your settlement logic.

Official SDKs

Python example

import isp

client = isp.Client(api_key=os.environ["ISP_API_KEY"])

s = client.settlements.create(
    amount="2500000.00",
    asset="USDC",
    from_="cp_meridian",
    to="cp_nordbank",
)
print(s.id, s.status)

Go example

client := isp.New(os.Getenv("ISP_API_KEY"))

s, err := client.Settlements.Create(&isp.SettlementParams{
    Amount: "2500000.00",
    Asset:  "USDC",
    From:   "cp_meridian",
    To:     "cp_nordbank",
})

Security & compliance

ISP is built for regulated institutions. Compliance and security are native to the protocol, not bolted on — every settlement is screened, encrypted and recorded.

Compliance

Data protection

Certifications

ISP operates to institutional assurance standards. Reports are available under NDA to whitelisted partners.