1. Introduction to Alchemy

1.1 What is Alchemy and Why Use It?

Alchemy is a leading Web3 development platform that provides developers with powerful blockchain infrastructure and tools. It acts as a bridge between decentralized applications (DApps) and blockchain networks, offering scalable, reliable, and high-performance APIs that simplify Web3 development.

Why Choose Alchemy?

Developing directly on blockchain nodes can be complex and inefficient. Alchemy removes these pain points by:

• Providing high-speed and reliable node infrastructure
• Offering advanced APIs for querying blockchain data efficiently
• Enabling real-time event monitoring via WebSockets
• Delivering analytics and debugging tools to optimize performance

Alchemy is used by top-tier Web3 projects, including OpenSea, Aave, 0x, and MetaMask, proving its robustness in production environments.

1.2 Key Advantages Over Other Solutions

Alchemy stands out from traditional Ethereum node providers and other Web3 services due to its unique features:

Scalability & Speed

• Alchemy’s Supernode offers up to 100x faster data retrieval than standard Ethereum nodes.
• Optimized caching and request batching reduce latency.

Enhanced Developer Experience

• Easy-to-use REST APIs & WebSockets for seamless blockchain interaction.
• NFT APIs, token balance APIs, and transaction APIs tailored for Web3 use cases.
• Alchemy Mempool for monitoring transactions before they are confirmed.

Reliability & Uptime

• Enterprise-grade infrastructure ensures 99.9% uptime for mission-critical applications.
• Automatically scales with demand, handling millions of requests per second.

Advanced Analytics & Debugging

• Alchemy Explorer provides in-depth transaction analysis.
• Debugging APIs help developers troubleshoot failed transactions and smart contract errors.

1.3 Overview of Alchemy’s Offer

Alchemy provides a comprehensive suite of Web3 tools designed to simplify blockchain development.

Alchemy Supernode

A high-performance blockchain node that provides enhanced capabilities over traditional Ethereum nodes:

• Faster data querying
• Advanced request optimization
• Real-time event monitoring

Alchemy Enhanced APIs

A set of powerful APIs for interacting with blockchain networks:

• NFT API – Retrieve NFT metadata, ownership details, and transfers.
• Token API – Get real-time balances for ERC-20 tokens.
• WebSockets – Listen to new transactions, token transfers, and smart contract events.

Alchemy Transact

A gas-optimized transaction service that enhances transaction execution:

• Faster transaction confirmation
• Lower gas fees through smart fee optimization

Alchemy Notify

A real-time notification system that alerts users about:

• New transactions on their wallets
• Smart contract interactions
• Blockchain events

Alchemy Monitor & Explorer

Tools to help developers track, debug, and optimize their blockchain applications:

• Real-time monitoring dashboard
• In-depth transaction and contract analysis

1.4 Who Should Use Alchemy?

Alchemy is built for Web3 developers, startups, and enterprises looking to build reliable and scalable blockchain applications. It is particularly beneficial for:

• DApp developers who need high-performance APIs to interact with smart contracts.
• NFT marketplaces requiring fast and reliable NFT metadata retrieval.
• DeFi platforms needing real-time token balances and transaction insights.
• Game developers integrating blockchain assets and in-game economies.

Alchemy’s infrastructure supports Ethereum, Polygon, Arbitrum, Optimism, Solana, and more, making it a versatile choice for various blockchain applications.

Conclusion

Alchemy simplifies Web3 development by providing a high-performance, scalable, and reliable infrastructure. Whether you’re building an NFT platform, DeFi protocol, or a decentralized app, Alchemy offers powerful tools and APIs to help you deploy and scale your project efficiently.

2. Setup and Getting Started

2.1 Creating an Alchemy Account

To start using Alchemy, you first need to create an account. The process is simple and free for basic usage.

Steps to Create an Alchemy Account

1. Go to the Alchemy Website – Visit Alchemy's official website.
2. Sign Up – Click on "Sign Up" and enter your email, password, and name.
3. Verify Your Email – You will receive a confirmation email. Click the verification link to activate your account.
4. Log In – After verification, log in to access the Alchemy Dashboard.

Once your account is set up, you can start creating and managing blockchain projects.

2.2 Setting Up Your First Web3 Project

After logging in, you need to create a project to generate an API key and interact with the blockchain.

How to Create a New Project in Alchemy

1. Access the Dashboard – After logging in, go to the Alchemy Dashboard.
2. Create a New App
   • Click "Create App"
   • Enter the Project Name
   • Select a Blockchain Network (e.g., Ethereum, Polygon, Arbitrum)
   • Choose a Network Type (Mainnet or Testnet)
3. Click "Create App" – Your project is now ready, and an API key will be generated.

Tip: If you are testing, it's best to start with a Testnet (e.g., Goerli, Sepolia) to avoid using real funds.

2.3 Generating and Managing API Keys

Alchemy provides API keys that allow your application to communicate with blockchain nodes.

Finding Your API Key

• Go to your Alchemy Dashboard
• Select your project
• You will see your HTTP and WebSocket API URLs

Types of API URLs

• HTTP API URL – Used for sending standard requests
• WebSocket API URL – Used for real-time blockchain event monitoring

Security Tip: Never expose your API key in public repositories. Store it in environment variables when coding.

2.4 Installing Alchemy in Your Development Environment

To interact with Alchemy in your code, you need to install the appropriate dependencies.

Installing Alchemy SDK

Alchemy provides an SDK to simplify blockchain interactions. You can install it using:

npm install @alch/alchemy-sdk ethers dotenv

or

yarn add @alch/alchemy-sdk ethers dotenv

🔹 Required Dependencies:

• @alch/alchemy-sdk – Alchemy’s official SDK
• ethers.js – Library to interact with smart contracts
• dotenv – To securely manage API keys

2.5 Connecting to the Blockchain with Alchemy

Once installed, you can connect to Ethereum, Polygon, or other blockchains using Alchemy's API.

Example: Connecting to Ethereum using Alchemy

require('dotenv').config();
const { Alchemy, Network } = require('@alch/alchemy-sdk');

// Load API Key from .env file
const alchemy = new Alchemy({
  apiKey: process.env.ALCHEMY_API_KEY,
  network: Network.ETH_GOERLI, // Use ETH_MAINNET for Mainnet
});

// Fetch the latest block number
async function getBlockNumber() {
  const blockNumber = await alchemy.core.getBlockNumber();
  console.log(`Latest Block Number: ${blockNumber}`);
}

getBlockNumber();

How This Works

1. Loads the Alchemy API Key from an environment file (.env).
2. Connects to the Goerli Testnet (you can switch to Mainnet if needed).
3. Fetches and displays the latest block number.

2.6 Choosing the Right Blockchain Network

Alchemy supports multiple blockchain networks, including:

When developing, it’s recommended to start on a Testnet to avoid using real funds.

Tip: You can get free testnet tokens from Alchemy’s Faucet.

2.7 Deploying Your First Smart Contract Using Alchemy

Once connected, you can deploy smart contracts easily.

Example: Deploying a Smart Contract with Hardhat

Install Hardhat

npm install --save-dev hardhat

Create a New Hardhat Project

npx hardhat

Deploy Using Alchemy
Modify hardhat.config.js to use Alchemy’s API:

