Zapper API

https://protocol.zapper.xyz
Admin
Zapper API is an enterprise-grade GraphQL API that provides comprehensive blockchain data including...
Tokens:443,812
Snippets:1,566
Trust Score:7.5
Update:8 months ago
Show doc for...
Tokens:
Raw
### GraphQL Pagination - Next Page Request

Source: https://protocol.zapper.xyz/docs/api/endpoints/utility/apps

This example shows how to request subsequent pages of results in a GraphQL API. It includes the 'first' argument to specify the number of items and the 'after' argument with a cursor to indicate the starting point for the next page. This enables efficient traversal of large datasets.

```json
{
  "first": 25,
  "after": "NERIRCszMzc5Njd"
}
```

--------------------------------

### Zapper API GET Response Example

Source: https://protocol.zapper.xyz/docs/api/resources/legacy-api-docs

This JSON structure represents a successful GET request to the Zapper API for fetching app balances. It includes details about the wallet address, application, network, total balance in USD, and a breakdown of products with their associated assets, tokens, and their respective balances and prices.

```json
[
    {
        "key": "597563987",
        "address": "0xe321bd63cde8ea046b382f82964575f2a5586474",
        "appId": "sushiswap",
        "appName": "SushiSwap",
        "appImage": "https://storage.googleapis.com/zapper-fi-assets/apps/sushiswap.png",
        "network": "ethereum",
        "updatedAt": "2023-01-26T22:51:36.215Z",
        "balanceUSD": 84.1847791577147,
        "products": [
            {
                "label": "Pools",
                "assets": [
                    {
                        "key": "2041256716",
                        "type": "app-token",
                        "appId": "sushiswap",
                        "groupId": "pool",
                        "network": "ethereum",
                        "address": "0xceff51756c56ceffca006cd410b03ffc46dd3a58",
                        "tokens": [
                            {
                                "type": "base-token",
                                "network": "ethereum",
                                "address": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599",
                                "symbol": "WBTC",
                                "decimals": 8,
                                "price": 23042,
                                "balance": 0.00035964,
                                "balanceRaw": "35964",
                                "balanceUSD": 8.28682488
                            },
                            {
                                "type": "base-token",
                                "network": "ethereum",
                                "address": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
                                "symbol": "WETH",
                                "decimals": 18,
                                "price": 1604.44,
                                "balance": 0.005167346483200388,
                                "balanceRaw": "5167346483200388",
                                "balanceUSD": 8.290697391506031
                            }
                        ],
                        "symbol": "SLP"
                    }
                ]
            }
        ]
    }
]

```

--------------------------------

### x402 Authentication Example Client

Source: https://protocol.zapper.xyz/docs/api/x402

An example client implementation demonstrating how to use x402 authentication with the Zapper API for making requests and handling payments.

```APIDOC
## POST /x402/token-price

### Description
This endpoint is used to query token prices, authenticated via the x402 protocol. The example demonstrates setting up the x402 client, signing with a private key, and wrapping an Axios instance for payment.

### Method
POST

### Endpoint
/x402/token-price

### Parameters
#### Query Parameters
None

#### Request Body
- **variables** (object) - Required - An object containing the query variables.
  - **address** (string) - Required - The token address.
  - **chainId** (number) - Required - The chain ID for the token.

### Request Example
```json
{
  "variables": {
    "address": "0xbe19c96f5deec29a91ca84e0d038d4bb01d098cd",
    "chainId": 8453
  }
}
```

### Response
#### Success Response (200)
- **data** (object) - The response data containing token price information.

#### Response Example
```json
{
  "data": {
    "tokenPrice": {
      "price": 0.000001 // Example price
    }
  }
}
```
```

--------------------------------

### Example Variables for ComputeAppBalances

Source: https://protocol.zapper.xyz/docs/api/resources/legacy-queries

An example of the variables object for the computeAppBalances mutation, demonstrating how to include multiple addresses and networks for app balance computation.

```json
{
  "input": {
    "addresses": [
      "0x123...", 
      "Habp5bncMSsBC3vkChyebepym5dcTNRYeg2LVG464E96"
    ],
    "networks": ["ETHEREUM_MAINNET", "SOLANA_MAINNET"]
  }
}
```

