Build token products with API calls, not blockchain ops overhead.

REST API and TypeScript SDK for backend and product teams shipping tokenization. 30+ audited contracts — fungible tokens, NFTs, soulbound credentials, security tokens, governance, vesting, vaults, multisig, token-bound accounts, and Chainlink integrations — without writing Solidity, managing nodes, or owning contract risk.

Create free account — no card required Explore API reference

242public API endpoints

14supported networks

< 200msp95 API latency

30+audited contracts

deploy-token.ts typescript

import { Urblock } from "@urblock/sdk";

const client = new Urblock("sk_live_...");

// deploy an ERC-20 — no Solidity, no node, no wallets to manage
const token = await client.tokens.create({
  name: "Carbon Credit",
  symbol: "CCT",
  standard: "ERC20",
  network: "polygon",
  supply: 1_000_000,
});

// mint to any address — async by default
const tx = await client.transactions.mint(token.id, {
  to: "0xabc...123",
  amount: 5000,
});

// returns immediately. webhook fires on confirmation.
tx.status; // "pending" → "confirmed" via webhook

Why it matters

Less protocol babysitting. More product velocity.

One platform to deploy standards, run async transaction flows, manage compliance, and expose a developer interface your team can build on.

The usual experience

Custom Solidity for every new product request
One reentrancy bug, one integer overflow, one misconfigured access control — and it's an unrecoverable loss
Ops debt around wallets, nonce management, stuck transactions, and webhook retries
Compliance logic split across scripts, dashboards, and docs
Product teams blocked on blockchain specialists for simple launches

With urblock

Launch standards through one API and one SDK
Contract risk stays in independently audited standards — not in your integration. Security-critical code is not your liability.
Get async transaction handling, idempotency, nonce management, and status tracking by default
30+ audited contract primitives across the full tokenization stack — deploy any standard without owning the security surface
Keep your application team shipping without becoming a smart contract shop

API surface

Everything needed to run tokenization as a product surface.

Opinionated where it matters: clean contracts, typed SDKs, async pipelines, tenant isolation, and audited standards. Fewer moving parts. No duct-taping blockchain into your backend.

REST

Predictable public API with typed request and response contracts

Async

Every blockchain operation modeled like real infrastructure: queued, tracked, observable

Typed

TypeScript-first across DTOs, SDK, and backend modules

Audited

Every contract primitive is built on independently audited, battle-tested EVM standards — not custom Solidity. No reentrancy, no overflow, no misconfigured roles. Smart contract bugs are irreversible. Ours live in audited code that has secured billions in assets, not in your integration layer.

Why now

Real-world asset tokenization is entering its infrastructure phase. The protocols are mature, the regulatory space is clarifying, and the competitive window is in who ships product fastest — not who writes the most Solidity.

Developer workflow

From API key to live token flow in three sane steps.

The goal is not to impress with screenshots. The goal is to reduce time-to-first-launch for engineering teams that need something durable enough for production and fast enough for sprint work.

01. Create your base layer

Get an API key, choose a standard, configure a network, and create a token or contract primitive through the API or the SDK.

02. Ship app logic on top

Use your own backend, frontend, or internal systems while urblock handles transaction submission, confirmations, status updates, and webhook delivery.

03. Scale without re-architecting

Expand into governance, vesting, vaults, identity-based compliance, and multi-chain support without rebuilding the platform every quarter.

Under the hood

Every call is a job, not a prayer.

When you call the API, you get a response in under 200ms. The chain work runs in the background. You don't poll — you receive a webhook when the block confirms.

No stuck-transaction war stories. No nonce management. No gas spike incidents at 2am. Every operation moves through the same hardened pipeline: validated, queued, signed, submitted, confirmed, notified.

tx-lifecycle.log runtime

[00:00.000] POST /v1/tokens/tok_abc/mint
[00:00.038] response: { id: "tx_xyz", status: "pending" } // immediate
[00:00.039] job queued → tx-submit
[00:02.814] gas estimated: 52,000 // +20% buffer applied
[00:03.109] tx submitted: 0xd4e5...9f2a
[00:11.723] block confirmed: 47,823,091
[00:11.724] POST https://your-api.com/hooks
[00:11.724] payload: "transaction.confirmed" // HMAC-SHA256 signed

Built for real products

What teams ship with urblock.

Six product categories that become a weekend project instead of a six-month Solidity engagement.

RWA tokenization

Carbon credits, real estate shares, and company equity — issued, transferred, and compliance-managed on-chain.

ERC-20 ERC-3643 Vesting

DAO tooling

Governance tokens, proposal systems, and timelock execution without deploying custom Governor contracts.

Voting ERC-20 Governance Timelock

Loyalty programs

Reward tokens with vesting schedules, redeemable vouchers, and soulbound membership credentials.

ERC-20 EIP-5192 Vesting