require("@nomicfoundation/hardhat-toolbox");

module.exports = {
  solidity: "0.8.0",
  networks: {
    goerli: {
      url: process.env.ALCHEMY_API_URL,
      accounts: [process.env.PRIVATE_KEY],
    },
  },
};

Write a Smart Contract (Example: contracts/SimpleStorage.sol)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleStorage {
    uint256 storedData;

    function set(uint256 x) public {
        storedData = x;
    }

    function get() public view returns (uint256) {
        return storedData;
    }
}

Create a Deployment Script

Inside the scripts/ folder, create a file called deploy.js:

const hre = require("hardhat");

async function main() {
  const SimpleStorage = await hre.ethers.getContractFactory("SimpleStorage");
  const simpleStorage = await SimpleStorage.deploy();

  await simpleStorage.deployed();
  console.log(`Contract deployed to: ${simpleStorage.address}`);
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});

Run Deployment Script

npx hardhat run scripts/deploy.js --network goerli

Your smart contract will now be deployed on the Goerli Testnet.

2.8 Conclusion

In this chapter, you learned how to:
Create an Alchemy account
Set up a Web3 project
Generate and use API keys
Connect to the blockchain using Alchemy SDK
Deploy a smart contract using Alchemy

You are now ready to start building decentralized applications (DApps) using Alchemy’s powerful tools.

3. Alchemy and Supported Blockchains

Alchemy supports multiple blockchains, providing developers with a scalable and reliable infrastructure for building decentralized applications (DApps), DeFi protocols, NFT marketplaces, and more. In this chapter, we'll explore the blockchains available on Alchemy, their key differences, and how to choose the best one for your project.

3.1 Blockchains Supported by Alchemy

Alchemy offers full-node infrastructure for several leading blockchains, each optimized for different use cases.

Overview of Supported Networks

Each blockchain has unique features that make it more suitable for specific applications.

3.2 Understanding Mainnet vs. Testnet

Mainnet (Live Network)

• The production environment where real transactions occur.
• Uses real tokens (ETH, MATIC, ARB, etc.).
• Ideal for launching fully operational DApps.

Testnet (Testing Environment)

• A sandbox for developers to test applications without using real money.
• Uses test tokens (e.g., Goerli ETH, Mumbai MATIC).
• Recommended for smart contract testing before Mainnet deployment.

3.3 Choosing the Right Blockchain for Your Project

Not all blockchains are created equal. Here’s how to decide which one fits your DApp:

Ethereum: The Most Secure & Decentralized

✅ Best for:

• High-value DeFi platforms (Uniswap, Aave)
• NFT marketplaces (OpenSea, Foundation)
• DAOs and governance applications

❌ Limitations:

• High gas fees during network congestion
• Slower transaction speeds compared to Layer 2 solutions

Polygon: Low-Cost and Scalable Alternative to Ethereum

✅ Best for:

• Gaming applications (Decentraland, The Sandbox)
• NFT platforms with low transaction fees
• High-frequency DApps that require cost-effective transactions

❌ Limitations:

• Less decentralized than Ethereum Mainnet
• Bridges to Ethereum can introduce delays

Arbitrum & Optimism: Ethereum Layer 2 Scaling Solutions

✅ Best for:

• DeFi applications needing fast transactions
• Users who want Ethereum’s security with lower fees
• Smart contract-heavy DApps

🔹 Key Differences:

• Arbitrum offers more decentralization and better compatibility with Ethereum smart contracts.
• Optimism has faster confirmation times but lower decentralization.

Base: Coinbase’s Layer 2 for Web3 Adoption

✅ Best for:

• Web3 projects targeting mainstream adoption
• DApps that need easy fiat-to-crypto onboarding

❌ Limitations:

• Less decentralized than Ethereum
• Still in early adoption phase

Solana: High-Speed Transactions for Web3

✅ Best for:

• Gaming and high-frequency trading
• NFT collections with instant minting
• DApps requiring high scalability

❌ Limitations:

• Less decentralization than Ethereum
• Network downtimes in the past

3.4 How to Connect to a Blockchain with Alchemy

Alchemy provides easy API access to interact with supported blockchains.

Step 1: Install Dependencies

If you haven't already installed the Alchemy SDK, run:

npm install @alch/alchemy-sdk ethers dotenv

Step 2: Set Up Your Environment

Create a .env file to store your API key securely:

ALCHEMY_API_KEY=your_api_key_here

Step 3: Connect to a Blockchain

Below is an example of connecting to Ethereum, Polygon, or another network using Alchemy.

require('dotenv').config();
const { Alchemy, Network } = require('@alch/alchemy-sdk');

// Configure Alchemy with API Key
const settings = {
  apiKey: process.env.ALCHEMY_API_KEY, 
  network: Network.ETH_GOERLI, // Change to ETH_MAINNET for live data
};

const alchemy = new Alchemy(settings);

// Fetch the latest block number
async function getBlockNumber() {
  const blockNumber = await alchemy.core.getBlockNumber();
  console.log(`Latest Block: ${blockNumber}`);
}

getBlockNumber();

Step 4: Switching to Another Blockchain

To switch blockchains, change the network parameter:

3.5 Checking Network Status and Gas Prices

Alchemy provides APIs to check real-time network status and gas fees.

Get Current Gas Fees on Ethereum

async function getGasPrice() {
  const gas = await alchemy.core.getGasPrice();
  console.log(`Current Gas Price: ${gas}`);
}

getGasPrice();

Check if a Blockchain is Running Smoothly

You can monitor blockchain latency and status using:

async function getHealthStatus() {
  const status = await alchemy.core.getHealth();
  console.log(`Network Health:`, status);
}

getHealthStatus();

3.6 Conclusion

Alchemy supports multiple blockchains, each optimized for different types of Web3 applications. In this chapter, we covered:

The mainnet and testnet options for each blockchain
How to choose the best blockchain for your project
How to connect your app to a blockchain using Alchemy
How to check gas prices and network status

This knowledge is crucial for scaling and optimizing your Web3 application efficiently.

4. Alchemy API: Features and Functionality

Alchemy provides a powerful set of APIs that enable developers to interact efficiently with blockchain networks. These APIs go beyond standard Ethereum node functionality, offering faster data retrieval, real-time event monitoring, and enhanced analytics.

In this chapter, we will explore the key features of Alchemy's API and how they can be used to build high-performance Web3 applications.

4.1 Overview of Alchemy’s API Services

Alchemy offers multiple APIs tailored to different blockchain development needs:

Each API offers unique functionalities that simplify Web3 development.

4.2 Alchemy Supernode API (Standard & Enhanced APIs)

The Alchemy Supernode API is an enhanced version of Ethereum nodes, offering faster, more reliable, and scalable blockchain interactions.

Key Features of Supernode API

100x faster queries compared to standard Ethereum nodes
Automatic failover & load balancing to ensure high availability
Advanced caching & request batching for optimized performance

Basic Example: Fetch the Latest Block Number

const { Alchemy, Network } = require("@alch/alchemy-sdk");

const alchemy = new Alchemy({
  apiKey: process.env.ALCHEMY_API_KEY, 
  network: Network.ETH_MAINNET,
});