--------------------------------

### Example Variables for Claimables

Source: https://protocol.zapper.xyz/docs/api/endpoints/portfolio

This JSON object shows example variables that can be used when querying for claimable tokens. It includes a list of addresses and a limit for the number of results.

```json
{
  "addresses": ["0x849151d7d0bf1f34b70d5cad5149d28cc2308bf1"],
  "first": 5
}
```

--------------------------------

### Example Variables for ComputeTokenBalances

Source: https://protocol.zapper.xyz/docs/api/resources/legacy-queries

Provides an example of the variables object used when calling the computeTokenBalances mutation. It specifies the addresses and networks for which to compute token balances.

```json
{
  "input": {
    "addresses": ["Habp5bncMSsBC3vkChyebepym5dcTNRYeg2LVG464E96"],
    "networks": ["BITCOIN_MAINNET", "SOLANA_MAINNET"]
  }
}
```

--------------------------------

### Example Variables for Portfolio Query

Source: https://protocol.zapper.xyz/docs/api/endpoints/portfolio

These are example variables for the `TokenBalances` GraphQL query. They specify the addresses to query, the number of results to return (`first`), optional chain IDs, and optional filters like `minBalanceUSD`.

```json
{
  "addresses": ["0x849151d7d0bf1f34b70d5cad5149d28cc2308bf1"],
  "first": 5,
  "chainIds": [8453],
  "filters": {"minBalanceUSD": 10}
}
```

--------------------------------

### Pagination Examples

Source: https://protocol.zapper.xyz/docs/api/endpoints/utility/apps

Illustrates how to implement pagination for fetching data, including the first page and subsequent pages.

```APIDOC
## Pagination Examples

### Description
Examples demonstrating how to structure requests for paginated data retrieval.

### First Page
To fetch the first page of results, include the `first` argument to specify the number of items.

#### Request Example
```json
{
  "first": 25
}
```

### Next Page
To fetch subsequent pages, include both `first` and `after` arguments, where `after` is the cursor from the previous page's `endCursor`.

#### Request Example
```json
{
  "first": 25,
  "after": "NERIRCszMzc5Njd"
}
```
```

--------------------------------

### Get Exchange Quote (cURL)

Source: https://protocol.zapper.xyz/docs/api/resources/legacy-api-docs

Example of how to fetch exchange quote data using cURL. This request includes parameters for gas, token addresses, amounts, owner, slippage, and network. It requires an Authorization header.

```bash
cURL -X 'GET' \
  'https://api.zapper.xyz/v2/exchange/quote?gasPrice=35000000000&maxFeePerGas=40000000000&maxPriorityFeePerGas=1000000000&sellTokenAddress=0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48&buyTokenAddress=0x0000000000000000000000000000000000000000&sellAmount=1000000&ownerAddress=0xe321bd63cde8ea046b382f82964575f2a5586474&slippagePercentage=0.03&network=ethereum' \
  -H 'accept: */*' \
  -H 'Authorization: Basic sadkfljsdafksal24uh2jk34=='
```

--------------------------------

### Fetch App Balances via GET Request

Source: https://protocol.zapper.xyz/docs/api/resources/legacy-api-docs

This snippet shows how to use a GET request to fetch balance information for applications associated with a wallet address. Similar to the POST request, it requires an Authorization header and targets the same API endpoint. The response is a JSON array containing detailed balance and product information.

```bash
cURL -X 'GET' \
  'https://api.zapper.xyz/v2/balances/apps?addresses%5B%5D=0xe321bD63CDE8Ea046b382f82964575f2A5586474' \
  -H 'accept: */*' \
  -H 'Authorization: Basic sadkfljsdafksal24uh2jk34=='

```

--------------------------------

### Get Collection Metadata using nftCollectionsV2 (JSON)

Source: https://protocol.zapper.xyz/docs/api/endpoints/nft-queries/nft-collections

This example demonstrates how to request detailed metadata for NFT collections using the `nftCollectionsV2` endpoint. It requires an array of collection objects, each specifying the NFT contract address and the chain ID. The response includes paginated NFT data, sales and mint history, market cap, floor price, holder lists, and social links.

