Fig_01 — Overview

The abstraction layer for Web3

Build across chains, without building for every chain.

One API and one integration for onchain data, payments, and transactions across multiple blockchains.

Works with
SolanaEthereumMore chains →
Fig_02 — Request
terminal
$ curl https://api.mainly.live/v1/solana/wallets/9WzD…AWWM/balance

{
  "address": "9WzD…AWWM",
  "lamports": 1529000000,
  "sol": 1.529
}
Fig_03 — Architecture

One surface instead of a stack per chain

Keep your product logic. Replace the chain-specific plumbing around it with one predictable API boundary.

Without MainlyN integrations
Your app or agent

Solana stack

RPC + DAStoken programspriority fees

Ethereum stack

JSON-RPCreceipts + logsERC metadata
different units · errors · pagination · retry logic
With Mainly1 integration
Your app or agent

Mainly API

/v1/{chain}/{resource}
Wallets
Tokens
NFTs
Transactions
one key · one schema · one error model
Fig_04 — Audience

Who mainly is for

App developers

Ship one integration, not five

Wallets, balances, tokens, NFTs, and transactions behind identical REST shapes. Adding a chain is a path segment, not a rewrite.

Agents & AI tools

A surface a model can actually call

Flat JSON, human units, and stable error codes — no SDK ceremony, no per-chain quirks to teach your agent.

Fintech & payments

No nodes to babysit

Read balances and move value without running infrastructure per chain. One key, one bill, one place to look when something breaks.

Fig_05 — Principles
01

One key, every chain

The same REST shapes across Solana and Ethereum. New chains slot in under /v1 without breaking anything.

02

Human units built in

Every amount comes as raw integer and readable value — lamports and SOL, wei and ETH, token decimals resolved.

03

Predictable errors

Stable machine-readable error codes with clear messages, plus rate-limit headers on every response.

Fig_06 — Capabilities

The useful parts of a chain, already assembled

Each endpoint replaces a small pile of RPC calls, parsing rules, and edge cases with a response your product can use directly.

Wallet intelligence

Balances and holdings, not account archaeology

Native balance, fungible tokens, NFTs, and parsed activity behind one wallet-shaped surface.

GET /v1/solana/wallets/9WzD…/tokens
{
  "symbol": "USDC",
  "balance": { "raw": "42000000", "ui": 42 }
}
Network

Ready to transact

Health, recent blockhashes, and fee estimates without raw RPC configuration.

/network/status
/network/blockhash
/network/fees
Transactions

Simulate, send, confirm

Sign client-side. Mainly handles the network lifecycle without ever holding your keys.

simulatesendfinalized
Tokens + NFTs

Metadata included

Resolve supply, decimals, holders, collections, and wallet-owned assets without stitching indexers together.

token detailstop holdersNFT detailscollection assets
Accounts + programs

Parsed by default

Read one account, batch many at the same slot, or inspect program state without base64 tuples.

Predictable failures

Errors your code can branch on

{ "error": {
  "code": "blockhash_expired",
  "message": "Fetch a fresh blockhash, rebuild, and re-sign."
} }
Fig_07 — Chains

Every chain behind the same endpoints

Two families live today, mainnet and testnet each. The rest slot in under /v1 without changing a request you have already written.

SolanaLive
EthereumLive
BasePlanned
ArbitrumPlanned
OptimismPlanned
PolygonPlanned
BNB ChainPlanned
AvalanchePlanned
BitcoinPlanned
SuiPlanned
AptosPlanned
TONPlanned
Fig_08 — FAQ

Before you put it in production

The short answers to the questions that usually appear between a successful curl request and a real integration.

Which networks are live today?

Solana mainnet and devnet, plus Ethereum mainnet and Sepolia. Planned chains are marked separately; when they arrive, they use the same /v1/{chain} request shapes.

Does Mainly ever hold my private keys?

No. You build and sign transactions with your wallet or signer, then submit the signed bytes. Mainly handles simulation, submission, retries, and confirmation without receiving key material.

What does the API normalize across chains?

Endpoint structure, amount shapes, pagination, confirmation states, and error bodies. Amounts include raw integer values and human-readable units so you do not have to repeat decimal math in every client.

Do I need to install an SDK?

No. Mainly is plain HTTP and JSON, so it works from a backend, browser, mobile app, workflow, or AI agent. Use curl or any HTTP client you already have.

How are network failures exposed?

Failures use stable machine-readable codes with a clear message and relevant details. Transaction status distinguishes submitted, confirmed, finalized, failed, and expired states so retry decisions stay explicit.

How does early-access pricing work?

Early access currently has no metering and generous rate limits. Limit information is returned in response headers, and pricing will be communicated before metering is introduced.

Ready to build?

Get a key and make your first cross-chain call in under a minute. No metering during early access.

https://api.mainly.liveEarly access — no metering, generous rate limits.