async function getLatestBlock() {
  const blockNumber = await alchemy.core.getBlockNumber();
  console.log(`Latest Block: ${blockNumber}`);
}

getLatestBlock();

4.3 Alchemy Enhanced APIs (Advanced Blockchain Data Retrieval)

Alchemy’s Enhanced APIs provide highly optimized methods for retrieving blockchain data.

Get Token Balances of a Wallet

async function getTokenBalances(address) {
  const balances = await alchemy.core.getTokenBalances(address);
  console.log("Token Balances:", balances);
}

getTokenBalances("0xYourWalletAddressHere");

Use Case: Ideal for wallet apps, portfolio trackers, and DeFi platforms.

4.4 Alchemy NFT API (Efficient NFT Data Handling)

The Alchemy NFT API is specifically designed for fast and efficient NFT data retrieval, making it ideal for NFT marketplaces and analytics tools.

Fetch NFT Metadata for a Collection

async function getNFTMetadata(contractAddress, tokenId) {
  const metadata = await alchemy.nft.getNftMetadata(contractAddress, tokenId);
  console.log("NFT Metadata:", metadata);
}

getNFTMetadata("0xYourNFTContractAddress", "1");

Fetch All NFTs Owned by a Wallet

async function getWalletNFTs(walletAddress) {
  const nfts = await alchemy.nft.getNftsForOwner(walletAddress);
  console.log("Owned NFTs:", nfts);
}

getWalletNFTs("0xYourWalletAddressHere");

Use Case: Useful for NFT wallets, analytics dashboards, and marketplaces.

4.5 Alchemy WebSockets API (Real-Time Blockchain Monitoring)

Alchemy's WebSockets API allows developers to subscribe to blockchain events without polling, reducing costs and improving efficiency.

Subscribe to New Blocks in Real Time

const WebSocket = require("ws");

const ws = new WebSocket("wss://eth-mainnet.ws.alchemy.com/v2/YOUR_ALCHEMY_API_KEY");

ws.on("open", () => {
  ws.send(
    JSON.stringify({
      jsonrpc: "2.0",
      id: 1,
      method: "eth_subscribe",
      params: ["newHeads"],
    })
  );
});

ws.on("message", (data) => {
  console.log("New Block:", JSON.parse(data));
});

Use Case: Perfect for real-time dashboards, trading bots, and analytics tools.

4.6 Alchemy Mempool API (Track Pending Transactions)

The Mempool API allows developers to monitor transactions before they are confirmed, giving a competitive edge in DeFi and trading applications.

Get Pending Transactions for a Wallet

async function getPendingTransactions(walletAddress) {
  const pendingTxs = await alchemy.core.getTransactionReceipts({ fromAddress: walletAddress });
  console.log("Pending Transactions:", pendingTxs);
}

getPendingTransactions("0xYourWalletAddressHere");

Use Case: Useful for traders, bots, and analytics platforms to predict network congestion.

4.7 Alchemy Transact (Gas-Optimized Transactions)

Alchemy optimizes transaction execution, ensuring faster confirmations and lower gas fees.

Send an Optimized Transaction

async function sendTransaction() {
  const tx = await alchemy.transact.sendGasOptimizedTransaction({
    to: "0xRecipientAddressHere",
    value: "0.1", // 0.1 ETH
    gasLimit: "21000",
  });

  console.log("Transaction Hash:", tx.hash);
}

sendTransaction();

Use Case: Ideal for wallets, NFT platforms, and DeFi apps that need efficient transaction processing.

4.8 Alchemy Notify API (Blockchain Event Notifications)

Alchemy’s Notify API lets you create custom alerts for blockchain events.

Set Up Webhooks for Blockchain Events

async function createWebhook() {
  const webhook = await alchemy.notify.createWebhook({
    webhookUrl: "https://yourserver.com/webhook",
    eventType: "ADDRESS_ACTIVITY",
    address: "0xYourWalletAddressHere",
  });

  console.log("Webhook Created:", webhook);
}

createWebhook();

Use Case: Best for wallet alerts, automated notifications, and monitoring tools.

4.9 Conclusion

Alchemy’s APIs provide powerful, developer-friendly tools that enhance blockchain application development. In this chapter, we covered:

Alchemy Supernode API for high-speed blockchain queries
Enhanced APIs for retrieving wallet balances, tokens, and NFTs
WebSockets API for real-time blockchain event monitoring
Mempool API to track pending transactions before confirmation
Alchemy Transact for gas-optimized transactions
Alchemy Notify API for real-time notifications on blockchain events

These tools allow Web3 developers to build faster, more scalable, and feature-rich applications.

5. Building a DApp with Alchemy

Decentralized Applications (DApps) are the backbone of Web3, enabling users to interact with smart contracts on the blockchain. Alchemy simplifies DApp development by providing powerful APIs, enhanced blockchain access, and real-time monitoring tools.

In this chapter, you’ll learn how to set up a DApp development environment, deploy a smart contract, and integrate it with a front-end interface using Alchemy, Hardhat, and Ethers.js.

5.1 Setting Up a Development Environment

Before building a DApp, you need to set up a development environment with Node.js, Hardhat, and Alchemy’s SDK.

🔹 Install Required Dependencies

Ensure you have Node.js installed, then run:

mkdir alchemy-dapp && cd alchemy-dapp
npm init -y
npm install --save-dev hardhat ethers dotenv @alch/alchemy-sdk

5.2 Creating a New Hardhat Project

To initialize a Hardhat project, run:

npx hardhat

Select "Create a basic sample project", then install missing dependencies:

npm install --save-dev @nomicfoundation/hardhat-toolbox

Configuring Hardhat to Use Alchemy

Edit hardhat.config.js to include your Alchemy API Key and Ethereum Testnet configuration:

require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config();

module.exports = {
  solidity: "0.8.19",
  networks: {
    goerli: {
      url: process.env.ALCHEMY_API_URL, // Alchemy Goerli URL
      accounts: [process.env.PRIVATE_KEY], // Your wallet private key
    },
  },
};

Security Tip: Store API keys in a .env file:

ALCHEMY_API_URL=https://eth-goerli.alchemyapi.io/v2/YOUR_ALCHEMY_KEY
PRIVATE_KEY=your_private_key_here

5.3 Writing a Smart Contract

Smart contracts are self-executing programs that run on the blockchain. Below is a simple Ethereum contract that allows users to store and retrieve a number.

This procedure is the same already seen in chapter 2.

Create a new Solidity file:

Create a new folder contracts, then add SimpleStorage.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleStorage {
    uint256 storedData;

    function set(uint256 x) public {
        storedData = x;
    }

    function get() public view returns (uint256) {
        return storedData;
    }
}

What This Does:

• set(uint256 x): Updates the stored number.
• get(): Retrieves the stored number.

5.4 Compiling and Deploying the Smart Contract

Compile the Contract

Run the following command:

npx hardhat compile

If successful, you’ll see "Compilation finished successfully".

Create a Deployment Script

Inside the scripts/ folder, create a file called deploy.js:

const hre = require("hardhat");

async function main() {
  const SimpleStorage = await hre.ethers.getContractFactory("SimpleStorage");
  const simpleStorage = await SimpleStorage.deploy();

  await simpleStorage.deployed();
  console.log(`Contract deployed to: ${simpleStorage.address}`);
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});