```json
{
  "collections": [
    {
      "address": "0xa449b4f43d9a33fcdcf397b9cc7aa909012709fd",
      "chainId": 8453
    }
  ]
}
```

--------------------------------

### Fetch Portfolio Data with React and Apollo Client

Source: https://protocol.zapper.xyz/docs/api

This example demonstrates how to fetch token balances for a given address on the Ethereum mainnet using React and Apollo Client. It sets up an Apollo Client instance with authentication and queries the `portfolioV2` endpoint to retrieve token details, including balance, raw balance, balance in USD, symbol, and name. The data is then rendered in a list format.

```javascript
import { ApolloClient, InMemoryCache, createHttpLink, gql, useQuery, ApolloProvider } from '@apollo/client';  
import { setContext } from '@apollo/client/link/context';  
  
interface TokenNode {  
  balance: number;  
  balanceRaw: string;  
  balanceUSD: number;  
  symbol: string;  
  name: string;  
}  
  
interface TokenEdge {  
  node: TokenNode;  
}  
  
interface PortfolioV2Data {  
  portfolioV2: {  
    tokenBalances: {  
      byToken: {  
        edges: TokenEdge[];  
      }  
    }  
  };  
}  
  
// Set up Apollo Client  
const httpLink = createHttpLink({  
  uri: 'https://public.zapper.xyz/graphql',  
});  
  
const API_KEY = 'YOUR_API_KEY';  
  
const authLink = setContext((_, { headers }) => {  
  return {  
    headers: {  
      ...headers,  
      'x-zapper-api-key': API_KEY,  
    },  
  };  
});  
  
const client = new ApolloClient({  
  link: authLink.concat(httpLink),  
  cache: new InMemoryCache(),  
});  
  
const PortfolioV2Query = gql`  
  query PortfolioV2($addresses: [Address!]!, $networks: [Network!]) {  
    portfolioV2(addresses: $addresses, networks: $networks) {  
      tokenBalances {  
        byToken {  
          edges {  
            node {  
              balance  
              balanceRaw  
              balanceUSD  
              symbol  
              name  
            }  
          }  
        }  
      }  
    }  
  }  
`;  
  
function Portfolio() {  
  const { loading, error, data } = useQuery<PortfolioV2Data>(PortfolioV2Query, {  
    variables: {  
      addresses: ['0x3d280fde2ddb59323c891cf30995e1862510342f'],  
      networks: ['ETHEREUM_MAINNET'],  
    },  
  });  
  
  if (loading) return <div>Loading...</div>;  
  if (error) return <div>Error: {error.message}</div>;  
  if (!data) return <div>No data found</div>;  
  
  return (  
    <div className="p-4">  
      {data.portfolioV2.tokenBalances.byToken.edges.map((edge, index) => (  
        <div key={`${edge.node.symbol}-${index}`} className="mb-4 p-4 border rounded">  
          <p>Token: {edge.node.name}</p>  
          <p>Symbol: {edge.node.symbol}</p>  
          <p>Balance: {edge.node.balance}</p>  
          <p>Raw Balance: {edge.node.balanceRaw}</p>  
          <p>Value (USD): ${edge.node.balanceUSD.toFixed(2)}</p>  
        </div>  
      ))}  
    </div>  
  );  
}  
  
function App() {  
  return (  
    <ApolloProvider client={client}>  
      <Portfolio />  
    </ApolloProvider>  
  );  
}  
  
export default App;  

```

--------------------------------

### GET /v2/balances/tokens

Source: https://protocol.zapper.xyz/docs/api/resources/legacy-api-docs

Retrieves cached token balances for the specified wallet addresses. This is a cost-effective way to get balance information if the cache is up-to-date.

```APIDOC
## GET /v2/balances/tokens

### Description
Retrieves cached "base token" balances for the specified wallet addresses. "Base tokens" are native ERC20 tokens in a wallet that are not invested in an application.

### Method
GET

### Endpoint
`https://api.zapper.xyz/v2/balances/tokens`

