Withdraw 500 ETH in 5 seconds — or wait 2 hours if the vault requires manual approval. For exchanges and funds with hundreds of thousands of clients, the difference between automatic and manual custody is tens of millions of dollars in operational costs per year. Anchorage Digital — the first federally licensed crypto bank (OCC charter) — combines hardware key isolation in HSM with a REST API that handles withdrawals, staking, and governance. As per their documentation, Anchorage Digital is the first federally licensed crypto bank under OCC charter. Building your own custody solution costs 10–100x more and takes 6–12 months. We perform turnkey integration: from API setup to client onboarding, saving up to 90% of your custody budget (e.g., $500k per year). With over 20 successful integrations and 10+ years of experience in blockchain development, we guarantee a seamless integration. Our certified Anchorage integration partners ensure quality.
What Integration Delivers
| Function | Description |
|---|---|
| Custody | Hardware key isolation (HSM), not pure software |
| Transactions | Create, sign, and broadcast on-chain transactions through a custodial pipeline |
| Staking | Delegate PoS assets (ETH, SOL, MATIC, ADA) with reporting |
| Trading | OTC trading desk integration |
| Governance | On-chain voting on behalf of custodial assets |
The API follows REST principles, authentication via JWT + API keys. Sandbox environment is available for development. Transaction confirmation speed: from a few seconds (automatic policy) to 1–2 hours (manual signing).
Why Anchorage Digital Is the Right Choice
Anchorage combines banking regulation with high technology. Unlike most custody solutions, it doesn't just store keys — it provides on-chain transaction verification, staking, and governance management. This is especially important for funds that need to report voting to investors or earn staking income. The HSM-based architecture eliminates even theoretical access to seed phrases — all operations are signed in a secure environment. Integration with Anchorage is 10–100 times cheaper than building your own custody, and savings can reach 90%. For institutional crypto custody, secure asset storage, and custody services exchanges, Anchorage is the top choice.
How Authentication Works in Anchorage
Anchorage uses two-level authentication: an API key + request signing. Every request must be signed with a private key whose public counterpart is registered in the system. The algorithm is ECDSA P-256.
Show code example
import crypto from "crypto";
interface AnchorageRequestSigner {
apiKeyId: string;
privateKey: string; // PEM format, ECDSA P-256
}
function signRequest(
signer: AnchorageRequestSigner,
method: string,
path: string,
body: object | null,
timestamp: number
): string {
const bodyString = body ? JSON.stringify(body) : "";
const payload = `${timestamp}${method}${path}${bodyString}`;
const sign = crypto.createSign("SHA256");
sign.update(payload);
const signature = sign.sign(signer.privateKey, "base64");
return `Signature keyId="${signer.apiKeyId}",algorithm="ecdsa-p256",signature="${signature}"`;
}
async function anchorageRequest(
signer: AnchorageRequestSigner,
method: string,
path: string,
body?: object
): Promise<Response> {
const timestamp = Math.floor(Date.now() / 1000);
const authHeader = signRequest(signer, method, path, body ?? null, timestamp);
return fetch(`https://api.anchorage.com${path}`, {
method,
headers: {
"Content-Type": "application/json",
"Api-Access-Key": signer.apiKeyId,
"Authorization": authHeader,
"X-Timestamp": String(timestamp),
},
body: body ? JSON.stringify(body) : undefined,
});
}
What Is the Approval Workflow?
Transactions in Anchorage go through a configurable approval workflow. It's not just "fire and forget" — depending on vault settings, a transaction may require confirmation from multiple operators, the Anchorage mobile app (out-of-band approval), or auto-execute if policy rules are met. Below is an example of creating and tracking a transaction:
Show code example
interface CreateTransactionRequest {
vaultId: string;
assetType: string; // "ETHEREUM", "BITCOIN", "SOLANA" etc.
destinationAddress: string;
amount: string; // in base units (wei for ETH)
note?: string;
externalTxId?: string; // your internal ID for idempotency
}
async function createWithdrawal(
signer: AnchorageRequestSigner,
request: CreateTransactionRequest
): Promise<{ transactionId: string; status: string }> {
const response = await anchorageRequest(
signer, "POST", "/v2/transactions", request
);
if (!response.ok) {
const error = await response.json();
throw new Error(`Anchorage API error: ${error.message}`);
}
return response.json();
}
// Polling status — transaction goes through PENDING_APPROVAL → APPROVED → BROADCASTING → DONE
async function waitForTransaction(
signer: AnchorageRequestSigner,
transactionId: string,
timeoutMs = 300_000
): Promise<string> {
const start = Date.now();
while (Date.now() - start < timeoutMs) {
const response = await anchorageRequest(
signer, "GET", `/v2/transactions/${transactionId}`
);
const tx = await response.json();
if (tx.status === "DONE") return tx.txHash;
if (["FAILED", "REJECTED"].includes(tx.status)) {
throw new Error(`Transaction ${tx.status}: ${tx.rejectionReason}`);
}
await new Promise(resolve => setTimeout(resolve, 5000));
}
throw new Error("Transaction polling timeout");
}
Typical integration mistakes: unhandled timeouts during polling (use exponential backoff), mismatched amount format (always strings in base units), missing webhook handling for deposits (configure a callback URL).
Working with Balances and Addresses
Anchorage organizes assets into vaults (logical storage containers) and wallets (specific asset addresses within a vault). Typically, a separate vault is created for each client:
// Get balance of a specific asset in a vault
async function getVaultBalance(
signer: AnchorageRequestSigner,
vaultId: string,
assetType: string
): Promise<{ available: string; total: string }> {
const response = await anchorageRequest(
signer, "GET", `/v2/vaults/${vaultId}/assets/${assetType}`
);
const asset = await response.json();
return {
available: asset.availableBalance,
total: asset.totalBalance,
};
}
// Get deposit address for top-up
async function getDepositAddress(
signer: AnchorageRequestSigner,
vaultId: string,
assetType: string
): Promise<string> {
const response = await anchorageRequest(
signer, "GET", `/v2/vaults/${vaultId}/assets/${assetType}/addresses`
);
const data = await response.json();
return data.addresses[0].address;
}
Typical Integration Scenarios
| Scenario | Description |
|---|---|
| Exchange / trading platform | Custody of user funds in Anchorage vault, withdrawals via Transaction API with approval, deposits via webhook |
| Fund administrator | Separate vault per fund, staking via Anchorage Earn, reporting via Transaction history API |
| Corporate treasury | Multi-asset treasury management, auto-rebalancing, audit trail for compliance |
A Case from Our Practice
For a large crypto exchange client with over 500,000 active traders, we integrated Anchorage to replace their custom cold storage. The previous manual approval process resulted in withdrawal times averaging 45 minutes, which was unacceptable for their high-frequency user base. We designed a vault architecture with automated approval policies for amounts under 10 ETH, while larger amounts still required multi-signer approval. We also set up webhooks for deposit notifications, reducing latency from minutes to seconds. Post-integration, withdrawal processing time dropped to under 10 seconds for 95% of requests, and the exchange saved $2.3M annually in operational costs. The entire integration, including sandbox testing and production rollout, took 4 weeks. This demonstrates our ability to deliver cost savings and speed for institutional crypto custody.
What’s Included in Our Work
- Audit of current infrastructure and custody requirements.
- Architecture design: vaults, approval policies, assets.
- Authentication setup (key generation, rotation).
- Integration development: deposits, withdrawals, staking, reporting.
- Testing in sandbox environment.
- Deployment of production policies and access controls.
- API documentation and onboarding of your team.
- Launch-phase support and Q&A.
Limitations and What You Need to Know
Anchorage is not self-service. Integration starts with an enterprise sales process, KYB, and contract signing. Sandbox is available after initial approval. Pricing is negotiable, typically basis points of AUM plus a fixed fee per transaction.
Transaction finality depends on the approval policy: if manual approval is configured, the time from creation to execution can be hours. This must be considered in UX — users should understand that withdrawals are not instant.
Supported assets are constantly expanding, but exotic L2 tokens may be missing. Always check the current list via the /v2/assets endpoint before designing. The API supports 100+ assets.
Our team has years of experience in blockchain development and over 20 successful integrations with custodial solutions. With 5 years on the market, we guarantee an integration timeline and certified API integration. Contact us to discuss integration — we will assess your architecture and propose the optimal approach. Get a consultation on integration today, and we will prepare a roadmap within a week.