Quickstart

0Bit is a product suite for crypto payment, liquidity, routing, merchant checkout, and protocol-activity visibility. The safest first integration is not to call every product at once. Start with the surface that owns your workflow, build one server-led loop, then add product-specific depth.

This page is for all 0Bit products. It gives you the shared integration model first, then points you into 0Gate, 0Pools, 0Base, 0Link, or 0Pools Scan depending on what you are building. 0Gate appears as the most concrete starter example because it is the default hosted path for many external integrations, not because Get Started is only about 0Gate.

Choose the product surface

The first production-shaped loop

The important part is ownership. Your server owns your order, user reference, internal workflow id, idempotency key, fulfillment rule, and reconciliation state. 0Bit owns the product object and emits signed status. The browser is allowed to show progress, but it must not be your final accounting source.

Product starter paths

Each product has a different first object and a different completion signal:

Setup values

Use sandbox/test values while building. Secret values stay server-side; publishable and session-scoped values are the only browser-safe values.

OBIT_GATE_API_BASE_URL=https://gate-api-sandbox.0bit.app/v1
OBIT_SECRET_KEY=sk_test_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
NEXT_PUBLIC_OBIT_PUBLISHABLE_KEY=pk_test_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
OBIT_WEBHOOK_SECRET=whsec_test_xxxxxxxxxxxxxxxxxxxxxxxx

Example track: build the first 0Gate flow

The rest of this quickstart uses 0Gate as a concrete example because it exercises the shared 0Bit pattern: server-created object, browser-safe value, hosted user flow, signed webhook, and reconciliation record. If you are integrating 0Pools, 0Base, or 0Link, use the same ownership model and continue into the product quickstart instead of copying the Gate session payload.

1. Create your own record first

Before calling 0Bit, create an order, checkout, account action, or workflow record in your system. Store:

2. Create the session server-side

curl -X POST https://gate-api-sandbox.0bit.app/v1/gate_sessions \
  -H "Authorization: Bearer $OBIT_SECRET_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: 00000000-0000-4000-8000-000000000123" \
  -d '{
    "amount": "100.00",
    "currency": "EUR",
    "return_url": "https://app.partner.example/checkout/done",
    "metadata": {
      "order_id": "order_test_123"
    }
  }'

The response includes a session id and client_secret. Store the session id on your backend. Send only the browser-safe client_secret to the client.

3. Mount the hosted experience

import { GateRamp } from '@0bit/gate/browser';

const ramp = new GateRamp({
  publishableKey: process.env.NEXT_PUBLIC_OBIT_PUBLISHABLE_KEY!,
  clientSecret: session.client_secret,
  environment: 'sandbox',
});

await ramp.mount('#gate-container', {
  onSuccess: ({ txId, sessionId }) => {
    console.log({ txId, sessionId });
  },
  onError: ({ code, message }) => {
    console.warn(code, message);
  },
});

Use browser callbacks for UX only. Show a pending, confirming, or completed screen, but run fulfillment from verified backend state.

4. Verify webhooks

import crypto from 'node:crypto';
import express from 'express';

const app = express();

app.post('/webhooks/0bit', express.raw({ type: 'application/json' }), async (req, res) => {
  const rawBody = req.body.toString('utf8');
  const signature = req.header('Gate-Signature') ?? '';

  if (!verifyGateSignature(rawBody, signature, process.env.OBIT_WEBHOOK_SECRET!)) {
    return res.sendStatus(401);
  }

  const event = JSON.parse(rawBody);
  await storeEventOnce(event.id, event);
  await applyBusinessState(event);
  return res.sendStatus(200);
});

function verifyGateSignature(rawBody: string, header: string, secret: string) {
  const parts = Object.fromEntries(header.split(',').map((part) => part.split('=')));
  const timestamp = Number(parts.t);
  const expected = crypto.createHmac('sha256', secret).update(`${timestamp}.${rawBody}`).digest('hex');
  return crypto.timingSafeEqual(Buffer.from(expected, 'hex'), Buffer.from(parts.v1, 'hex'));
}

What good looks like

Continue