### Parameters
#### Query Parameters
- **addresses[]** (array of strings) - Required - Wallet addresses for which to retrieve balances. Can handle up to 15 addresses. Example syntax: `?addresses[]=address_1&addresses[]=address_2`
- **networks[]** (array of strings) - Optional - Networks for which to retrieve balances. Available values: `ethereum`, `polygon`, `optimism`, `gnosis`, `binance-smart-chain`, `fantom`, `avalanche`, `arbitrum`, `celo`, `moonriver`, `bitcoin`, `aurora`

### Request Example
```
GET https://api.zapper.xyz/v2/balances/tokens?addresses[]=0x...&addresses[]=0x...
```

### Response
#### Success Response (200)
- **key** (string) - Unique identifier for aggregating token balances across addresses.
- **address** (string) - The wallet address the position is for.
- **network** (string) - The network the token is on.
- **updatedAt** (integer) - Timestamp of when the balance was last calculated. Used to determine cache staleness.
- **token** (object) - Object containing token details:
    - **id** (string) - Internal token ID.
    - **networkId** (string) - Internal network ID.
    - **address** (string) - Token's contract address on the network.
    - **name** (string) - Token's display name.
    - **symbol** (string) - Token's symbol.
    - **price** (number) - Current price of the token in USD.
    - **balance** (number) - The user's balance of the token.
    - **decimals** (integer) - The number of decimal places for the token.
    - **displayBalance** (string) - The user's balance formatted as a string.
    - **displayValue** (string) - The user's balance formatted as a string with USD value.

#### Response Example
```json
[
  {
    "key": "ethereum:0x...:0x...",
    "address": "0x...",
    "network": "ethereum",
    "updatedAt": 1678886400,
    "token": {
      "id": "ethereum:0x...",
      "networkId": "ethereum",
      "address": "0x...",
      "name": "USD Coin",
      "symbol": "USDC",
      "price": 1.00,
      "balance": 1000.00,
      "decimals": 6,
      "displayBalance": "1,000.00",
      "displayValue": "$1,000.00"
    }
  }
]
```
```

--------------------------------

### Transaction History V2 Example Filters

Source: https://protocol.zapper.xyz/docs/api/endpoints/human-readable-transactions/transaction-history

An example JSON object demonstrating how to apply filters to the transactionHistoryV2 endpoint. This example shows filtering by multiple chain IDs, a specific token, sender, receiver, transaction categories, and a contract address.

```json
{
  "filters": {
    "chainIds": [8453, 1],
    "tokenAddress": ["0x833589fcd6edb6e08f4c7c32d4f71b54bda02913"],
    "receivedFrom": ["0x52c8ff44260056f896e20d8a43610dd88f05701b"],
    "sentTo": ["0x9b3a20176d2c5d0a22dae382496416a1a8934b30"],
    "categories": ["Swap", "Bridge", "Nft_Mint", "Nft_Sale"],
    "contractAddress": ["0x03059433bcdb6e08f4c7c32d4f71b54bda02913"]
  }
}

```

--------------------------------

### GraphQL Pagination - First Page Request

Source: https://protocol.zapper.xyz/docs/api/endpoints/utility/apps

This example demonstrates how to request the first page of results in a GraphQL API. It specifies the number of items to retrieve using the 'first' argument. This is a common pattern for paginating through lists of data.

```json
{
  "first": 25
}
```

--------------------------------

### Implement x402 Authentication Client with Axios

Source: https://protocol.zapper.xyz/docs/api/x402

Demonstrates setting up an Axios client with x402 payment integration. It initializes the x402 client, registers an EVM signing scheme using a private key, and wraps the Axios instance to handle payment headers automatically. This allows making API requests that are automatically paid for using USDC on the selected chain.

```javascript
import axios from 'axios';
import { x402Client, wrapAxiosWithPayment } from '@x402/axios';
import { registerExactEvmScheme } from '@x402/evm/exact/client';
import { privateKeyToAccount } from 'viem/accounts';

async function main() {
  const privateKey = 'YOUR_PRIVATE_KEY';

  const client = new x402Client();
    
  const signer = privateKeyToAccount(privateKey);
  registerExactEvmScheme(client, { signer });
  
  const api = wrapAxiosWithPayment(
    axios.create({
      baseURL: 'https://public.zapper.xyz',
      headers: { 'Content-Type': 'application/json' },
    }),
    client
  );
  
  const response = await api.post('/x402/token-price', {
    variables: {
      address: '0xbe19c96f5deec29a91ca84e0d038d4bb01d098cd',
      chainId: 8453,
    },
  });
  
  console.log('response:', response.data.data);
}

