Build financial businesses on Torq

Developer Preview. The documentation and complete integration contract are public. Test applications, credentials, SDK packages, production scopes, and role authority remain controlled.

Torq gives wallets, exchanges, banks, neobanks, and fintech teams one developer platform for tokenized credit. Use canonical product data, typed customer-signed workflows, events, SDKs, and AI context without rebuilding the credit protocol or reconstructing shared state from RPC.

Choose what you want to launch

Every path uses the same governed resources and completion rules. The product experience can be fully yours while Torq supplies the typed credit infrastructure, authority checks, and canonical state behind it.

Launch a complete Earn experience

The shortest secure integration connects the customer's current wallet, loads the complete Earn catalogue, and prepares a reviewed deposit:

const earn = await connectTorqEarn({ publishableKey, deploymentNamespace, wallet, review });
const products = await earn.catalogue();
const completed = await earn.deposit({ wrapperAddress, assetAddress, assets: "1000000" });

The same connection supports the customer across the whole credit lifecycle:

1. Discover assets, markets, vaults, tranches, fees, eligibility, and liquidity.
2. Review the exact deposit terms and sign with the customer's wallet.
3. Show positions, yield, allocations, activity, and current exit conditions.
4. Prepare redemption and wait for canonical final_success.
5. Surface impairment, recovery progress, claims, and separately available distressed-fund options.

An affected position never guarantees fund eligibility, compensation, recovery proceeds, or a claim. Your interface must present those as separate, evidence-backed decisions.

Follow the few-line Earn quickstart, then use the complete credit lifecycle to cover normal servicing, distress, and recovery end to end.

Build and distribute credit products

Torq exposes the product-visible data required to create institutional credit experiences:

• complete assets, markets, credit facilities, vaults, tranches, and funds;
• economics, fees, allocation, liquidity, duration, activity, and share-mobility state;
• wallet positions, eligibility, transaction progress, and freshness evidence;
• typed deposit, redemption, collateral, borrow, repay, and approved role workflows; and
• versioned events, webhooks, reconciliation, and recovery resources.

Use the API reference when you need exact methods, fields, schemas, authentication, and errors. Use the SDK reference when you want typed resources, pagination, retry, workflow preparation, customer signing, and canonical completion.

Integrate with existing financial infrastructure

You do not need to replace your wallet connection, custody model, account system, or product UI. Torq can sit behind an existing customer experience while your application keeps its own identity and relationships.

The use-case playbooks provide end-to-end implementation paths for:

• wallet providers;
• exchanges and custodians;
• neobanks;
• financial service providers;
• yield aggregators;
• crypto lending protocols; and
• asset managers.

Each playbook covers setup, authentication, product discovery, connected-wallet behavior, secure writes, event handling, reconciliation, failure states, and the path from deposit through recovery.

Keep every action secure and explainable

Torq separates product intent from transaction signing:

1. Read current product and wallet state from the canonical API.
2. Ask Torq to prepare one typed workflow.
3. Show the customer the exact network, amount, target, value, and transaction steps.
4. Let the customer-controlled wallet, HSM, or MPC boundary simulate and sign.
5. Register the transaction and wait for canonical final_success.
6. Re-read the affected resources and reconcile every durable event.

Never send private keys or seed phrases to Torq. Never invent a path, address, target, or calldata. A mined receipt is not the final product state.

Add AI without giving it signing authority

The AI and Agents guide provides a compact context pack, retrieval rules, a strict grounding policy, secure workflow boundaries, and evaluation cases. An AI can explain products, retrieve current evidence, and propose a bounded action. It cannot sign, hold reusable wallet proofs, or declare completion before canonical state confirms it.

Start building

1. Choose a use case for the end-to-end product architecture.
2. Run the few-line Earn quickstart for the shortest secure integration.
3. Open a complete code sample for your stack.
4. Inspect every API operation and its endpoint-specific sample response.
5. Review Developer Preview availability before requesting access.