Alchemy is a blockchain developer platform that provides the infrastructure, APIs, and SDKs developers use to build applications on public blockchains. Founded in 2017 by Nikil Viswanathan and Joe Lau, it is often called the "AWS of Web3" because it abstracts away the hard operational work — running nodes, indexing data, handling webhooks — so engineering teams can focus on product rather than plumbing. Companies like OpenSea, Adobe, and Shopify rely on it in production.
​

Before platforms like Alchemy existed, a team building a decentralized application had to spin up and maintain their own blockchain nodes, write custom indexing logic to track wallet transfers or NFT mints, and build webhooks from scratch to react to onchain events. Each of those layers requires dedicated DevOps work that has nothing to do with the product itself. Alchemy packages all of that infrastructure into a single developer account with a dashboard, API keys, and documentation.
​

The platform sits between your application code and the blockchain. Your app sends a request to Alchemy's endpoint instead of a raw node. Alchemy routes it through its Supernode infrastructure, applies caching and load balancing, and returns the response — often faster and more reliably than a self-hosted setup. On top of raw node access, Alchemy layers purpose-built APIs for NFTs, token transfers, gas sponsorship, and smart account creation.
​

One important distinction worth making early: Alchemy the developer platform (alchemy.com) is entirely separate from Alchemy Pay, a crypto payment processor. They share a name but have no operational connection. This article covers the developer platform only.
​

Learn how the underlying infrastructure works: What Is a Blockchain.
​

Alchemy Supernode is the enhanced node infrastructure that underpins every API call on the platform. Unlike a single standard Ethereum node that can fall behind on syncing, hit rate limits under load, or miss historical data before its own start block, Supernode runs as a distributed cluster with archival access — meaning you can query any block from genesis, not just recent ones. It is designed to handle production traffic at scale with low latency.
​

A standard Ethereum node stores the current state of the chain and a limited window of recent blocks. If you need data from three years ago — say, the token balance of a wallet at a specific historical block — a standard node cannot answer that query. An archival node stores every historical state, but archival nodes are expensive: Ethereum's archive is hundreds of terabytes. Supernode provides archival access through a shared infrastructure model, so individual teams get the capability without the storage cost.
​

Beyond archival access, Supernode adds several layers that a raw node does not include:

Alchemy offers a free tier for developers getting started, with higher rate limits and SLA guarantees on paid Growth and Scale plans. The free tier is generous enough to build and test most applications. The Alchemy API overview documents current rate limits and plan differences in detail.
​

Connecting your app to Supernode is a two-step process: create an app in the Alchemy dashboard, copy the generated HTTPS or WebSocket endpoint, and replace whatever RPC URL your code currently uses. No other code changes are required for basic node access.
​

Beyond raw node access, Alchemy exposes a set of purpose-built APIs that handle common Web3 data problems developers would otherwise solve by writing their own indexers. Each API targets a specific data domain and returns structured responses rather than raw transaction receipts or event logs that require heavy parsing.
​

NFT API. The NFT API lets you fetch a wallet's complete NFT holdings, metadata for a specific token, all transfers of a collection, floor prices, and ownership history without parsing Transfer event logs yourself. It covers ERC-721 and ERC-1155 tokens across all supported chains. OpenSea and other NFT platforms use it to power portfolio views and activity feeds. The NFT API quickstart shows how to pull a wallet's NFTs in under ten lines of JavaScript.
​

Transfers API. The Transfers API indexes every asset movement — ETH, ERC-20, ERC-721, ERC-1155 — across the entire chain history for any address. Building a transaction history view with raw RPC calls requires scanning every block and filtering logs, which is slow and expensive. The Transfers API lets you query alchemy_getAssetTransfers and get a paginated, structured list in milliseconds. DeFi dashboards and wallet apps use this to power activity feeds.
​

Token API. The Token API returns metadata, balances, and prices for ERC-20 tokens. Given a wallet address, you get back a list of every token it holds with current balances and contract details — without needing to iterate over a token list manually.
​

Alchemy Notify. Notify is Alchemy's webhook system. Instead of polling the chain repeatedly to detect when a transaction confirms or a wallet receives funds, you register a webhook URL and Alchemy sends an HTTP POST to your server the moment the event fires. Supported event types include address activity, dropped transactions, mined transactions, and gas price alerts. This is the right tool for any feature that needs to react to onchain events in near real time.
​

These APIs are all available through the same API key used for node access. You do not need separate credentials or additional setup beyond what you already configured for Supernode.
​

Understanding the contracts these APIs read is useful context: What Is a Smart Contract.
​

Alchemy has invested heavily in ERC-4337 account abstraction, the Ethereum standard that allows smart contract wallets to replace traditional externally-owned accounts. Its account abstraction product line includes Account Kit (an SDK for building embedded smart accounts), Gas Manager (a paymaster service for sponsoring gas fees), and Embedded Accounts (a hosted smart account service for consumer apps).
​

Traditional Ethereum accounts require users to hold ETH to pay gas, store a private key, and sign every transaction manually. ERC-4337 replaces that model with smart contract wallets that can be controlled by email login, passkeys, or social recovery, and can have their gas fees paid by an application rather than the user. This makes it possible to build blockchain apps that feel like regular web apps.
​

Account Kit is Alchemy's open-source TypeScript SDK for building with ERC-4337. It handles the complexity of bundling user operations, interacting with the EntryPoint contract, and managing signer plugins. Developers configure a signer (email, passkey, or external wallet), pass it to Account Kit, and get back a smart account object they can use to send transactions. The Account Kit documentation covers setup and configuration.
​