main().catch(console.error);

```

--------------------------------

### GET /v2/balances/apps

Source: https://protocol.zapper.xyz/documentation

Get balances of different supported applications for a specific address. This endpoint retrieves the aggregated balances across various DeFi applications for one or more Ethereum addresses.

```APIDOC
## GET /v2/balances/apps

### Description
Get balances of different supported applications for a specific address. This endpoint retrieves the aggregated balances across various DeFi applications for one or more Ethereum addresses.

### Method
GET

### Endpoint
/v2/balances/apps

### Parameters
#### Query Parameters
- **addresses[]** (array of strings) - Required - Addresses for which to retrieve balances.
- **networks[]** (array of strings) - Optional - Enum: "ethereum" "polygon" "optimism" "gnosis" "binance-smart-chain" "fantom" "avalanche" "arbitrum" "celo" "harmony" "moonriver" "bitcoin" "cronos" "aurora" "evmos" "base" "blast" "solana" "degen" "mode" "zksync" "mantle" "scroll" "moonbeam" "linea" "zora" "metis" "worldchain" "shape" "opbnb" "apechain" "morph" "bob" "unichain" "core" "race" "frax" "b2" "taiko" "cyber" "zero" "immutablex" "arbitrum-nova" "xai" "redstone" "polygonzkevm" "flow" "ink" "sonic" "soneium" "abstract" "rootstock" "berachain" "story" "ronin" "lens" "superseed" "hyperevm" "astar" "hyperliquid" "monad" - Networks for which to retrieve balances.

### Responses
#### Success Response (200)
- **balances** (object) - An object containing balances for each address and network.

#### Response Example
```json
{
  "balances": {
    "0x123...": {
      "ethereum": {
        "totalValue": "1500.50",
        "tokens": [
          {
            "address": "0x...",
            "symbol": "USDC",
            "amount": "1000",
            "value": "1000"
          }
        ]
      }
    }
  }
}
```
```

--------------------------------

### Example Variables for App Positions Query

Source: https://protocol.zapper.xyz/docs/api/endpoints/portfolio

These are example variables to be used with the `GetAppPositions` GraphQL query. They specify the account addresses to query, the number of results to retrieve (`first`), and optionally filter results by network chain IDs.

```json
{
  "addresses": ["0xaf06a5ee843215e156e1b42efbc4de5404607164"],
  "first": 5,
  "chainIds": [8453] 
}
```

--------------------------------

### GET /v2/balances/jobs/{jobId}

Source: https://protocol.zapper.xyz/documentation

Gets the status of a single balance computation job. Use this endpoint to check the progress or completion status of a balance recomputation triggered by the POST /v2/balances/apps endpoint.

```APIDOC
## GET /v2/balances/jobs/{jobId}

### Description
Gets the status of a single balance computation job. Use this endpoint to check the progress or completion status of a balance recomputation triggered by the POST /v2/balances/apps endpoint.

### Method
GET

### Endpoint
/v2/balances/jobs/{jobId}

### Parameters
#### Query Parameters
- **jobId** (string) - Required - Id of the job for which to retrieve the status.

### Responses
#### Success Response (200)
- **status** (string) - The status of the job (e.g., "pending", "processing", "completed", "failed").
- **progress** (number) - The completion percentage of the job.

#### Response Example
```json
{
  "status": "completed",
  "progress": 100
}
```
```

--------------------------------

### Job Status Response Example

Source: https://protocol.zapper.xyz/docs/api/resources/legacy-api-docs

This is an example of the JSON response received when querying the job status. It includes the `jobId` that was requested and the current `status` of the computation job, which can be 'active', 'completed', or 'unknown'.

```json
{
    "jobId": "f7a84c5d-8605-4ad5-8c5e-ae65e07cfafd",
    "status": "active"
}
```

--------------------------------

### Get Supported Apps via cURL

Source: https://protocol.zapper.xyz/docs/api/resources/legacy-api-docs

This snippet demonstrates how to query the Zapper API to retrieve a list of supported applications for a given wallet address. It uses cURL for the request and includes necessary headers like 'accept' and 'Authorization'. The output is a JSON array containing app details for different networks.

```bash
cURL -X 'GET' \
  'https://api.zapper.xyz/v2/apps/balances/supported?addresses%5B%5D=0xd8da6bf26964af9d7eed9e03e53415d37aa96045' \
  -H 'accept: */*' \
  -H 'Authorization: Basic sadkfljsdafksal24uh2jk34=='