Deploy the Contract to Goerli Testnet

Run:

npx hardhat run scripts/deploy.js --network goerli

🔹 Output Example:

Contract deployed to: 0x123456789abcdef...

Your contract is now live on the Goerli testnet!

5.5 Interacting with the Smart Contract Using Alchemy

Now that the contract is deployed, let’s interact with it using Ethers.js and Alchemy.

Fetch Contract Data

Create a new file interact.js:

require("dotenv").config();
const { ethers } = require("ethers");

const ALCHEMY_API_URL = process.env.ALCHEMY_API_URL;
const PRIVATE_KEY = process.env.PRIVATE_KEY;
const CONTRACT_ADDRESS = "0xYourDeployedContractAddress";
const ABI = [
  {
    "inputs": [{"internalType": "uint256", "name": "x", "type": "uint256"}],
    "name": "set",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "get",
    "outputs": [{"internalType": "uint256", "name": "", "type": "uint256"}],
    "stateMutability": "view",
    "type": "function"
  }
];

// Connect to Alchemy
const provider = new ethers.JsonRpcProvider(ALCHEMY_API_URL);
const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
const contract = new ethers.Contract(CONTRACT_ADDRESS, ABI, wallet);

async function interactWithContract() {
  // Store a new value
  let tx = await contract.set(42);
  await tx.wait();
  console.log("Stored value updated!");

  // Retrieve the stored value
  let value = await contract.get();
  console.log(`Stored Value: ${value}`);
}

interactWithContract();

Run the Script

node interact.js

Expected Output:

Stored value updated!
Stored Value: 42

5.6 Creating a Front-End for the DApp

Now, let’s build a simple React UI that interacts with our smart contract.

Install React and Dependencies

npx create-react-app frontend
cd frontend
npm install ethers dotenv

Modify App.js

Replace the content with:

import { useState } from "react";
import { ethers } from "ethers";

const CONTRACT_ADDRESS = "0xYourDeployedContractAddress";
const ABI = [...]; // Paste your contract ABI here

function App() {
  const [value, setValue] = useState(0);
  const [provider, setProvider] = useState(null);
  const [contract, setContract] = useState(null);

  async function connectWallet() {
    if (window.ethereum) {
      const web3Provider = new ethers.BrowserProvider(window.ethereum);
      await web3Provider.send("eth_requestAccounts", []);
      setProvider(web3Provider);

      const signer = await web3Provider.getSigner();
      setContract(new ethers.Contract(CONTRACT_ADDRESS, ABI, signer));
    } else {
      alert("Please install MetaMask");
    }
  }

  async function updateValue() {
    const tx = await contract.set(42);
    await tx.wait();
    alert("Stored value updated!");
  }

  async function fetchValue() {
    const storedValue = await contract.get();
    setValue(storedValue.toString());
  }

  return (
    <div>
      <button onClick={connectWallet}>Connect Wallet</button>
      <button onClick={updateValue}>Set Value to 42</button>
      <button onClick={fetchValue}>Get Stored Value</button>
      <p>Stored Value: {value}</p>
    </div>
  );
}

export default App;

Run the React App

npm start

Your DApp is now live!

5.7 Conclusion

In this chapter, you learned how to:

Set up a Hardhat project with Alchemy
Write, deploy, and interact with a smart contract
Build a React front-end that connects to the blockchain

You are now ready to build fully functional Web3 applications!

6. Debugging and Analytics with Alchemy

Debugging and analytics are critical components of blockchain development. Unlike traditional applications, blockchain transactions are immutable, making it essential to analyze transactions, detect errors, and optimize performance before deploying a smart contract or DApp to mainnet.

Alchemy provides powerful debugging and analytics tools, including:
Alchemy Explorer for transaction insights
Alchemy Mempool to track pending transactions
Alchemy Debug APIs for diagnosing smart contract failures
Real-time monitoring tools to optimize performance

6.1 Using Alchemy Explorer for Transaction Analysis

Alchemy Explorer is a blockchain analytics dashboard that allows developers to inspect transactions, smart contracts, and gas fees in real-time.

🔹 Checking a Transaction on Alchemy Explorer

1. Go to Alchemy Explorer → https://dashboard.alchemy.com/explorer
2. Enter the transaction hash (Tx Hash)
3. Analyze transaction details, including:
   • Gas fees
   • Sender & recipient addresses
   • Smart contract interactions
   • Status (Success/Failed/Pending)

Example: Fetch Transaction Data Using Alchemy API

You can programmatically analyze transactions using Alchemy’s API.

const { Alchemy, Network } = require("@alch/alchemy-sdk");

const alchemy = new Alchemy({
  apiKey: process.env.ALCHEMY_API_KEY,
  network: Network.ETH_GOERLI,
});

async function getTransactionDetails(txHash) {
  const txDetails = await alchemy.core.getTransaction(txHash);
  console.log("Transaction Details:", txDetails);
}

getTransactionDetails("0xYourTransactionHashHere");

Use Case: Useful for troubleshooting failed transactions and optimizing gas fees.

6.2 Debugging Smart Contracts with Alchemy Debug API

Alchemy provides low-level debugging APIs that help developers analyze smart contract execution.

Using debug_traceTransaction to Inspect Failed Transactions

This method provides a detailed breakdown of a transaction’s execution.

async function debugTransaction(txHash) {
  const debugInfo = await alchemy.core.traceTransaction(txHash);
  console.log("Debug Trace:", debugInfo);
}

debugTransaction("0xYourFailedTransactionHashHere");

Use Case: Helps identify why a transaction failed (e.g., out-of-gas errors, smart contract logic issues).

6.3 Monitoring Pending Transactions with Alchemy Mempool API

Alchemy’s Mempool API allows developers to track unconfirmed transactions before they are included in a block.

Fetch Pending Transactions for a Wallet

async function getPendingTxs(walletAddress) {
  const pendingTxs = await alchemy.core.getTransactionReceipts({ fromAddress: walletAddress });
  console.log("Pending Transactions:", pendingTxs);
}

getPendingTxs("0xYourWalletAddressHere");

Use Case: Useful for DeFi bots, trading apps, and transaction analytics.

6.4 Analyzing Gas Fees and Optimizing Transactions

Gas fees can significantly impact the cost of transactions on Ethereum and other blockchains. Alchemy provides real-time gas fee data to help optimize costs.

Fetch Current Gas Prices

async function getGasPrice() {
  const gasPrice = await alchemy.core.getGasPrice();
  console.log(`Current Gas Price: ${ethers.formatUnits(gasPrice, "gwei")} Gwei`);
}

getGasPrice();

Estimate Gas for a Transaction

async function estimateGas() {
  const estimatedGas = await alchemy.core.estimateGas({
    to: "0xRecipientAddressHere",
    value: ethers.parseEther("0.1"),
  });

  console.log(`Estimated Gas: ${estimatedGas}`);
}

estimateGas();

Use Case: Helps optimize transaction costs by choosing the right gas price.

6.5 Setting Up Real-Time Alerts Using Alchemy Notify API

Alchemy’s Notify API allows developers to set up real-time notifications for blockchain events.