Gas Manager is Alchemy's paymaster service. A paymaster is a contract that agrees to pay gas on behalf of users under conditions you define — for example, sponsoring all transactions from users who have completed onboarding, or subsidizing gas for specific contract interactions. You configure a Gas Manager policy in the Alchemy dashboard (daily spend caps, allowlists, contract restrictions), then pass the policy ID to Account Kit. Gas Manager handles the ERC-4337 paymaster signing flow automatically.
​

Embedded Accounts is the hosted version of the same stack: Alchemy manages the infrastructure for smart accounts, bundling, and paymasters so you do not need to self-host any of those components. Consumer apps that want social login and gasless transactions without running backend infrastructure use Embedded Accounts.
​

For a deeper explanation of the standard these products build on: What Is ERC-4337.
​

Alchemy supports a wide range of EVM-compatible chains and Solana. Coverage across chains is not uniform — some chains get the full suite of Supernode, NFT API, Transfers API, Notify, and Account Kit, while others get node access and core APIs only. The table below reflects the current product state as documented on Alchemy Chain Connect.
​

Chain support is actively expanding. If a chain you need is not listed, check the Chain Connect page for the current list — it is updated as new integrations launch.
​

For applications that need to move assets or data across multiple chains, understanding how those chains connect matters: What Is Blockchain Interoperability.
​

Alchemy, Infura, and QuickNode are the three largest managed node providers. Each takes a different approach to pricing, coverage, and product depth. A self-hosted node is also a real option for teams with specific compliance requirements or very high volume. The table below compares these four options across the dimensions that matter most for most teams.
​

The main reasons teams choose Alchemy over alternatives are its account abstraction product depth and the NFT/Transfers API maturity. Infura is a reasonable alternative for teams already in the ConsenSys ecosystem. QuickNode has the broadest raw chain coverage if you need a chain Alchemy does not yet support. Self-hosted nodes make sense when you have compliance requirements prohibiting third-party data processors or when your volume makes managed pricing uneconomical.
​

For DeFi applications specifically, the choice of node provider affects latency on read-heavy data pipelines: What Is DeFi.
​

Getting started with Alchemy takes under ten minutes. You create an account at alchemy.com, create an app in the dashboard (selecting your target network), and copy the generated endpoint URL. That URL replaces whatever RPC URL your code currently points to — the rest of your code stays the same.
​

Most Web3 applications interact with Alchemy through a library rather than raw HTTP calls. The two most common are ethers.js and viem. Both accept an RPC URL in their provider constructor:
​

With ethers.js: instantiate new ethers.JsonRpcProvider("YOUR_ALCHEMY_URL") and all subsequent calls route through Alchemy. With viem: create a transport with http("YOUR_ALCHEMY_URL") and pass it to createPublicClient. Neither library requires Alchemy-specific code — the endpoint swap is the only change.
​

The Alchemy SDK is an optional layer that adds type-safe wrappers for the enhanced APIs (NFT, Transfers, Notify) that raw ethers.js or viem do not cover. Install it with npm install alchemy-sdk, initialize it with your API key, and call methods like alchemy.nft.getNftsForOwner(walletAddress) directly. The Alchemy SDK quickstart walks through a full setup.
​

Common use cases by application type:

Alchemy's dashboard also includes a Composer tool (a built-in API explorer for testing requests without writing code), a Mempool Visualizer for debugging stuck transactions, and a Debug Toolkit for tracing failed transactions. These are useful during development even if you swap to a different provider in production.
​

Alchemy has a free tier that includes Supernode access, the NFT API, the Transfers API, and Alchemy Notify with no time limit. The free tier has compute unit limits per month, which are sufficient for development and low-traffic production apps. Paid plans (Growth and Scale) increase rate limits, add SLA guarantees, and unlock dedicated support. Pricing details are on the Alchemy pricing page.
​

No. Alchemy (alchemy.com) is a blockchain developer platform providing node infrastructure, APIs, and SDKs. Alchemy Pay is an entirely separate company that processes crypto payments at point of sale. The two share a name but have no corporate or product relationship. Any reference to "Alchemy" in a Web3 developer context almost always means the developer platform, not the payment processor.
​

A regular Ethereum node stores the current chain state and recent blocks. Supernode is a distributed cluster with full archival access, load balancing, automatic failover, and request caching layered on top. It handles production traffic volumes without the operational overhead of running and maintaining your own infrastructure, and provides archival data (any block from genesis) without the storage cost of running your own archive node.
​

Gas Manager is a paymaster service in the ERC-4337 stack. You define a policy in the Alchemy dashboard (spend caps, allowed contracts, user allowlists), then pass the policy ID to Account Kit. When a user submits a transaction, Account Kit bundles it into a UserOperation and attaches a Gas Manager signature. The EntryPoint contract verifies that signature and charges the gas to your Gas Manager balance instead of the user's wallet, making the transaction gasless from the user's perspective.
​

Yes. Alchemy added Solana support and provides Supernode RPC access, an NFT API, and a Transfers API for Solana alongside its EVM chain coverage. Account Kit and Gas Manager are EVM-specific products and are not available for Solana, since Solana uses a different transaction model. The Alchemy dashboard lets you create separate apps for each chain and manage their API keys and settings independently.
​