```

--------------------------------

### Fetching API Schema and Instructions

Source: https://protocol.zapper.xyz/docs/api/agents

You can programmatically fetch the API schema and usage instructions for use with agents or other tools.

```APIDOC
## Fetching API Schema and Instructions

### Description
This endpoint allows you to retrieve the complete API schema and usage instructions, which can be useful for agents or for building tools that interact with the Zapper API.

### Method
GET

### Endpoint
`https://protocol.zapper.xyz/agents.txt`

### Parameters
None

### Request Example
```bash
curl https://protocol.zapper.xyz/agents.txt
```

### Response
#### Success Response (200)
The response will be a plain text file containing:
- Developer Assistant Instructions
- Autonomous Agent Instructions
- Farcaster Onchain Context information
- Complete API Schema

#### Response Example
(Content will be a large text block containing the schema and instructions, similar to the input provided.)
```

--------------------------------

### Fetch Farcaster Portfolio Data with React and Apollo Client

Source: https://protocol.zapper.xyz/docs/api/endpoints/farcaster/farcaster-portfolio

This example demonstrates fetching portfolio data for a Farcaster ID (FID) and username. It utilizes Apollo Client to interact with the Zapper GraphQL API. The code first queries for account addresses using FIDs and usernames, then uses these addresses to fetch token balances. It includes type definitions for GraphQL responses, Apollo Client setup with authentication, and a React component to render the portfolio data, handling loading and no-data states.

```javascript
import { ApolloClient, InMemoryCache, createHttpLink, gql, useQuery, ApolloProvider } from '@apollo/client';  
import { setContext } from '@apollo/client/link/context';  
  
// Types for the GraphQL responses  
interface BaseToken {  
  name: string;  
  symbol: string;  
}  
  
interface Token {  
  balance: string;  
  balanceUSD: number;  
  baseToken: BaseToken;  
}  
  
interface TokenBalance {  
  address: string;  
  network: string;  
  token: Token;  
}  
  
interface PortfolioData {  
  portfolio: {  
    tokenBalances: TokenBalance[];  
  };  
}  
  
interface AccountsData {  
  accounts: {  
    address: string;  
  }[];  
}  
  
// Set up Apollo Client  
const httpLink = createHttpLink({  
  uri: 'https://public.zapper.xyz/graphql',  
});  
  
const API_KEY = 'YOUR_API_KEY';  
  
const authLink = setContext((_, { headers }) => {  
  return {  
    headers: {  
      ...headers,  
      'x-zapper-api-key': API_KEY,  
    },  
  };  
});  
  
const client = new ApolloClient({  
  link: authLink.concat(httpLink),  
  cache: new InMemoryCache(),  
});  
  
const AccountsQuery = gql`  
  query($fids: [Float!], $farcasterUsernames: [String!]) {  
    accounts(fids: $fids, farcasterUsernames: $farcasterUsernames) {  
      address  
    }  
  }  
`;  
  
const PortfolioQuery = gql`  
  query providerPorfolioQuery($addresses: [Address!]!, $networks: [Network!]!) {  
    portfolio(addresses: $addresses, networks: $networks) {  
      tokenBalances {  
        address  
        network  
        token {  
          balance  
          balanceUSD  
          baseToken {  
            name  
            symbol  
          }  
        }  
      }  
    }  
  }  
`;  
  