Creating a Webhook for Wallet Activity

async function createWebhook() {
  const webhook = await alchemy.notify.createWebhook({
    webhookUrl: "https://yourserver.com/webhook",
    eventType: "ADDRESS_ACTIVITY",
    address: "0xYourWalletAddressHere",
  });

  console.log("Webhook Created:", webhook);
}

createWebhook();

Use Case: Useful for wallet monitoring, security alerts, and DApp notifications.

6.6 Using Alchemy Monitor for Performance Insights

Alchemy Monitor provides real-time analytics on API usage, transaction success rates, and node performance.

How to Use Alchemy Monitor

1. Go to the Alchemy Dashboard → https://dashboard.alchemy.com/monitor
2. View API Usage Analytics
   • Track how many requests your DApp is making
   • Identify slow API calls
3. Analyze Transaction Performance
   • Check failed vs. successful transactions
   • Optimize smart contract gas efficiency

Use Case: Ideal for DApp performance monitoring and debugging.

6.7 Conclusion

Alchemy provides powerful debugging and analytics tools that help developers:

Analyze transactions using Alchemy Explorer
Debug smart contracts using debug_traceTransaction
Monitor pending transactions in the Mempool
Estimate and optimize gas fees
Set up real-time notifications for wallet activity
Track API usage and performance with Alchemy Monitor

With these tools, developers can build more reliable and optimized DApps.

7. Performance Optimization with Alchemy

Building scalable and efficient Web3 applications is essential for improving user experience and reducing costs. Blockchain transactions can be expensive and slow, especially on Ethereum, but Alchemy provides several tools to optimize performance.

In this chapter, we’ll explore strategies and APIs that can help developers:

Reduce gas fees and transaction costs
Improve data query speed
Optimize contract interactions
Use caching and indexing for better performance

7.1 Understanding Web3 Performance Bottlenecks

Before optimizing, it’s important to understand the common performance bottlenecks in blockchain applications:

🔹 High Gas Fees

• Ethereum transactions can become very expensive during network congestion.
• Inefficient smart contract logic can lead to higher execution costs.

🔹 Slow Transaction Confirmations

• Transactions may take minutes or even hours to confirm if gas fees are too low.
• Users experience frustration due to delayed updates in DApps.

🔹 Inefficient Data Retrieval

• Standard blockchain queries can be slow and costly.
• Fetching NFT metadata, token balances, or logs requires multiple API calls, increasing latency.

🔹 Redundant API Calls

• Polling for transaction status updates wastes API requests and slows down performance.
• Lack of caching increases load time for frequently accessed data.

7.2 Reducing Gas Fees with Alchemy Transact

Alchemy Transact API helps developers optimize gas fees for Ethereum transactions.

Fetch Current Gas Prices and Set an Optimal Fee

const { ethers } = require("ethers");
const { Alchemy, Network } = require("@alch/alchemy-sdk");

const alchemy = new Alchemy({
  apiKey: process.env.ALCHEMY_API_KEY,
  network: Network.ETH_MAINNET,
});

async function getGasPrice() {
  const gasPrice = await alchemy.core.getGasPrice();
  console.log(`Current Gas Price: ${ethers.formatUnits(gasPrice, "gwei")} Gwei`);
}

getGasPrice();

Best Practice: Dynamically adjust gas fees based on network congestion to ensure fast and cost-effective transactions.

7.3 Using Alchemy Mempool API for Faster Transactions

Alchemy Mempool API helps developers monitor pending transactions and adjust gas fees dynamically.

Track Pending Transactions for a Wallet

async function trackPendingTransactions(walletAddress) {
  const pendingTxs = await alchemy.core.getTransactionReceipts({ fromAddress: walletAddress });
  console.log("Pending Transactions:", pendingTxs);
}

trackPendingTransactions("0xYourWalletAddressHere");

Use Case: This helps DeFi platforms and NFT marketplaces prioritize urgent transactions.

7.4 Reducing API Calls with WebSockets

Polling the blockchain wastes resources. Instead, use WebSockets to receive real-time updates instantly.

Subscribe to New Transactions in Real Time

const WebSocket = require("ws");

const ws = new WebSocket("wss://eth-mainnet.ws.alchemy.com/v2/YOUR_ALCHEMY_API_KEY");

