LOAN4BANK
Developers
LOAN4BANK
Dashboard
Guide

5-minute Quick Start

Est. time to first API call · 5 minutes
Step 01 · 30 sec
Create an account and get an API key

Grab an instant sandbox key (no signup) or register a permanent Starter/Growth account on the marketplace to get both live and sandbox keys.

# One-click sandbox key — free, no signup
curl -X POST 'https://api.loan4bank.com/v3/marketplace/sandbox/quick-key' | jq .sandbox_key
Step 02 · 30 sec
Choose sandbox or live environment

Sandbox keys are prefixed `l4b_sandbox_…` and use mock data safe for CI. Live keys start with `l4b_live_…` and hit production partners. Base URL is identical — only the key changes.

# Same URL, different key — the platform routes automatically
BASE=https://api.loan4bank.com/v3
export L4B_API_KEY='l4b_sandbox_…' # or l4b_live_…
Step 03 · 60 sec
Make your first test API call

Every endpoint requires `X-API-Key`. This EMI-calculator call works with a Free-plan sandbox key out of the box.

curl -X POST "$BASE/marketplace/v1/emi-calculator" \
  -H "X-API-Key: $L4B_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"principal":1000000,"annual_rate_pct":10.5,"tenure_months":60}'
Step 04 · 60 sec
Handle responses and errors

All responses follow `{status, message, data}`. Non-2xx codes carry a `detail` field with the human-readable reason. See the Errors page for the full L4B-XXX code table.

// Standard success
{ "status": "SUCCESS", "message": "ok", "data": { "emi": 21493.9 } }

// Plan gate (402)
{ "detail": "This API requires the 'starter' plan or higher." }

// Rate-limit (429)  → back off Retry-After seconds
{ "detail": "Rate-limited (60 / minute burst)." }
Step 05 · 2 min
Go-live checklist

Before flipping the switch from sandbox → live keys in production:

  • Rotate any hard-coded sandbox keys — never ship them.
  • Move `L4B_API_KEY` to your secret manager (Vault, SSM, Doppler).
  • Register at least one webhook endpoint with signature verification.
  • Add retry-with-backoff on 429 and 5xx responses.
  • Wire the `rate_limit.hit` and `quota.exhausted` webhook events into your on-call alerts.
  • Subscribe to the status page for the endpoints you consume.

Video walkthrough

Video coming soon · in the meantime the steps above cover the exact flow the walkthrough will show.

What's next?

Reference
Explore all 8 APIs →
Async
Wire up webhooks →
Robustness
Handle every error code →
Client libs
Grab an SDK →

Everything you need to know before your first LOAN4BANK API call

The LOAN4BANK API is a single JSON-over-HTTPS surface that exposes India's regulated financial rails as clean, batteries-included endpoints — loan origination, KYC and video-KYC, credit-decisioning, EMI and interest computations, real-time gold-loan pricing, wallet and BBPS payments, corporate rewards, referrals and analytics. Everything is versioned under `/v1`, authenticated with a single `X-API-Key`, and returns predictable `{status, message, data}` envelopes so the same client library can call every endpoint without special-casing.

You do not need a company, a bank tie-up or a signed NDA to start building. The one-click sandbox flow issues a scoped key that hits fully-instrumented mock data — the same request and response shapes as production, but every partner call is replaced with deterministic fixtures. That means you can wire an entire loan-application UI end-to-end, run it in CI, and demo it to internal stakeholders before you ever apply for a live key. When you're ready to go live, swap the key prefix from `l4b_sandbox_` to `l4b_live_` and you're done — the base URL, request shapes, and error contracts are byte-identical.

For production integrations we strongly recommend routing calls through the official SDK for your language (JavaScript, TypeScript, Python, PHP, Java, Go) rather than raw `fetch`. The SDKs handle exponential-backoff retries on 429 and 5xx, HMAC signing for the endpoints that require it, streaming for long-running video-KYC operations, and typed responses so your compiler catches breaking changes at build time. All SDKs ship with the same version cadence as the API itself and are released within 24 hours of a MINOR bump.

Every step in this quick-start maps to a chapter in the API reference: Step 3 (first request) corresponds to `POST /v1/marketplace/v1/emi-calculator`, Step 4 (error handling) links to the L4B-XXX code table on the Errors page, and Step 5 (go-live) is expanded into the Production Readiness checklist under Support. Follow the chapters in order and you'll ship a live integration inside a business day.

Frequently asked questions

How long does it take to build an integration with LOAN4BANK APIs?
A typical single-product integration — say, a Personal Loan quote widget on a partner site — takes about half a day. That covers grabbing a sandbox key, wiring EMI + eligibility + apply endpoints, verifying with the sandbox fixtures, and swapping in a live key. Multi-product integrations that also include KYC and webhooks usually finish inside 3–5 engineering days.
Do I need to sign a partnership agreement before using the sandbox?
No. The sandbox is completely self-serve — one click issues a scoped key that hits mock partners with the same response shapes as production. Signing a commercial agreement is only required once you're ready to move to live keys and route real customer traffic.
What is the difference between sandbox and live LOAN4BANK API keys?
Sandbox keys (prefix l4b_sandbox_) hit mock partner data with deterministic fixtures — safe for CI and demos, but no real loans are booked. Live keys (prefix l4b_live_) route to the actual partner banks and NBFCs, real KYC providers, and real payment rails. The base URL and every endpoint are identical, so you can promote code from sandbox to live without any refactor.
Which programming languages does LOAN4BANK officially support?
Official SDKs are shipped for JavaScript, TypeScript, Python, PHP, Java and Go. Community SDKs exist for Ruby and .NET. If you're on any other stack, the REST API is straightforward to call directly — every endpoint is documented with a curl sample in the API reference.
How do I test LOAN4BANK webhooks locally during development?
Point the webhook URL in your developer account at an ngrok or Cloudflare Tunnel that exposes your local server. The sandbox emits every webhook event on a fixed cadence and includes a Replay button on each delivery row so you can re-fire an event as many times as your test needs.

Ready to graduate from Quick Start? The API Reference has every endpoint's request and response schema, and the SDK pages have copy-paste snippets for the language you already ship in.