function Portfolio() {  
  // First, fetch the addresses  
  const { loading: addressesLoading, data: addressesData } = useQuery<AccountsData>(AccountsQuery, {  
    variables: {  
      fids: [177],  
      farcasterUsernames: ['jasper'],  
    },  
  });  
  
  // Then use the addresses to fetch portfolio data  
  const { loading: portfolioLoading, data: portfolioData } = useQuery<PortfolioData>(PortfolioQuery, {  
    variables: {  
      addresses: addressesData?.accounts.map((account) => account.address) || [],  
      networks: ['ETHEREUM_MAINNET'],  
    },  
    skip: !addressesData,  
  });  
  
  // Handle loading states  
  if (addressesLoading || portfolioLoading) return <div>Loading...</div>;  
  
  // Handle no data  
  if (!addressesData || !portfolioData) return <div>No data found</div>;  
  
  return (  
    <div className="p-4">  
      <h2 className="text-xl font-bold mb-4">Portfolio Data for {addressesData.accounts.length} Addresses</h2>  
  
      {portfolioData.portfolio.tokenBalances.map((balance, index) => (  
        <div key={`${balance.address}-${index}`} className="mb-4 p-4 border rounded shadow-sm">  
          <p className="font-semibold">Token: {balance.token.baseToken.name}</p>  
          <p>Symbol: {balance.token.baseToken.symbol}</p>  
          <p>Balance: {balance.token.balance}</p>  
          <p>Value (USD): ${balance.token.balanceUSD.toFixed(2)}</p>  
          <p>Network: {balance.network}</p>  
          <p className="text-sm text-gray-600">Address: {balance.address}</p>  
        </div>  
      ))}  
    </div>  
  );  
}  
  
function App() {  
  return (  
    <ApolloProvider client={client}>  
      <Portfolio />  
    </ApolloProvider>  
  );  
}  
  
export default App;  
```

--------------------------------

### Example Response for Apps Query (JSON)

Source: https://protocol.zapper.xyz/docs/api/endpoints/utility/apps

This JSON object represents a sample response from the 'apps' GraphQL endpoint. It contains a list of application edges, each with a cursor and node data including ID, slug, display name, URL, description, image URL, and category information. It also includes the total count of applications and pagination details.

```json
{
    "data": {
        "apps": {
            "edges": [
                {
                    "cursor": "QWRyYXZlIEdhbWUrMzM4MTQz",
                    "node": {
                        "id": "QXBwT2JqZWN0LTMzODE0Mw==",
                        "slug": "adrave-game",
                        "displayName": "Adrave Game",
                        "url": "https://adravegame.com/",
                        "links": null,
                        "description": "The world has entered a new technological age where artificial intelligence, robotics, and cybernetic enhancements have fundamentally reshaped society. Humanity now stands on the brink of a new reality, where machine intelligence challenges human existence",
                        "imgUrl": "https://storage.googleapis.com/zapper-fi-assets/apps%2Fadrave-game.png",
                        "categoryId": 12,
                        "category": {
                            "__typename": "AppCategoryObject",
                            "name": "Gaming",
                            "description": "Blockchain gaming integrates blockchain technology into video games, allowing for the creation, ownership, and trading of in-game assets as NFTs, enabling players to have true ownership and the ability to trade or sell their digital items outside the game's ecosystem."
                        }
                    }
                },
                {
                    "cursor": "QWQgV29ybGQrMzM2OTY5",
                    "node": {
                        "id": "QXBwT2JqZWN0LTMzNjk2OQ==",
                        "slug": "rainbow-world",
                        "displayName": "Ad World",
                        "url": "https://adworld.game/",
                        "links": null,
                        "description": "Rainbow World by Rainbow & AdWorld. ⭐️ Mint👇Customize 🌟 Create 💛\n",
                        "imgUrl": "https://storage.googleapis.com/zapper-fi-assets/apps%2Frainbow-world.png",
                        "categoryId": 14,
                        "category": {
                            "__typename": "AppCategoryObject",
                            "name": "Art",
                            "description": "Onchain art refers to digital artworks that are created, stored, and traded directly on the blockchain, ensuring immutable provenance, ownership, and security through decentralized technology."
                        }
                    }
                }
            ],
            "totalCount": 1655,
            "pageInfo": {
                "startCursor": "QWRyYXZlIEdhbWUrMzM4MTQz",
                "endCursor": "QWQgV29ybGQrMzM2OTY5",
                "hasNextPage": true
            }
        }
    }
}
```

--------------------------------

### Example Variables for Portfolio Query

Source: https://protocol.zapper.xyz/docs/api/endpoints/portfolio

Provides example variables for a GraphQL query, specifying addresses and the number of results to fetch. This is commonly used with portfolio-related queries.

```json
{
  "addresses": ["0x849151d7d0bf1f34b70d5cad5149d28cc2308bf1"],
  "first": 20
}
```

--------------------------------

### Query App Positions by Account and Token

Source: https://protocol.zapper.xyz/docs/api/endpoints/portfolio

This example demonstrates how to query on-chain application positions, specifically focusing on positions related to a given account address and optionally filtering by network. It utilizes GraphQL fragments to differentiate between fungible token positions and contract-based positions, allowing access to specific fields for each type.

```graphql
query GetAppPositions($addresses: [String!]!, $first: Int, $chainIds: [Int!]) {
  protocolZapper {
    appBalances(addresses: $addresses, first: $first, chainIds: $chainIds) {
      byAccount {
        edges {
          node {
            accountAddress
            balance
            balanceUSD
            balanceRaw
            account {
              address
            }
            # Use fragments to access specific position types
            ... on AppTokenPositionBalance {
              type
              price
              symbol
              tokens {
                address
                decimals
                symbol
                name
              }
            }
            ... on ContractPositionBalance {
              type
              tokens {
                address
                decimals
                symbol
                name
                metaType
              }
              displayProps
            }
          }
        }
      }
    }
  }
}
```

--------------------------------

### Get All Apps Details (cURL)

Source: https://protocol.zapper.xyz/docs/api/resources/legacy-api-docs

This cURL command fetches detailed information for all applications listed on Zapper. It requires an authorization token for access and returns a JSON array containing app metadata.

```shell
cURL -X 'GET' \
  'https://api.zapper.xyz/v2/apps' \
  -H 'accept: */*' \
  -H 'Authorization: Basic sadkfljsdafksal24uh2jk34=='