NFT marketplaces

Collections with royalties, batch operations, and token-bound accounts that let NFTs own and hold other assets.

ERC-721 ERC-1155 ERC-6551

DeFi vaults

Yield strategies, treasury management, and fund structures on the ERC-4626 standard with multisig control.

ERC-4626 ERC-20 Multisig

Gaming economies

Multi-asset item systems, character NFTs with on-chain inventories, and verifiable randomness for in-game drops.

ERC-1155 ERC-6551 VRF Randomness

Supported standards

A serious tokenization stack, not one contract and a promise.

Start with one standard. Expand into the rest when the product asks for it. No rewrite required.

ERC-20

fungible tokens

Voting ERC-20

delegation + vote weight

ERC-721

NFT collections

ERC-1155

multi-token assets

ERC-3643

T-REX security tokens

ERC-1363

payable token (transferAndCall)

ERC-4626

tokenized vaults

Vesting

release schedules

Governance

proposals + timelock

EIP-5192

soulbound credentials

ERC-6551

token-bound accounts

Multisig

m-of-n on-chain signing

Oracle + VRF

price feeds + randomness

What you ship

Every primitive needed. Nothing you have to build yourself.

+ Fungible tokens, NFT collections, and soulbound credentials with a single API call
+ Compliance-ready security tokens with on-chain identity, investor restrictions, and forced transfer
+ NFTs that own assets and execute transactions via ERC-6551 token-bound accounts
+ On-chain governance with proposals, voting, and timelock execution — no node infrastructure
+ ERC-1363 payable tokens with transferAndCall and approveAndCall for on-transfer hooks
+ Vesting schedules, ERC-4626 vaults, and m-of-n multisig with deterministic addresses
+ Chainlink price feeds and verifiable randomness without managing subscriptions or RPC callbacks

// ready to ship

Tokenization without the blockchain tax. Or the contract risk.

Generate an API key. Call the SDK. Launch on testnet. No Solidity, no node setup, no blockchain hiring plan. Free to start — no credit card.

quick-start.ts 3 steps to live token

// 1. install the sdk
npm install @urblock/sdk

// 2. initialize with your api key
const client = new Urblock("sk_test_...");

// 3. deploy to testnet — done
const token = await client.tokens.create({ standard: "ERC20", network: "amoy" });
// → { id: "tok_...", status: "deployed", contract_address: "0x..." }

Create free account — no card required Read documentation Open faucet

// full api coverage

Tokens

→ ERC-20 with mint / burn / pause
→ Voting token with delegation
→ ERC-1363 payable token (transferAndCall)
→ ERC-3643 security token + compliance
→ Gas-optimised variants

NFTs & Credentials

→ ERC-721 collections + royalties
→ ERC-1155 multi-token + batch mint
→ EIP-5192 soulbound credentials
→ ERC-6551 token-bound accounts

Governance

→ On-chain proposals + voting
→ Configurable quorum + period
→ Timelock execution with delay
→ m-of-n multisig treasury

DeFi Primitives

→ ERC-4626 tokenized vaults
→ Vesting schedules + cliff
→ Verifiable randomness (VRF)
→ On-chain price feeds

Compliance

→ On-chain identity registry
→ Country + balance restrictions
→ Trusted issuer management
→ Forced transfer + recovery

Infrastructure

→ Async pipeline + webhooks
→ HD wallet derivation
→ 14 networks supported
→ Idempotency + retry logic

// Best fit

→ Backend & product engineers
→ Fintech & RWA builders
→ Teams shipping without a blockchain hire
→ Companies needing compliance-grade programmable money

// What you skip

→ Custom Solidity and security audits
→ Nonce hell and stuck transactions at 2am
→ Hand-rolled compliance and identity logic
→ The existential risk of a contract bug you can't roll back

// What you keep

→ Your product logic and UX
→ Your backend and deployment pipeline
→ Your roadmap ownership
→ A clean API surface your team ships against

// Next step

→ Create an account — free, no card
→ Get a test API key from the dashboard
→ Deploy your first token to Amoy testnet
→ Ship to mainnet when you're ready

pricing

One API. Four tiers. Zero lock-in.

Every plan includes REST API, TypeScript SDK, webhooks, and 30+ contract types. Start free, unlock mainnets when you're ready, add T-REX compliance when you need it.

// Sandbox

Free

No card required

Create free account

2,000 tx / month
Testnets only
10 req/s
All 30+ contracts incl. T-REX
REST API + SDK + Webhooks
Ship a proof-of-concept in a weekend

// Starter

$49

/ month

Start building

10,000 tx / month
All 14 mainnets
100 req/s
ERC-20, 721, 1155, 1363, SBT
Governance, Vesting, Vaults
TBA, Chainlink, Multisig
$0.005 / extra tx
No T-REX / compliance