# Zora - Creator Economy & NFT L2 Documentation

## Zora RPC plans and rate limits

- **Free plan:** 20 responses per second, up to 100,000 responses a day.
- **Plans:** $49/mo, $299/mo, $999/mo with 25M, 150M, and 500M included responses. Overages billed at $5/$3/$2 per million responses respectively.
- **Paid rate limits:** 100 to 5,000 responses per second (bursts from 500 to 10,000), no daily limit.
- **Billing:** 1 response = 1 API credit on every shared plan, over HTTPS or WebSocket (WSS) where Zora supports it.

Details: [Pricing](https://www.dwellir.com/docs/getting-started/pricing) · [Rate limits](https://www.dwellir.com/docs/getting-started/rate-limits) · [Authentication](https://www.dwellir.com/docs/getting-started/authentication) · [Archive nodes](https://www.dwellir.com/docs/getting-started/archive-nodes)

## Why Build on Zora?

Zora is the leading Ethereum Layer 2 optimized for creators, NFTs, and onchain media. Built on Optimism's OP Stack, Zora offers the perfect infrastructure for the creator economy:

### **Creator-First Design**

- **0.000777 ETH mint rewards** - Get rewarded for onchain activity
- **Gas-optimized NFT operations** - Efficient minting, trading, and transfers
- **Built-in creator tools** - Native support for royalties and revenue sharing

### **Lightning Fast & Affordable**

- **2-second block times** - Near-instant NFT transactions
- **Ultra-low fees** - Mint NFTs for pennies, not dollars
- **EIP-4844 enabled** - Leveraging blob data for maximum cost efficiency

### **Battle-Tested Infrastructure**

- **OP Stack security** - Inherits Ethereum's security guarantees
- **7777777 Chain ID** - Lucky sevens for the creator economy
- **Ethereum compatibility** - Use existing tools and wallets

### **Thriving NFT Ecosystem**

- **Zora Protocol integration** - Native NFT marketplace functionality
- **Creator rewards system** - Earn from every mint and interaction
- **Major creator adoptions** - Home to top artists and projects

## Quick Start with Zora

Connect to Zora's creator-optimized infrastructure in seconds:

### Installation & Setup

Ethers.js v6
Web3.js
Viem

```javascript
import { JsonRpcProvider } from 'ethers';

// Connect to Zora mainnet
const provider = new JsonRpcProvider(
  'https://api-zora-mainnet.n.dwellir.com/YOUR_API_KEY'
);

// Get the latest block
const block = await provider.getBlock('latest');
console.log('Latest block:', block.number);

// Query account balance
const balance = await provider.getBalance('0x...');
console.log('Balance:', balance.toString());
```

```javascript
const Web3 = require('web3');

// Connect to Zora mainnet
const web3 = new Web3(
  'https://api-zora-mainnet.n.dwellir.com/YOUR_API_KEY'
);

// Get chain ID to verify connection
const chainId = await web3.eth.getChainId();
console.log('Connected to Zora:', chainId === 7777777);

// Get gas price for optimal NFT transactions
const gasPrice = await web3.eth.getGasPrice();
console.log('Current gas price:', gasPrice);
```

```typescript
import { createPublicClient, http } from 'viem';
import { zora } from 'viem/chains';

// Create Zora client
const client = createPublicClient({
  chain: zora,
  transport: http('https://api-zora-mainnet.n.dwellir.com/YOUR_API_KEY'),
});

// Read NFT contract data
const data = await client.readContract({
  address: '0x...',
  abi: erc721Abi,
  functionName: 'tokenURI',
  args: [1],
});
```

## Network Information

| Parameter    | Value     | Details      |
| ------------ | --------- | ------------ |
| Chain ID     | 7777777   | Mainnet      |
| Block Time   | 2 seconds | Average      |
| Gas Token    | ETH       | Native token |
| RPC Standard | Ethereum  | JSON-RPC 2.0 |

## API Reference

Zora supports the full [Ethereum JSON-RPC API specification](https://ethereum.org/developers/docs/apis/json-rpc/) plus OP Stack L2 optimizations for creator applications.

## Creator-Focused Integration Patterns

### NFT Minting & Management

Efficiently mint and manage NFTs on Zora:

```javascript
// Mint NFT with creator rewards
async function mintNFTWithRewards(contract, to, tokenURI) {
  const tx = {
    to: contract.address,
    data: contract.interface.encodeFunctionData('mint', [to, tokenURI]),
    // Zora rewards: 0.000777 ETH per mint
    value: parseEther('0.000777')
  };

  const receipt = await provider.sendTransaction(tx);

  // Check for creator reward distribution
  const rewardEvents = receipt.logs.filter(log =>
    log.topics[0] === creatorRewardEventSignature
  );

  return { receipt, rewards: rewardEvents };
}
```

### Real-time NFT Tracking

Monitor NFT transfers and marketplace activity:

```javascript
// Watch for NFT transfers in real-time
const nftFilter = {
  address: contractAddress,
  topics: [
    '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef', // Transfer
    null, // from (any)
    null  // to (any)
  ]
};

provider.on(nftFilter, (log) => {
  const transfer = parseLog(log);
  console.log(`NFT ${transfer.tokenId} transferred from ${transfer.from} to ${transfer.to}`);
});
```

### Creator Revenue Optimization

Track and optimize creator earnings:

```javascript
// Calculate total creator rewards
async function getCreatorEarnings(creatorAddress, fromBlock = 0) {
  const rewardFilter = {
    address: ZORA_REWARDS_CONTRACT,
    topics: [
      '0x...', // RewardPaid event signature
      ethers.utils.hexZeroPad(creatorAddress, 32)
    ]
  };

  const logs = await provider.getLogs({
    ...rewardFilter,
    fromBlock,
    toBlock: 'latest'
  });

  const totalRewards = logs.reduce((sum, log) => {
    const reward = parseLog(log);
    return sum.add(reward.amount);
  }, BigNumber.from(0));

  return totalRewards;
}
```

### Advanced NFT Querying

Query NFT metadata and ownership efficiently:

```javascript
// Batch query NFT metadata
async function getNFTBatch(contractAddress, tokenIds) {
  const contract = new Contract(contractAddress, erc721Abi, provider);
  const batchSize = 50; // Zora recommended batch size

  const results = [];
  for (let i = 0; i < tokenIds.length; i += batchSize) {
    const batch = tokenIds.slice(i, i + batchSize);

    const promises = batch.map(async (tokenId) => ({
      tokenId,
      owner: await contract.ownerOf(tokenId),
      tokenURI: await contract.tokenURI(tokenId),
    }));

    const batchResults = await Promise.all(promises);
    results.push(...batchResults);
  }

  return results;
}
```

## Performance Best Practices for Creators

### 1. **Optimize NFT Operations**

Use efficient patterns for high-volume NFT operations:

```javascript
// Batch mint for gas efficiency
async function batchMintNFTs(contract, recipients, tokenURIs) {
  const batchData = recipients.map((to, i) =>
    contract.interface.encodeFunctionData('mint', [to, tokenURIs[i]])
  );

  const multicallData = contract.interface.encodeFunctionData('multicall', [batchData]);

  return await contract.multicall(batchData, {
    value: parseEther((0.000777 * recipients.length).toString())
  });
}
```

### 2. **Smart Caching for Metadata**

Cache NFT metadata to improve user experience:

```javascript
const metadataCache = new Map();

async function getCachedMetadata(tokenURI) {
  if (!metadataCache.has(tokenURI)) {
    const response = await fetch(tokenURI);
    const metadata = await response.json();
    metadataCache.set(tokenURI, metadata);
  }

  return metadataCache.get(tokenURI);
}
```

### 3. **Event-Driven Architecture**

Build responsive creator tools with event listeners:

```javascript
// Listen for all creator-relevant events
const eventFilters = [
  { topics: [transferEventSignature] }, // NFT transfers
  { topics: [mintEventSignature] },     // New mints
  { topics: [saleEventSignature] },     // Marketplace sales
  { topics: [rewardEventSignature] }    // Creator rewards
];

eventFilters.forEach(filter => {
  provider.on(filter, handleCreatorEvent);
});

function handleCreatorEvent(log) {
  const eventType = identifyEventType(log);

  switch(eventType) {
    case 'TRANSFER':
      updateOwnershipRecords(log);
      break;
    case 'MINT':
      trackNewCreation(log);
      break;
    case 'SALE':
      updateCreatorEarnings(log);
      break;
    case 'REWARD':
      distributeMintRewards(log);
      break;
  }
}
```

## Troubleshooting Creator Applications

### Error: "Insufficient mint reward"

Zora requires 0.000777 ETH for creator rewards on mints:

```javascript
// Always include mint reward in NFT transactions
const mintTx = {
  to: nftContract.address,
  data: mintData,
  value: parseEther('0.000777'), // Required for Zora rewards
  gasLimit: 100000n
};
```

### Error: "Token does not exist"

Handle NFT queries gracefully for better UX:

```javascript
async function safeGetTokenURI(contract, tokenId) {
  try {
    return await contract.tokenURI(tokenId);
  } catch (error) {
    if (error.reason === 'ERC721: invalid token ID') {
      return null; // Token doesn't exist yet
    }
    throw error; // Re-throw other errors
  }
}
```

### Error: "Rate limit exceeded"

Implement retry logic for high-volume creator applications:

```javascript
async function mintWithRetry(contract, params, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await contract.mint(...params);
    } catch (error) {
      if (error.code === 429 && i < maxRetries - 1) {
        const delay = Math.min(2 ** i * 1000, 10000); // Cap at 10s
        await new Promise(r => setTimeout(r, delay));
      } else {
        throw error;
      }
    }
  }
}
```

## Migration Guide

### From Ethereum Mainnet

Moving NFT projects from L1 to Zora L2:

```javascript
// Before (Ethereum L1)
const provider = new JsonRpcProvider('https://eth-rpc.example.com');

// After (Zora L2)
const provider = new JsonRpcProvider(
  'https://api-zora-mainnet.n.dwellir.com/YOUR_API_KEY'
);

// Same NFT standards (ERC-721, ERC-1155)
// Same tooling and libraries work
// Dramatically lower fees
// Note: Different chain ID (7777777)
// Note: Creator rewards system (0.000777 ETH)
// Note: L1 data fees apply
```

### From Polygon

Zora offers better creator economics than Polygon:

```javascript
// Enhanced creator benefits on Zora:
// - Built-in mint rewards (0.000777 ETH per mint)
// - Lower gas fees than Polygon
// - Native creator tools and royalty enforcement
// - Better Ethereum ecosystem integration
```

## Creator Tools & Resources

### Official Resources

- [Zora Documentation](https://docs.zora.co)
- [Zora Explorer](https://explorer.zora.energy)

### Creator Tools

- [Zora Create](https://zora.co/create) - Easy NFT minting
- [Creator Toolkit](https://github.com/ourzora/zora-protocol) - Smart contract templates

### Developer Resources

- [Zora Documentation](https://docs.zora.co)

### Need Help?

- **Email**: <support@dwellir.com>
- **Docs**: You're here!
- **Dashboard**: [dashboard.dwellir.com](https://dashboard.dwellir.com)

***

*Start building the future of the creator economy on Zora with Dwellir's enterprise-grade RPC infrastructure. [Get your API key](https://dashboard.dwellir.com/register)*