```

--------------------------------

### Example Variables for NFT Metadata Query

Source: https://protocol.zapper.xyz/docs/api/endpoints/nft-queries/nft-token

These are example variables to be used with the `NFTMetadata` GraphQL query. They specify the `collectionAddress`, `chainId`, and `tokenId` for the NFT you want to query.

```json
{
  "collectionAddress": "0xb47e3cd837ddf8e4c57f05d70ab865de6e193bbb",
  "chainId": 1,
  "tokenId": "7495"
}
```

--------------------------------

### Get App Metadata via cURL

Source: https://protocol.zapper.xyz/docs/api/resources/legacy-api-docs

This snippet demonstrates how to fetch metadata for a specific application using the cURL command-line tool. It requires the application's slug as a path parameter and an authorization token in the header. The response is a JSON object containing details about the app.

```bash
cURL -X 'GET' \
  'https://api.zapper.xyz/v2/apps/aave-v3' \
  -H 'accept: */*' \
  -H 'Authorization: Basic sadkfljsdafksal24uh2jk34=='
```

--------------------------------

### Example Variables for Account Identity Query

Source: https://protocol.zapper.xyz/docs/api/endpoints/onchain-identity

These JSON variables provide an example of the input format required for the `accounts` query, specifically a list of blockchain addresses.

```json
{
  "addresses": [
    "0x52c8ff44260056f896e20d8a43610dd88f05701b",
    "0xd8da6bf26964af9d7eed9e03e53415d37aa96045"
  ]
}
```

--------------------------------

### GraphQL Query for Portfolio Data

Source: https://protocol.zapper.xyz/docs/api/agents

This TypeScript example demonstrates a GraphQL query to fetch portfolio data, specifically token balances, for given addresses. It includes variables for addresses and limits the number of tokens returned.

```typescript
const query = `
  query PortfolioV2Query($addresses: [Address!]!) {
    portfolioV2(addresses: $addresses) {
      tokenBalances {
        totalBalanceUSD
        byToken(first: 10) {
          edges {
            node {
              symbol
              balance
              balanceUSD
              imgUrlV2
              network {
                name
              }
            }
          }
        }
      }
    }
  }
`;

const variables = {
  addresses: ['0x...']
};
```
Tokens:
Raw