ws.on("open", () => {
  ws.send(JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_subscribe", params: ["newHeads"] }));
});

ws.on("message", (data) => {
  console.log("New Block:", JSON.parse(data));
});

Best Practice: Use WebSockets for real-time updates instead of polling to reduce API costs and latency.

7.5 Optimizing Smart Contract Efficiency

Smart contract inefficiencies lead to higher gas fees and slower transactions. Here are some best practices:

Reduce Storage Usage

Before (Expensive Storage Write)

uint256[] public numbers;

function addNumber(uint256 _num) public {
    numbers.push(_num);
}

After (More Efficient)

mapping(uint256 => bool) public numbers;

function addNumber(uint256 _num) public {
    numbers[_num] = true;
}

Use calldata Instead of memory for Function Parameters

Before (Higher Gas Usage)

function processData(string memory _data) public {
    // Function logic
}

After (Lower Gas Usage)

function processData(string calldata _data) public {
    // Function logic
}

Best Practice: Optimize storage and function parameters to reduce gas costs.

7.6 Improving Query Speed with Enhanced APIs

Alchemy Enhanced APIs provide faster and more efficient data retrieval.

Get Token Balances in One API Call

async function getTokenBalances(walletAddress) {
  const balances = await alchemy.core.getTokenBalances(walletAddress);
  console.log("Token Balances:", balances);
}

getTokenBalances("0xYourWalletAddressHere");

Best Practice: Use Alchemy Enhanced APIs instead of multiple standard JSON-RPC calls.

7.7 Caching and Indexing Data

Repeated queries slow down performance. Instead, cache frequently accessed data using Redis or a database.

Example: Caching NFT Data Locally

const NodeCache = require("node-cache");
const nftCache = new NodeCache({ stdTTL: 600 }); // Cache for 10 minutes

async function getNFTMetadata(contract, tokenId) {
  const cacheKey = `${contract}-${tokenId}`;
  const cachedData = nftCache.get(cacheKey);

  if (cachedData) {
    console.log("Returning cached NFT data.");
    return cachedData;
  }

  const metadata = await alchemy.nft.getNftMetadata(contract, tokenId);
  nftCache.set(cacheKey, metadata);
  return metadata;
}

Best Practice: Use caching layers to reduce redundant API calls.

7.8 Using Alchemy Monitor to Optimize API Usage

Alchemy Monitor provides real-time analytics for API performance.

How to Use Alchemy Monitor:

1. Go to Alchemy Dashboard → https://dashboard.alchemy.com/monitor
2. Analyze API usage trends
3. Identify slow API calls and optimize queries
4. Set up alerts for API overuse

Best Practice: Use Alchemy Monitor to optimize query efficiency.

7.9 Conclusion

Alchemy provides powerful tools to improve Web3 application performance. In this chapter, we covered:

Reducing gas fees with Alchemy Transact
Using Mempool API for faster transactions
Switching to WebSockets to reduce API calls
Optimizing smart contract gas efficiency
Using Enhanced APIs for faster data retrieval
Caching & indexing data for better performance
Using Alchemy Monitor to track API performance

These optimization techniques help developers reduce costs and improve user experience.

8. Security and Best Practices for Alchemy DApps

Security is critical in Web3 development. Unlike traditional applications, blockchain transactions are irreversible, and vulnerabilities can lead to loss of funds or exploits.

Alchemy provides tools and best practices to help developers secure their DApps by:

Protecting API Keys and preventing unauthorized access
Implementing smart contract security best practices
Preventing gas fee manipulation attacks
Using real-time monitoring and alerts for suspicious activity

8.1 Protecting API Keys and Credentials

API keys give access to Alchemy’s blockchain infrastructure and must be protected to prevent abuse.

Best Practices for API Key Security

• Use environment variables instead of hardcoding API keys in your source code.
1. Restrict API Key Usage
   • Use Alchemy Dashboard to set key restrictions.
   • Limit allowed origins (CORS) or IP addresses.
2. Rotate API Keys Regularly
   • If a key is compromised, generate a new one and update your application.

Never expose API keys in public repositories

ALCHEMY_API_KEY=your_secret_key

require("dotenv").config();
const API_KEY = process.env.ALCHEMY_API_KEY;

Use Case: Protects DApps from unauthorized API usage and key leaks.

8.2 Preventing Smart Contract Vulnerabilities

Smart contracts are public and immutable, making security flaws permanent. Follow these best practices to secure your contracts.

1. Use the Latest Solidity Version

• Solidity updates include security fixes for known vulnerabilities.
• Specify a Solidity version range to avoid outdated compilers.

pragma solidity ^0.8.19;

2. Implement SafeMath to Prevent Overflows

Solidity 0.8+ includes built-in overflow protection, but for older versions, use SafeMath:

// Example: Preventing Overflows
uint256 private balance;

function addBalance(uint256 amount) public {
    require(amount > 0, "Amount must be greater than zero");
    balance += amount; // Safe in Solidity 0.8+
}

3. Use require() to Validate Inputs

Prevent unexpected behavior by checking conditions before execution.

function transfer(address recipient, uint256 amount) public {
    require(recipient != address(0), "Invalid recipient");
    require(amount > 0, "Amount must be greater than zero");
}

4. Avoid tx.origin for Authentication

• Wrong: Using tx.origin makes contracts vulnerable to phishing attacks.
• Correct: Use msg.sender to authenticate users.

Use Case: Prevents common smart contract exploits like reentrancy attacks and integer overflows.

8.3 Preventing Reentrancy Attacks

A reentrancy attack occurs when a contract calls an external contract before updating its own state, allowing an attacker to drain funds.

Vulnerable Contract

function withdraw(uint256 amount) public {
    require(balance[msg.sender] >= amount, "Insufficient balance");
    (bool success, ) = msg.sender.call{value: amount}(""); // Reentrancy risk!
    require(success, "Transfer failed");
    balance[msg.sender] -= amount; // State update occurs AFTER transfer
}

Secure Contract (Use Checks-Effects-Interactions Pattern)

function withdraw(uint256 amount) public {
    require(balance[msg.sender] >= amount, "Insufficient balance");

    balance[msg.sender] -= amount; // Update state first
    (bool success, ) = msg.sender.call{value: amount}("");
    require(success, "Transfer failed");
}

Use Case: Prevents attackers from calling the function multiple times before state changes.

8.4 Securing Transaction Execution

Gas fee manipulation and front-running attacks are common in DeFi and NFT marketplaces.

1. Use Alchemy Gas Optimization

Alchemy Transact API optimizes gas fees dynamically:

async function sendOptimizedTx() {
  const tx = await alchemy.transact.sendGasOptimizedTransaction({
    to: "0xRecipientAddress",
    value: "0.1", // ETH amount
    gasLimit: "21000",
  });

  console.log("Transaction Hash:", tx.hash);
}
sendOptimizedTx();

2. Prevent Front-Running with Private Transactions

Front-runners scan pending transactions to copy profitable trades.
Alchemy supports private transactions, which are sent directly to miners without going to the mempool.

const { FlashbotsBundleProvider } = require("@flashbots/ethers-provider-bundle");

async function sendPrivateTransaction() {
  const flashbotsProvider = await FlashbotsBundleProvider.create(
    ethers.getDefaultProvider(),
    wallet
  );

  const signedBundle = await flashbotsProvider.signBundle([
    {
      transaction: {
        to: "0xRecipientAddress",
        value: ethers.parseEther("1"),
      },
      signer: wallet,
    },
  ]);

  await flashbotsProvider.sendBundle(signedBundle);
}
sendPrivateTransaction();

Use Case: Prevents bots from front-running NFT purchases or DeFi trades.

8.5 Implementing Multi-Signature Wallets for Security

For high-value transactions, multi-signature wallets (like Gnosis Safe) add an extra layer of protection.

Example: Deploying a Gnosis Safe Multi-Sig

1. Go to Gnosis Safe
2. Set multiple owner addresses
3. Require at least 2 confirmations before transactions execute

Use Case: Protects DeFi protocols, DAOs, and NFT projects from a single point of failure.

8.6 Real-Time Security Monitoring with Alchemy Notify API

Alchemy Notify API can detect suspicious activity in real time.

Set Up a Wallet Activity Alert

async function createSecurityAlert() {
  const webhook = await alchemy.notify.createWebhook({
    webhookUrl: "https://yourserver.com/webhook",
    eventType: "ADDRESS_ACTIVITY",
    address: "0xYourWalletAddress",
  });

  console.log("Security Alert Set:", webhook);
}
createSecurityAlert();

Use Case: Get alerts for large withdrawals, unauthorized transactions, or contract exploits.

8.7 Conclusion

Security is critical for Web3 applications. In this chapter, we covered:

How to protect API keys and prevent unauthorized access
Best practices for smart contract security
How to prevent gas fee manipulation and front-running
Using multi-signature wallets for added security
Setting up real-time security alerts with Alchemy Notify

By following these security best practices, developers can build safer and more resilient DApps.

9. Alchemy for NFT Applications

Non-Fungible Tokens (NFTs) have transformed digital ownership in industries like art, gaming, collectibles, and virtual real estate. Alchemy provides powerful NFT APIs to help developers create, manage, and analyze NFTs efficiently.

In this chapter, we’ll explore:
How to create and deploy an NFT smart contract
Using Alchemy NFT API to fetch metadata and ownership details
Building an NFT marketplace or gallery
Optimizing NFT transactions and gas fees

9.1 Understanding NFT Standards (ERC-721 vs ERC-1155)

NFTs follow Ethereum token standards to ensure interoperability across platforms.

🔹 Best Practice: Use ERC-721 for unique NFTs and ERC-1155 for gaming assets.

9.2 Creating and Deploying an NFT Smart Contract

To create an NFT collection, you need a smart contract that defines the NFT minting, ownership, and metadata storage.

🔹 Step 1: Install Required Dependencies

npm install --save-dev hardhat @openzeppelin/contracts dotenv

🔹 Step 2: Create an ERC-721 Smart Contract

Inside the contracts/ folder, create MyNFT.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MyNFT is ERC721URIStorage, Ownable {
    uint256 private _tokenIdCounter;

    constructor() ERC721("MyNFTCollection", "MYNFT") {}

    function mintNFT(address recipient, string memory tokenURI) public onlyOwner {
        uint256 newTokenId = _tokenIdCounter;
        _mint(recipient, newTokenId);
        _setTokenURI(newTokenId, tokenURI);
        _tokenIdCounter++;
    }
}

🔹 What This Does:

• mintNFT() creates a new NFT and assigns metadata.
• Uses Ownable so only the contract owner can mint.

🔹 Step 3: Deploy the Smart Contract Using Alchemy

Modify hardhat.config.js to include Alchemy API:

require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config();

module.exports = {
  solidity: "0.8.19",
  networks: {
    goerli: {
      url: process.env.ALCHEMY_API_URL,
      accounts: [process.env.PRIVATE_KEY],
    },
  },
};

🔹 Deploy the contract:

npx hardhat run scripts/deploy.js --network goerli

9.3 Fetching NFT Metadata Using Alchemy NFT API

Alchemy NFT API provides faster and more efficient NFT data retrieval.

🔹 Fetch NFTs Owned by a Wallet

const { Alchemy, Network } = require("@alch/alchemy-sdk");

const alchemy = new Alchemy({
  apiKey: process.env.ALCHEMY_API_KEY,
  network: Network.ETH_MAINNET,
});

async function getWalletNFTs(walletAddress) {
  const nfts = await alchemy.nft.getNftsForOwner(walletAddress);
  console.log("Owned NFTs:", nfts);
}

getWalletNFTs("0xYourWalletAddress");

🔹 Use Case: Display NFT collections in wallet apps or marketplaces.

🔹 Fetch NFT Metadata

async function getNFTMetadata(contractAddress, tokenId) {
  const metadata = await alchemy.nft.getNftMetadata(contractAddress, tokenId);
  console.log("NFT Metadata:", metadata);
}

getNFTMetadata("0xYourNFTContractAddress", "1");

🔹 Use Case: Fetch image, name, and attributes for NFT galleries.

9.4 Building an NFT Marketplace with Alchemy

🔹 Features of an NFT Marketplace

1. Fetch and display NFTs from Alchemy NFT API
2. Allow users to buy/sell NFTs
3. Enable minting of new NFTs

🔹 Step 1: Setting Up a React NFT Gallery

Install dependencies:

npx create-react-app nft-gallery
cd nft-gallery
npm install ethers @alch/alchemy-sdk dotenv

Modify App.js:

import { useState } from "react";
import { Alchemy, Network } from "@alch/alchemy-sdk";

const alchemy = new Alchemy({
  apiKey: process.env.REACT_APP_ALCHEMY_API_KEY,
  network: Network.ETH_MAINNET,
});

function App() {
  const [nfts, setNfts] = useState([]);

  async function fetchNFTs() {
    const response = await alchemy.nft.getNftsForOwner("0xYourWalletAddress");
    setNfts(response.ownedNfts);
  }

  return (
    <div>
      <button onClick={fetchNFTs}>Load NFTs</button>
      {nfts.map((nft, index) => (
        <div key={index}>
          <h3>{nft.title}</h3>
          <img src={nft.media[0]?.gateway} alt={nft.title} />
        </div>
      ))}
    </div>
  );
}

export default App;

🔹 Use Case: Displays NFT collections dynamically.

9.5 Optimizing NFT Transactions and Gas Fees

🔹 Reduce Minting Costs with Lazy Minting

Lazy minting delays minting until purchase, reducing gas fees.

function lazyMint(address buyer, uint256 tokenId, string memory uri) public {
    _safeMint(buyer, tokenId);
    _setTokenURI(tokenId, uri);
}

🔹 Use Case: Lowers initial deployment costs for NFT projects.

🔹 Use Polygon for Cheaper NFT Transactions

Polygon offers lower fees than Ethereum for NFT transactions.

Modify hardhat.config.js:

networks: {
  polygon: {
    url: process.env.ALCHEMY_POLYGON_API_URL,
    accounts: [process.env.PRIVATE_KEY],
  },
}

Deploy to Polygon:

npx hardhat run scripts/deploy.js --network polygon

🔹 Use Case: Reduces minting and trading costs.

9.6 Monitoring NFT Transactions with Alchemy Notify API

Use Alchemy Notify API to alert users about NFT sales or transfers.

🔹 Set Up an NFT Transfer Webhook

async function createNFTTransferAlert() {
  const webhook = await alchemy.notify.createWebhook({
    webhookUrl: "https://yourserver.com/webhook",
    eventType: "NFT_ACTIVITY",
    contractAddress: "0xYourNFTContract",
  });

  console.log("NFT Transfer Alert Set:", webhook);
}

createNFTTransferAlert();

🔹 Use Case: Sends notifications for NFT sales, bids, or transfers.

9.7 Conclusion

Alchemy simplifies NFT development with powerful APIs and scalable solutions. In this chapter, we covered:

Creating and deploying an NFT smart contract
Fetching NFT metadata and ownership details with Alchemy NFT API
Building an NFT gallery using React and Alchemy
Optimizing NFT minting costs with Polygon and lazy minting
Monitoring NFT transfers with real-time alerts

With these tools, developers can build scalable and cost-effective NFT applications.

10. Alchemy and DeFi

Decentralized Finance (DeFi) is one of the most impactful use cases of blockchain technology. It replaces traditional financial intermediaries with smart contracts, enabling permissionless and transparent services such as lending, borrowing, staking, trading, and yield farming.

Alchemy provides developers with the infrastructure and APIs needed to build, scale, and monitor robust DeFi applications with low latency, real-time insights, and secure execution.

10.1 Core DeFi Concepts & How Alchemy Fits In

Before diving into code, here are the key components of a DeFi app and how Alchemy supports each:

10.2 Reading DeFi Token Data with Alchemy

DeFi apps often need to track token balances, transfers, and approvals.

🔹 Get ERC-20 Token Balances for a Wallet

const { Alchemy, Network } = require("@alch/alchemy-sdk");

const alchemy = new Alchemy({
  apiKey: process.env.ALCHEMY_API_KEY,
  network: Network.ETH_MAINNET,
});

async function getDeFiBalances(wallet) {
  const result = await alchemy.core.getTokenBalances(wallet);
  console.log("Token Balances:", result.tokenBalances);
}

getDeFiBalances("0xYourDeFiUserWallet");

🔹 Use Case: Track user portfolio values across multiple tokens.

10.3 Tracking Wallet Activity for DeFi Users

With Alchemy, you can monitor wallet activity in real time, a critical feature for DeFi dashboards.

🔹 Listen for Transactions with WebSockets

const ws = new WebSocket("wss://eth-mainnet.ws.alchemy.com/v2/YOUR_API_KEY");

ws.on("open", () => {
  ws.send(
    JSON.stringify({
      jsonrpc: "2.0",
      id: 1,
      method: "eth_subscribe",
      params: ["newPendingTransactions"],
    })
  );
});

ws.on("message", (data) => {
  const tx = JSON.parse(data);
  console.log("New pending transaction:", tx);
});

🔹 Use Case: Alert users when their transactions hit the mempool.

10.4 Using Alchemy Notify for Real-Time DeFi Alerts

Set up webhooks to notify users of critical actions, such as collateral liquidation, token transfers, or interest payouts.

🔹 Create a Notify Webhook

async function setupWebhook() {
  const webhook = await alchemy.notify.createWebhook({
    webhookUrl: "https://your-app.com/deFi-webhook",
    eventType: "ADDRESS_ACTIVITY",
    address: "0xUserDeFiWallet",
  });

  console.log("Webhook created:", webhook);
}

🔹 Use Case: Instant user notifications for position changes or rewards.

10.5 Interfacing with DeFi Protocols (e.g., Aave, Uniswap)

Most major DeFi protocols are deployed as public smart contracts. With Alchemy + Ethers.js, you can interact directly with them.

🔹 Example: Fetching Data from Aave Pool

const AAVE_POOL_ABI = [ /* simplified ABI */ ];
const AAVE_POOL_ADDRESS = "0xYourAavePool";

const provider = new ethers.JsonRpcProvider(process.env.ALCHEMY_API_URL);
const contract = new ethers.Contract(AAVE_POOL_ADDRESS, AAVE_POOL_ABI, provider);

async function getReserveData(assetAddress) {
  const data = await contract.getReserveData(assetAddress);
  console.log("Aave Reserve Data:", data);
}

🔹 Use Case: Display interest rates, liquidity, or user deposits in your app.

10.6 Optimizing Transactions in DeFi Apps

Alchemy helps you optimize DeFi transactions using:

✅ Gas Fee Estimation

async function estimateGasForSwap() {
  const gas = await alchemy.core.estimateGas({
    to: "0xUniswapRouter",
    data: "0x...", // calldata for swapExactTokensForETH
  });

  console.log(`Estimated Gas: ${gas}`);
}

✅ Fast Confirmation with Alchemy Transact

async function sendOptimizedTx() {
  const tx = await alchemy.transact.sendGasOptimizedTransaction({
    to: "0xAaveLendingPool",
    value: "0.2", // ETH
    gasLimit: "21000",
  });

  console.log("Transaction Hash:", tx.hash);
}

🔹 Use Case: Reduce slippage and transaction failures in high-traffic situations.

10.7 DeFi Use Case: Building a Yield Tracker

Let’s combine APIs to create a DeFi yield dashboard:

1. Fetch all user tokens
2. Listen for incoming reward transactions
3. Alert when new yield is received
4. Display token value over time using gas-efficient queries

Tools You’ll Use:

• alchemy.core.getTokenBalances()
• alchemy.notify.createWebhook()
• alchemy.core.getTransactionReceipt()

🔹 Goal: Build a live dashboard that tracks user gains across protocols.

10.8 Conclusion

Alchemy provides a comprehensive toolkit for building, scaling, and monitoring DeFi applications.

In this chapter, you learned to:

Read token balances and DeFi data using Alchemy
Monitor transactions and wallet activity in real time
Use Notify API for user alerts and yield notifications
Optimize DeFi transactions for lower cost and faster confirmation
Interface with major protocols like Aave and Uniswap

With these tools, you can build high-performance, gas-optimized, and secure DeFi experiences.

11. Tools and Developer Resources

To build robust and production-ready Web3 applications with Alchemy, it's essential to leverage the wide range of developer tools, resources, and community support available. In this chapter, you’ll learn how to:

• Use Alchemy Monitor for performance tracking
• Access comprehensive documentation and API references
• Join the Alchemy developer community
• Explore starter kits, tutorials, and learning paths
• Get help through support channels and integrations

11.1 Alchemy Monitor: Track API Usage and App Health

Alchemy Monitor is a real-time dashboard that helps developers:

• Track API usage and error rates
• Analyze request types and patterns
• Identify performance bottlenecks
• Detect failed transactions or misconfigured DApps

How to Access Alchemy Monitor

1. Go to dashboard.alchemy.com
2. Select your app
3. Click on the Monitor tab

Key Metrics Available

• Total and daily API requests
• Response times and error logs
• Network performance (e.g., latency, gas trends)
• Smart contract invocation analytics

🔹 Use Case: Ensures that your DApp is scalable, reliable, and production-ready.

11.2 Official Alchemy Documentation and API Reference

Alchemy provides clear, detailed, and well-maintained documentation for all its services.

Explore the Docs:

📘 https://docs.alchemy.com

You'll find:

• API references for Supernode, NFT API, WebSockets, Transact, and Notify
• SDK usage examples in JavaScript, Python, and REST
• Guides on NFTs, DeFi, Layer 2s, and more

🔹 Use Case: Use the docs as your go-to resource for integrating Alchemy with any Web3 tech stack.

11.3 Developer Starter Kits and Templates

Alchemy offers ready-made boilerplates and starter projects to help you go from zero to launch faster.

Popular Starter Kits

• NFT Gallery Starter
  → React + Alchemy NFT API + Tailwind
• DeFi Dashboard Starter
  → Ethers.js + Alchemy + Aave Protocol
• Hardhat Boilerplate
  → Full-stack smart contract + frontend with Alchemy SDK
• Alchemy + Next.js + Wallet Connect
  → Great for wallet-based login and token dashboards

🔹 Explore on GitHub:
🧱 https://github.com/alchemyplatform

11.4 Tutorials and Learning Resources

Whether you're a beginner or advanced developer, Alchemy provides interactive tutorials and learning paths.

Learning Platforms

• Alchemy University – Free, in-depth curriculum for Web3 developers
  → https://university.alchemy.com
• YouTube Channel – Step-by-step project builds and feature deep dives
• Blog Posts & Case Studies – Learn from real-world projects and their architectures
  → https://www.alchemy.com/blog

🔹 Use Case: Perfect for onboarding new devs or teams into Web3 and the Alchemy ecosystem.

11.5 Community and Developer Support

Join thousands of Web3 builders and get support from the Alchemy engineering team and community.

Community Channels

• Alchemy Discord: discord.gg/alchemy
• Alchemy Twitter: @AlchemyPlatform
• Developer Forum: Ask questions, post solutions, and engage with the ecosystem

Support Options

• Live chat inside the Alchemy dashboard
• Email support for paid plans
• Status updates at status.alchemyapi.io

🔹 Use Case: Great for quick troubleshooting, announcements, and getting unstuck.

11.6 Integrations with Popular Dev Tools

Alchemy is compatible with major Web3 frameworks and dev tools, including:

🔹 Use Case: Easily plug Alchemy into existing tech stacks for faster builds.

11.7 Feature Requests and Beta Programs

Alchemy actively builds with its developer community. You can:

• Submit feature requests or API enhancements
• Join beta programs to test new features like private mempool access, NFT indexing, or L2 integrations

🔹 Track new releases:
🛠 https://alchemy.com/changelog

11.8 Conclusion

Alchemy offers a rich set of tools and community resources to help Web3 developers build smarter, faster, and with confidence.

In this chapter, you explored:
Alchemy Monitor for app performance tracking
Extensive documentation and learning resources
Starter kits, tutorials, and free courses
Community support and developer tools integration
Early access to new features through beta programs

With these resources, you're fully equipped to build production-grade blockchain applications powered by Alchemy.