# Data from Chain to Database (Aave Example) — Part 1
Source: https://docs.indexing.co/examples/aave_pt1



In this two-part guide, we’ll walk through how to build an onchain data indexing pipeline from scratch using The Indexing Company’s infrastructure. By the end of this series, you’ll have a live pipeline deployed in **The Neighborhood**, the distributed data network built by The Indexing Company, and streaming onchain events from the Aave protocol into your own database or webhook.

We'll also provide a [**Postman collection**](https://github.com/indexing-co/docs/blob/main/examples/Aave_Pipeline_to_Database_Example.postman_collection.json) so you can follow along step-by-step. For each command in this guide, we'll reference its name as found in the Postman collection.

In **Part 1**, we’ll focus on:

* Setting up a contract address filter
* Writing transformation code to decode key contract events
* Testing and registering the transformation for pipeline use

In **Part 2**, we’ll:

* Set up a target database or webhook
* Create a data schema using transformation output
* Deploy the full pipeline and verify that the data is flowing

### The Example Contract: Aave Pool

For this tutorial, we’ll be indexing events from the **Aave Pool contract**, which emits all the core supply, borrow, repay, and liquidation events. You can find its documentation and ABI here:

* [Aave Pool contract ABI](https://aave.com/docs/developers/smart-contracts/pool)
* [Etherscan link](https://etherscan.io/address/0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2)

You can extract event signatures from either the ABI or directly from Etherscan. We recommend verifying or formatting them with an LLM to ensure they match the expected Solidity format used by The Indexing Company. [Follow this Event Extraction Example for tips](/examples/evm_event_sigs).

***

### Step 1: Set up a contract address filter

**Postman Command Name**: `1. Create Contract Filter`

The first step is to define which contracts your pipeline should listen to. If no filter is applied, the transformation code will be applied to all blocks. In our case, we’ll be indexing events from the [Aave Pool contract](https://etherscan.io/address/0x87870bca3f3fd6335c3f4ce8392d69350b4fa4e2).

To register this contract as a filter, send the following `curl` request:

```bash theme={null}
curl --location 'https://app.indexing.co/dw/filters/aave_example_filter' \
--header 'X-API-KEY: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{"values": [
    "0x87870bca3f3fd6335c3f4ce8392d69350b4fa4e2"
]}'

```

This creates a named filter called `aave_example_filter` that targets the Aave Pool contract. You can confirm it was created by calling:

**Postman Command Name**: `2. Get Contract Filters`

```bash theme={null}
curl --location 'https://app.indexing.co/dw/filters/aave_example_filter' \
--header 'X-API-KEY: YOUR_API_KEY'

```

If you need to remove the filter later:

**Postman Command Name**: `3. Delete Contract Filter`

```bash theme={null}
curl --location --request DELETE 'https://app.indexing.co/dw/filters/aave_example_filter' \
--header 'X-API-KEY: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{"values": [
    "0x87870bca3f3fd6335c3f4ce8392d69350b4fa4e2"
]}'

```

***

### Step 2: Write transformation code

**JavaScript Filename**: `AavePool.js`

Now that the contract filter is set up, it’s time to define the logic to extract relevant onchain events. The Indexing Company supports transformation functions written in JavaScript, which operate on each block. We will decode logs and format events for downstream use. For an instruction to find and transform these events visit our (Event Extraction Example)\[/examples/evm\_event\_sigs].

Below is the transformation code we’ll use to extract key Aave Pool events:

```jsx theme={null}
function AaveEvents(block) {
  const events = [];

  for (const tx of block.transactions || []) {
    for (const log of tx.receipt?.logs || []) {
      const decodedWithMetadata = utils.evmDecodeLogWithMetadata(log, [
        "event Supply(address indexed reserve, address user, address indexed onBehalfOf, uint256 amount, uint16 indexed referralCode)",
        "event Withdraw(address indexed reserve, address indexed user, address indexed to, uint256 amount)",
        "event Borrow(address indexed reserve, address user, address indexed onBehalfOf, uint256 amount, uint8 interestRateMode, uint256 borrowRate, uint16 indexed referralCode)",
        "event Repay(address indexed reserve, address indexed user, address indexed repayer, uint256 amount, bool useATokens)",
        "event FlashLoan(address indexed target, address initiator, address indexed asset, uint256 amount, uint8 interestRateMode, uint256 premium, uint16 indexed referralCode)",
        "event UserEModeSet(address indexed user, uint8 categoryId)",
        "event LiquidationCall(address indexed collateralAsset, address indexed debtAsset, address indexed user, uint256 debtToCover, uint256 liquidatedCollateralAmount, address liquidator, bool receiveAToken)",
        "event ReserveDataUpdated(address indexed reserve, uint256 liquidityRate, uint256 stableBorrowRate, uint256 variableBorrowRate, uint256 liquidityIndex, uint256 variableBorrowIndex)"
      ]);

      if (decodedWithMetadata) {
        events.push({
          chain: block._network,
          block: block.number,
          transaction_hash: tx.hash,
          log_index: log.logIndex,
          contract_address: log.address?.toLowerCase(),
          decoded: decodedWithMetadata.decoded,
          event_name: decodedWithMetadata.metadata?.name.replace(/^event\s+/, '') || 'UnknownEvent'
        });
      }
    }
  }

  return events;
}
```

We’ll test this transformation in the next step using a historical block and verify that it extracts the correct Aave Pool events before registering it into the system.

***

### Step 3: Test the transformation

**Postman Command Name**: `4a. Test Transformation (JS code upload)` or `4b. Test Transformation (JS code as Text)`

Before registering your transformation into a live pipeline, it's essential to test it against real onchain data. The Indexing API provides a `/transformations/test` endpoint that lets you simulate a run using a specific block number and your contract filter. We are using [this transaction](https://etherscan.io/tx/0xc0814c035946d6889497a82d6515647f939f1dfe5d86d46c4294b3c6b127bad7) to test on.
To get the `network`you look up the Network Key [here](/networks). We are testing this on [Ethereum](https://docs.indexing.co/networks/overview) at block 22282149 (called beat in the API).

Use the following `curl` to test the transformation code:

```bash theme={null}
curl --location --globoff 'https://app.indexing.co/dw/transformations/test?network=ethereum&beat=22282149&filter=aave_example_filter&filterKeys[0]=contract_address' \
--header 'X-API-KEY: YOUR_API_KEY' \
--form 'code=@"AavePool.js"'

```

If you're using Postman:

* Select `POST`
* Set the URL with the correct query parameters
* Go to **Body > form-data**, set key to `code`, type `Text`, and paste in your transformation code OR set type `File` and upload the `AavePool.js` file.

This test will return a JSON response with decoded logs for that block. Make sure your expected events (e.g., `Supply`, `Borrow`, etc.) show up correctly.

For block `22282149` on Ethereum, you should receive an output similar to the following:

```json theme={null}
[
    {
        "chain": "ETHEREUM",
        "block": 22282149,
        "transaction_hash": "0xc0814c035946d6889497a82d6515647f939f1dfe5d86d46c4294b3c6b127bad7",
        "log_index": 534,
        "contract_address": "0x87870bca3f3fd6335c3f4ce8392d69350b4fa4e2",
        "decoded": {
            "reserve": "0xD533a949740bb3306d119CC777fa900bA034cd52",
            "onBehalfOf": "0x3f3B17da678a495EbEc8a061657Cb6CFa4901531",
            "referralCode": 0,
            "user": "0x3f3B17da678a495EbEc8a061657Cb6CFa4901531",
            "amount": "15000000000000000000000"
        },
        "event_name": "Supply"
    }
]

```

***

### Step 4: Register the transformation

**Postman Command Name**: `5a. Register Transformation (JS code upload)` or `5b. Register Transformation (JS code as Text)`

Once you’ve confirmed your transformation code works correctly, you can register it for production use. This saves the code under a unique transformation ID, allowing you to reference it in the pipeline setup.

Use the following `curl` to register the transformation:

```bash theme={null}
curl --location 'https://app.indexing.co/dw/transformations/aave_example' \
--header 'X-API-KEY: YOUR_API_KEY' \
--form 'code="function AaveEvents(block) { ... }"'  # paste the full function here

```

In Postman:

* Select `POST`
* Use the same endpoint URL
* Under **Body > form-data**, key should be `code`, set type to `Text`, and paste your transformation function OR set type `File` and upload the `AavePool.js` file.

Once registered, your transformation is ready to be used in a full indexing pipeline in **The Neighborhood**.

***

## What’s Next?

In [**Part 2**](/examples/aave_pt2), we’ll continue by wiring up the destination: setting up a database or webhook, generating a schema from your transformation output, and deploying the full pipeline.

Need help getting started or want to integrate indexing into your stack?

* Reach out to us at [indexing.co/contact](https://www.indexing.co/contact)
* Or email us at [**hello@indexing.co**](mailto:hello@indexing.co)


# Data from Chain to Database (Aave Example) — Part 2
Source: https://docs.indexing.co/examples/aave_pt2



In [Part 1](/examples/aave_pt1), we set up a contract filter for the Aave Pool, wrote transformation logic to extract onchain events, and registered it for use in a pipeline. In this second and final part, we’ll walk through deploying the full pipeline and streaming your data into a database or webhook endpoint.

We'll be using **Postman** again, but only for the final pipeline deployment step. The rest of the setup will be done using CLI tools or through your preferred database and development environment.

Here’s what we’ll cover:

1. Set up a database
2. Create a schema based on transformation output
3. Deploy the pipeline with destination credentials
4. Confirm data is flowing

***

### Step 4a: Set up a database or webhook

Before deploying the pipeline, you need to define a destination where data will be streamed.

In this guide, we’ll use **PostgreSQL** as our example target. However, The Indexing Company supports many output adapters, organized into categories:

* **Databases & Warehouses** — PostgreSQL (example), MySQL, SQLite, BigQuery, Firestore, MongoDB, Neo4j, Arango
* **Event Streams & Queues** — Kafka, Kinesis, Pulsar, GCP PubSub
* **Cloud Storage & APIs** — AWS S3, GCP Cloud Storage (GCS), HTTP / Webhook

➡️ You can find the full list of supported destinations [in our adapter directory](https://www.notion.so/16e25f031053805da10cf65179f977c6?pvs=21).

Need support for a destination you don’t see listed? We can add custom adapters — just reach out to us at [**hello@indexing.co**](mailto:hello@indexing.co).

### PostgreSQL Setup

To follow along with this example:

* Spin up a Postgres instance (local or hosted)
* Create a table or database for the data
* Make sure it’s accessible (e.g., by IP allowlisting The Indexing Company)

Next, we’ll define the schema based on the output of your transformation function.

***

### Step 5: Generate a schema from transformation output

Before deploying your pipeline, you need to define a table schema that aligns with the output of your transformation code.

The fastest way to do this is by taking the test output from [Part 1, Step 3](/examples/aave_pt1), and using that JSON object to generate a PostgreSQL schema.

Here’s a sample output from the transformation:

```json theme={null}
{
  "chain": "ETHEREUM",
  "block": 22282149,
  "transaction_hash": "0xc0814c035946d6889497a82d6515647f939f1dfe5d86d46c4294b3c6b127bad7",
  "log_index": 534,
  "contract_address": "0x87870bca3f3fd6335c3f4ce8392d69350b4fa4e2",
  "decoded": {
    "reserve": "0xD533a949740bb3306d119CC777fa900bA034cd52",
    "onBehalfOf": "0x3f3B17da678a495EbEc8a061657Cb6CFa4901531",
    "referralCode": 0,
    "user": "0x3f3B17da678a495EbEc8a061657Cb6CFa4901531",
    "amount": "15000000000000000000000"
  },
  "event_name": "Supply"
}

```

If you're creating a table from scratch, you can do it with a single SQL command. Here's the schema fit for the current pipeline.

```sql theme={null}
CREATE TABLE AavePool (
    chain TEXT NOT NULL,
    block BIGINT NOT NULL,
    transaction_hash TEXT NOT NULL,
    log_index INTEGER NOT NULL,
    contract_address TEXT NOT NULL,
    decoded JSONB NOT NULL,
    event_name TEXT NOT NULL,
    created_at TIMESTAMPTZ DEFAULT now(),
    PRIMARY KEY (chain, transaction_hash, log_index)
);

```

This setup avoids using generated IDs for deterministic data — a common trap. Instead, it uses a unique combination of `chain`, `transaction_hash`, and `log_index` as the primary key.

Because The Indexing Company’s pipelines guarantee **at-least-once delivery**, duplicates can occur during retries. The unique key constraint ensures that only one version of each event is stored reliably.

Make sure the schema matches the structure and types you expect to receive at scale. Once ready, you're good to move on to deployment.

💡 You can use tools like ChatGPT or `jsonschema2ddl` to help generate your table schema from a JSON example like the one above. Here’s a [quick tutorial including the prompts](/examples/pipeline_to_postgres).

***

### Step 6: Deploy the pipeline

**Postman Command Name**: `6. Deploy Pipeline`

With the transformation logic, contract filter, and destination schema ready, you can now deploy the full pipeline. This step registers all components together so The Indexing Company can begin streaming data from the blockchain to your destination.

You’ll need to provide:

* The transformation ID (`aave_example` if following [Part 1](/examples/aave_pt1))
* The filter name (`aave_example_filter`) and filterKeys. The FilterKey is the parameter to filter on. In our case the `contract_address`
* The `networks` in this case `ethereum` , but feel free to add other chains if the event signatures and contracts filters apply on those too, like `base`
* The destination type (e.g. `postgres`, `webhook`, etc.)
* Destination connection credentials (e.g. database URI or webhook URL)

Here’s an example `curl` to deploy a pipeline to PostgreSQL:

```bash theme={null}
curl --location 'https://app.indexing.co/dw/pipelines/' \
--header 'X-API-KEY: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data-raw '{
    "name": "aave_example_pipeline",
    "transformation": "aave_example",
    "filter": "aave_example_filter",
    "filterKeys": [
        "contract_address"
    ],
    "networks": [
        "ethereum"
    ],
    "enabled": true,
    "delivery": {
        "adapter": "POSTGRES",
        "connectionUri": "postgresql://user:password@host:5432/database",
        "table": "aavepool",
        "uniqueKeys": [
            "chain", "transaction_hash", "log_index"
        ]
    }
}'
```

In Postman:

* Set the request type to **POST**
* Use the URL: `https://app.indexing.co/dw/pipelines/`
* Go to **Body > raw > JSON** and paste in the payload above

Once submitted, The Neighborhood will begin streaming data for every new block that matches your filter and passes your transformation.

***

### Step 7: Confirm data is flowing

Once your pipeline is live, it's time to verify that your data is arriving.

For PostgreSQL:

* Connect to your database
* Run a simple query like:

```
SELECT * FROM AavePool ORDER BY block DESC LIMIT 10;
```

You should see a stream of new rows appearing in real time as new blocks and events are indexed.

If you don’t see data:

* Double-check your filter, transformation, and table name
* Make sure your database is accessible and credentials are correct
* Review logs (if available) or reach out for help

***

## That’s a wrap!

You’ve now built and deployed a full onchain data pipeline to **The Neighborhood**, the distributed indexing network by The Indexing Company — from contract filtering to transformation, schema generation, and live delivery.

If you have any questions, need help configuring a destination, or want to request a new adapter:

* Reach out at [indexing.co/contact](https://www.indexing.co/contact)
* Or email us at [**hello@indexing.co**](mailto:hello@indexing.co)

We’d love to hear what you’re building!


# Work with Arbitrum data
Source: https://docs.indexing.co/examples/arbitrum



## Introduction

Arbitrum is available on The Neighborhood and indexed in real time, delivered to you. This guide shows you how to stream Arbitrum data into your own database or webhook using the same raw API that powers every pipeline, and how to skip straight to a working setup with the ready-made [Arbitrum templates](https://console.indexing.co/templates) in the Console.

The network key is `ARBITRUM`. You can preview the raw data at any time here: [jiti.indexing.co/networks/ARBITRUM/latest](https://jiti.indexing.co/networks/ARBITRUM/latest). See the [Arbitrum network page](/networks/arbitrum) for status.

## Prerequisites

You'll need:

* A Neighborhood API key. To get access, sign up at [**accounts.indexing.co**](https://accounts.indexing.co) or email [**hello@indexing.co**](mailto:hello@indexing.co)
* curl or Postman, or the [Console](https://console.indexing.co)
* A destination: an active Postgres database, a webhook (grab a temporary one at [webhook.site](https://webhook.site/)), or Kafka

## Start From a Template

The fastest way to work with Arbitrum data is to start from one of the Arbitrum [templates](https://console.indexing.co/templates) in the Console. Each one ships with a transformation and a deployment config, runs on Arbitrum out of the box, and can be customized before you deploy. The same templates are usable against the raw API.

| Template                      | What it captures                                                              | Delivery |
| ----------------------------- | ----------------------------------------------------------------------------- | -------- |
| Arbitrum DEX Swaps            | Swap events on Uniswap V3 and Camelot/Algebra pools on Arbitrum               | Postgres |
| Arbitrum Lending Events       | Aave-compatible (Aave V3 and Radiant) lending events on Arbitrum              | Postgres |
| Arbitrum Bridge Flows         | Stargate V1 pool swaps and native Arbitrum ETH withdrawals                    | Postgres |
| Arbitrum USDC / USDT Payments | USDC and USDT transfer payments for settlement, checkout, and treasury flows  | Postgres |
| Large Transfer Alerts         | Webhook alerts when Arbitrum USDC or USDT transfers cross an amount threshold | Webhook  |
| Large Bridge Value Alerts     | Webhook alerts when Arbitrum bridge flows exceed 10k USDC/USDT or 5 ETH       | Webhook  |

Pick one in the [template gallery](https://console.indexing.co/templates), adjust any configuration items, and deploy.

## Deploy via the Raw API

If you'd rather drive it from the command line, the flow is the same as any other EVM network. Just target `arbitrum`.

### Step 1: Create a transformation

Here's a transformation that decodes ERC-20 transfers from an Arbitrum block. Save it as `transfers.js`:

```javascript theme={null}
function blockTransfers(block) {
  const transfers = [];

  for (const tx of block.transactions || []) {
    for (const log of tx.receipt?.logs || []) {
      const decoded = utils.evmDecodeLogWithMetadata(log, [
        'event Transfer(address indexed from, address indexed to, uint256 value)',
      ]);

      if (decoded) {
        transfers.push({
          chain: block._network,
          transaction_hash: tx.hash,
          log_index: log.logIndex,
          contract_address: log.address?.toLowerCase(),
          decoded: decoded.decoded,
        });
      }
    }
  }

  return transfers;
}
```

Test it against a real Arbitrum block with the [test](/guide/transformations/test) endpoint:

```bash theme={null}
curl "https://app.indexing.co/dw/transformations/test?network=arbitrum&beat=latest" \
  -H "X-API-KEY: <your-api-key>" \
  -F code=@./transfers.js \
  | jq
```

Once you're happy with the output, commit it with the [create](/guide/transformations/create) endpoint:

```bash theme={null}
curl "https://app.indexing.co/dw/transformations/arbitrum_transfers" \
  -H "X-API-KEY: <your-api-key>" \
  -d code=@./transfers.js \
  | jq
```

### Step 2: Deploy the pipeline

[Create](/guide/pipelines/create) the pipeline targeting `arbitrum`:

```bash theme={null}
curl https://app.indexing.co/dw/pipelines \
  -H "Content-Type: application/json" \
  -H "X-API-KEY: <your-api-key>" \
  -d '{
    "name": "arbitrum_transfers",
    "transformation": "arbitrum_transfers",
    "networks": ["arbitrum"],
    "delivery": {
      "adapter": "HTTP",
      "connection": {
        "host": "<WEBHOOK ENDPOINT>"
      }
    }
  }' \
  | jq
```

<Note>
  Arbitrum is just one network. Add any of the supported [networks](/networks) to the same pipeline during creation. The more the merrier!
</Note>

It should only take a few seconds to begin seeing data flow. Once you're done experimenting, disable the pipeline with `enabled: false`.

## Wrap-Up

You've now set up a real-time stream of Arbitrum data using The Neighborhood, either from a Console template or directly through the raw API. The same templates and endpoints work across every supported network, so you can extend this pipeline to Base, Optimism, Polygon, and more with a one-line change.

Need help or want to go further?

* Start from a template in the [Console](https://console.indexing.co/templates)
* Reach out at [indexing.co/contact](https://www.indexing.co/contact)
* Or email us at [hello@indexing.co](mailto:hello@indexing.co)


# Streaming Clanker Token Deployments
Source: https://docs.indexing.co/examples/clanker_deployments



## Introduction

Clanker is an AI-powered protocol that allows users to deploy ERC-20 tokens instantly on Base, using Farcaster posts, web interfaces like [clanker.world](https://clanker.world/), or Clanker’s developer API. It automates token creation, liquidity provisioning, and fee sharing.

This tutorial shows you how to **stream Clanker token deployments in real time** using The Neighborhood's indexing infrastructure.

**Note:** This tutorial uses a transformation written by Indexing Co that returns the **same data the Clanker team receives** from The Neighborhood. It’s based on all known `TokenCreated` events across Clanker deployment contracts.

## Prerequisites

You’ll need:

* A Neighborhood API key. To get access, sign up at [**accounts.indexing.co**](https://accounts.indexing.co) or email [**hello@indexing.co**](mailto:hello@indexing.co)
* Familiarity with smart contract events
* curl or Postman
* A webhook or database endpoint (optional)

## What You’ll Build

A pipeline that:

1. Listens to Clanker’s `TokenCreated` events
2. Decodes them with the event metadata
3. Streams structured data to a webhook or database

## Step 1: Create a Contract Filter

Clanker’s `TokenCreated` event looks like:

```solidity theme={null}
event TokenCreated(address token, string name, string symbol, uint256 timestamp);
```

To get the Keccak256 hash of the event signature:

```
viem.toEventHash('TokenCreated(address,string,string,uint256)')
```

Then create the [filter](https://docs.indexing.co/guide/filters/add):

```bash theme={null}
curl --request POST \
  --url https://app.indexing.co/dw/filters/clanker-token-deployments \
  --header 'Content-Type: application/json' \
  --header 'X-API-KEY: <your-api-key>' \
  --data '{
    "values": [
      "0xd6f4364f..."  // Replace with actual hash
    ]
  }'
```

## Step 2: Add the Transformation Logic

This logic will give you the same data the Clanker team receives. It supports all known `TokenCreated` variants emitted by Clanker's suite of deployer contracts.

```javascript theme={null}
function main(block) {
  const CLANKER_DEPLOYMENT_EVENTS = [
    {
      address: '0x250c9FB2b411B48273f69879007803790A6AeA47',
      signature:
        'event TokenCreated(address tokenAddress, uint256 lpNftId, address deployer, string name, string symbol, uint256 supply, uint256 _supply, address lockerAddress)',
    },
    {
      address: '0x9B84fcE5Dcd9a38d2D01d5D72373F6b6b067c3e1',
      signature:
        'event TokenCreated(address tokenAddress, uint256 lpNftId, address deployer, uint256 fid, string name, string symbol, uint256 supply, address lockerAddress, string castHash)',
    },
    {
      address: '0x732560fa1d1A76350b1A500155BA978031B53833',
      signature:
        'event TokenCreated(address tokenAddress, uint256 positionId, address deployer, uint256 fid, string name, string symbol, uint256 supply, address lockerAddress, string castHash)',
    },
    {
      address: '0x375C15db32D28cEcdcAB5C03Ab889bf15cbD2c5E',
      signature:
        'event TokenCreated(address tokenAddress, uint256 positionId, address deployer, uint256 fid, string name, string symbol, uint256 supply, string castHash)',
    },
    {
      address: '0x2A787b2362021cC3eEa3C24C4748a6cD5B687382',
      signature:
        'event TokenCreated(address indexed tokenAddress,address indexed creatorAdmin, address indexed interfaceAdmin, address creatorRewardRecipient, address interfaceRewardRecipient, uint256 positionId, string name, string symbol, int24 startingTickIfToken0IsNewToken, string metadata, uint256 amountTokensBought, uint256 vaultDuration, uint8 vaultPercentage, address msgSender )',
    },
  ];

  const createdTokens = [];
  for (const tx of block.transactions) {
    if (!tx.receipt) continue;

    for (const log of tx.receipt.logs) {
      const decoded = utils.evmDecodeLog(log, CLANKER_DEPLOYMENT_EVENTS);
      if (decoded) {
        createdTokens.push({
          __filter_key: log.address,
          contract_address: decoded.tokenAddress,
          fid: decoded.fid,
          deployed_at: new Date(parseInt(block.timestamp) * 1000).toISOString(),
          symbol: decoded.symbol,
          cast_hash: decoded.castHash,
          deployer_address: decoded.deployer || decoded.creatorAdmin,
        });
      }
    }
  }

  return createdTokens;
}
```

## Step 3: Create the Transformation

```bash theme={null}
curl --request POST \
  --url https://app.indexing.co/dw/transformations/clanker-transform \
  --header 'Content-Type: application/json' \
  --header 'X-API-KEY: <your-api-key>' \
  --form 'code="// events/token_deploy/event.ts\nfunction main(block) { /* transformation logic here */ }"'
```

## 🔗 Step 4: Create the Pipeline

```bash theme={null}
curl --request POST \
  --url https://app.indexing.co/dw/pipelines \
  --header 'Content-Type: application/json' \
  --header 'X-API-KEY: <your-api-key>' \
  --data '{
    "name": "clanker-deployments-pipeline",
    "transformation": "clanker-transform",
    "filter": "clanker-token-deployments",
    "filterKeys": [
      "0xd6f4364f..."
    ],
    "networks": [
      "base"
    ],
    "enabled": true,
    "delivery": {
      "adapter": "HTTP",
      "connection": {
        "host": "https://webhook.site/...",
        "headers": {
          "some-auth-key":"some-auth-key"
        }
      }
    }
  }'
```

## Step 5: Test the Stream

Once live, your webhook should receive events like:

```json theme={null}
    {
        "__filter_key": "0x2A787b2362021cC3eEa3C24C4748a6cD5B687382",
        "contract_address": "0x62Afd12FfDA5048eaC3c3dcFF3B4BACCf0D7Eb07",
        "deployed_at": "2025-05-13T10:50:45.000Z",
        "symbol": "WHT4",
        "deployer_address": "0x4a9058Ad83Ac078a70d987f09B5327Aaf572C0E8"
    }
```

You can test this manually using:

```bash theme={null}
curl --location 'https://app.indexing.co/dw/transformations/test?network=base&beat=30172049' \
--header 'X-API-KEY: <your-api-key>' \
--form 'code="function main(block) { /* transformation logic here */ }"'
```

## Wrap-Up

You’ve now set up a real-time stream of Clanker token deployments using The Neighborhood. The data you're receiving is identical to what Clanker themselves use in production.

Need help or want to go further?

* Reach out at [indexing.co/contact](https://www.indexing.co/contact)
* Or email us at [hello@indexing.co](mailto:hello@indexing.co)


# How to Find and Use EVM Event Signatures in The Neighborhood
Source: https://docs.indexing.co/examples/evm_event_sigs



If you're building a pipeline in The Neighborhood and using transformation code to decode onchain events, getting the right event signatures is one of the most important steps.

This tutorial will walk you through:

* How to **find event signatures** from block explorers, source code, and documentation
* How to **format them correctly** for use in The Neighborhood
* How to use the **helper functions** in your transformation code
* Common issues to troubleshoot if events aren't being picked up

Let's start with the basics.

***

## How to Find Event Signatures

To decode EVM logs in The Neighborhood, you need the **original Solidity declaration** of each event you care about. Here are three reliable methods to find them:

***

### Method 1: From the Contract ABI (Etherscan or Block Explorer)

**Best for:** quick access to a list of event signatures

**Where to look:**

* Etherscan / Basescan → *Contract* tab → scroll to the **ABI** section

**How to use it:**

1. Copy the ABI JSON blob.
2. Search for entries with `"type": "event"`.
3. Look for the `name`, `inputs`, and `indexed` fields.

**Tip:** Paste a full `event` object or the whole ABI into an LLM and ask it to convert it into a correct Solidity declaration (more below with prompts).

**Example input:**

```
{
  "anonymous": false,
  "inputs": [
    { "indexed": true, "internalType": "address", "name": "reserve", "type": "address" },
    { "indexed": false, "internalType": "address", "name": "user", "type": "address" },
    { "indexed": true, "internalType": "address", "name": "onBehalfOf", "type": "address" },
    { "indexed": false, "internalType": "uint256", "name": "amount", "type": "uint256" },
    { "indexed": true, "internalType": "uint16", "name": "referralCode", "type": "uint16" }
  ],
  "name": "Supply",
  "type": "event"
}
```

**Expected output:**

```
event Supply(
  address indexed reserve,
  address user,
  address indexed onBehalfOf,
  uint256 amount,
  uint16 indexed referralCode
);
```

**Why it’s helpful:**

* ABI is guaranteed to be linked to the deployed contract
* Good fallback if the source code is hard to navigate or proxied

***

### Method 2: Logs from Real Transactions

**Best for:** verifying an event was actually emitted

**Where to look:**

* Etherscan (or another Block Explorer) → go to a transaction → *Logs* tab

**Example:**

Go to a [transaction](https://etherscan.io/tx/0xf19165aa860274af3e5e4e481a19cef15fd058c107d501d16e0db43d615759d5#eventlog) that triggered the event (in this case`Supply`) and expand the event:

* You'll see the decoded values
* You see the `Name` of the event (e.g. `Supply (index_topic_1 address reserve, address user, index_topic_2 address onBehalfOf, uint256 amount, index_topic_3 uint16 referralCode)`)
* You might also see the simplified event signature (e.g. `Supply(address,address,address,uint256,uint16)`)

**Caution:**

* These simplified signatures omit `indexed`
* Do **not** copy/paste them directly
* Use them to *identify the event*, then transform them into the right format (see below)

***

### Method 3: Protocol Documentation

**Best for:** learning event structure quickly

**Where to look:**

* Official docs or GitHub repos (e.g. [Aave dev docs](https://aave.com/docs/developers/smart-contracts/pool))

**What to check:**

* Look for full Solidity definitions (not JSON ABI fragments)
* Confirm parameters, types, and `indexed` markers

**Watch out:**

* Docs might be out of date or auto-generated (especially from TypeScript ABIs)
* Double-check final signature with Etherscan source

***

**Having trouble finding the right signature?**

Reach out to us at [hello@indexing.co](mailto:hello@indexing.co) — we're happy to help you source or verify the exact event declarations you need.

***

## What Are Event Signatures and Why They Matter

Event signatures are the blueprint for decoding onchain activity in EVM-based blockchains. Every time a smart contract emits an event, it's logged onchain with a `topic0` — a keccak256 hash of the event's signature (name and argument types). If you want to index, decode, or filter on these logs, you need to provide the exact event signature.

In The Neighborhood, transformation code uses helper functions like `utils.evmDecodeLogWithMetadata()` to decode logs. These functions rely on an array of event signatures written in their **original Solidity declaration format** — no shortened types, renamed parameters, or reordered arguments.

Why this matters:

* `event Borrow(address indexed reserve, address user, uint256 amount)` ≠ `event Borrow(address reserve, address user, uint256 amount)` — `indexed` is part of the signature!
* `uint256` ≠ `uint8`, and `address[]` ≠ `address` — exact types must match the deployed contract.

Providing a mismatched or standardized version of the signature means The Neighborhood won't be able to match and decode that log, even if the event did fire.

## Formatting Signatures with an LLM

Once you've found the event structure, you need to convert it into the exact Solidity format expected by The Neighborhood.

You can use a large language model (like ChatGPT) to help with this by giving it a structured prompt. Here’s a sample query you can copy-paste:

**Example prompt:**

```
Transform this event in the exact original Solidity declaration format, as written in the source code — without any type widening, narrowing, or standardization.

Types must match the original source exactly (e.g., uint8 must stay uint8, int128 must stay int128, etc.).

Return the events only in this format as a JavaScript array for use in utils.evmDecodeLogWithMetadata.

Do not explain, alter formatting, or adjust types.

Output format:

const decodedWithMetadata = utils.evmDecodeLogWithMetadata(log, [
  'event ...',
  'event ...',
]);
```

**Advanced:** You can also paste an entire contract page (like from Etherscan) into ChatGPT if it supports long context windows.

**Example prompt for full page:**

```
Webpage: https://etherscan.io/address/0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2

Give me back all events from this contract in the exact original Solidity declaration format, as written in the source code — without any type widening, narrowing, or standardization.

Types must match the original source exactly (e.g., uint8 must stay uint8, int128 must stay int128, etc.).

Return the events only in this format as a JavaScript array for use in utils.evmDecodeLogWithMetadata.

Do not explain, alter formatting, or adjust types.

Output format:

const decodedWithMetadata = utils.evmDecodeLogWithMetadata(log, [
  'event ...',
  'event ...',
]);
```

This method is quick, scalable, and accurate when used carefully — just always double-check the types and match them to verified sources.

## Using Signatures in The Neighborhoods Helper Functions

Once you've formatted your event signatures correctly, you're ready to use them in your transformation code.

The Neighborhood provides several helper functions that make decoding EVM logs straightforward:

```
const decoded = utils.evmDecodeLog(log, [
  'event ...',
]);

const decodedWithMetadata = utils.evmDecodeLogWithMetadata(log, [
  'event ...',
]);

const topic0 = utils.evmMethodSignatureToHex('event Transfer(address,address,uint256)');
```

* Use `evmDecodeLog()` to decode logs into raw data.
* Use `evmDecodeLogWithMetadata()` if you also want the matching event name returned.
* Use `evmMethodSignatureToHex()` to convert a signature string to its `topic0` hash for filtering or debugging.

### Common Troubleshooting Tips

If your event isn't being picked up:

* ✅ Double-check your signature format — types must match exactly, including `indexed`
* ✅ Confirm that the event was actually emitted using a block explorer
* ✅ Look for proxy contracts — your event might be emitted from a different implementation address
* ✅ Use `utils.evmMethodSignatureToHex()` to get `topic0` and verify it matches the log's first topic

Still stuck? Feel free to reach out — we’re happy to help troubleshoot.

***

##


# Track Wallet Flows Across EVM Chains
Source: https://docs.indexing.co/examples/evm_wallet_flows



In this step-by-step guide, we'll show you how to build a pipeline in **The Neighborhood**, the distributed data network built by The Indexing Company, that monitors wallet flows from 117 known Binance addresses and streams all related token transfers into your own database or webhook.

By the end of this tutorial, you’ll be able to:

* Track wallet or contract flows across **any EVM chain**
* Stream token transfer data into **PostgreSQL**, **webhooks**, or other destinations
* Apply filters to specific wallets, tokens, or transfer amounts
* Backfill historical data on demand

🔑 To get started, you’ll need an API key. You can request access at [indexing.co/contact](https://indexing.co/contact) or by emailing us at [hello@indexing.co](mailto:hello@indexing.co).

# Step 1: Create a Wallet Filter

This filter targets 117 known Binance wallets. You can replace these addresses with your own list if you want to track different wallets, smart contracts, or entities.

Don’t worry about (your) size! The Neighborhood supports **filters with over millions of addresses easily**.

```bash theme={null}
curl --location 'https://app.indexing.co/dw/filters/binance_addresses' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'content-type: application/json' \
--data '{"values": ["0x3f5ce5fbfe3e9af3971dd833d26ba9b5c936f0be","0xd551234ae421e3bcba99a0da6d736074f22192ff","0x564286362092d8e7936f0549571a803b203aaced","0x0681d8db095565fe8a346fa0277bffde9c0edbbf","0xfe9e8709d3215310075d67e3ed32a380ccf451c8","0x4e9ce36e442e55ecd9025b9a6e0d88485d628a67","0xbe0eb53f46cd790cd13851d5eff43d12404d33e8","0xf977814e90da44bfa03b6295a0616a897441acec","0x001866ae5b3de6caa5a51543fd9fb64f524f5478","0x85b931a32a0725be14285b66f1a22178c672d69b","0x708396f17127c42383e3b9014072679b2f60b82f","0xe0f0cfde7ee664943906f17f7f14342e76a5cec7","0x8f22f2063d253846b53609231ed80fa571bc0c8f","0x28c6c06298d514db089934071355e5743bf21d60","0x21a31ee1afc51d94c2efccaa2092ad1028285549","0xdfd5293d8e347dfe59e90efd55b2956a1343963d","0x56eddb7aa87536c09ccc2793473599fd21a8b17f","0x9696f59e4d72e237be84ffd425dcad154bf96976","0x4d9ff50ef4da947364bb9650892b2554e7be5e2b","0x4976a4a02f38326660d17bf34b431dc6e2eb2327","0xd88b55467f58af508dbfdc597e8ebd2ad2de49b3","0x7dfe9a368b6cf0c0309b763bb8d16da326e8f46e","0x345d8e3a1f62ee6b1d483890976fd66168e390f2","0xc3c8e0a39769e2308869f7461364ca48155d1d9e","0x2e581a5ae722207aa59acd3939771e7c7052dd3d","0x44592b81c05b4c35efb8424eb9d62538b949ebbf","0xa344c7ada83113b3b56941f6e85bf2eb425949f3","0x5a52e96bacdabb82fd05763e25335261b270efcb","0x06a0048079ec6571cd1b537418869cde6191d42d","0x892e9e24aea3f27f4c6e9360e312cce93cc98ebe","0x00799bbc833d5b168f0410312d2a8fd9e0e3079c","0x141fef8cd8397a390afe94846c8bd6f4ab981c48","0x50d669f43b484166680ecc3670e4766cdb0945ce","0x2f7e209e0f5f645c7612d7610193fe268f118b28","0xd9d93951896b4ef97d251334ef2a0e39f6f6d7d7","0x19184ab45c40c2920b0e0e31413b9434abd243ed","0x294b9b133ca7bc8ed2cdd03ba661a4c6d3a834d9","0x5d7f34372fa8708e09689d400a613eee67f75543","0x515b72ed8a97f42c568d6a143232775018f133c8","0x631fc1ea2270e98fbd9d92658ece0f5a269aa161","0xbd612a3f30dca67bf60a39fd0d35e39b7ab80774","0x161ba15a5f335c9f06bb5bbb0a9ce14076fbb645","0x3c783c21a0383057d128bae431894a5c19f9cf06","0xe7804c37c13166ff0b37f5ae0bb07a3aebb6e245","0x9f8c163cba728e99993abe7495f06c0a3c8ac8b9","0xb1256d6b31e4ae87da1d56e5890c66be7f1c038e","0x8894e0a0c962cb723c1976a4421c95949be2d4e3","0x01c952174c24e1210d26961d456a77a39e1f0bb0","0x082489a616ab4d46d1947ee3f912e080815b08da","0xb38e8c17e38363af6ebdcb3dae12e0243582891d","0xacd03d601e5bb1b275bb94076ff46ed9d753435a","0x1b5b4e441f5a22bfd91b7772c780463f66a74b35","0x17b692ae403a8ff3a3b2ed7676cf194310dde9af","0x8ff804cc2143451f454779a40de386f913dcff20","0xad9ffffd4573b642959d3b854027735579555cbc","0x7a8a34db9acd10c3b6277473b192fe47192569ca","0x1d40b233cdf2cc0cdc347d5401d5b02c2831a0c1","0x4fabb145d64652a948d72533023f6e7a623c7c53","0xf2de20dbf4b224af77aa4ff446f43318800bd6b4","0x7ab33ad1e91ddf6d5edf69a79d5d97a9c49015d4","0x4d072a68d0428a9a3054e03ad7ee61c557b537ab","0x1763f1a93815ee6e6bc3c4475d31cc9570716db2","0x972bed5493f7e7bdc760265fbb4d8e73ea89e453","0x290275e3db66394c52272398959845170e4dcb88","0x505e71695e9bc45943c58adec1650577bca68fd9","0x001ceb373c83ae75b9f5cf78fc2aba3e185d09e2","0x07b664c8af37eddaa7e3b6030ed1f494975e9dfb","0x0e4158c85ff724526233c1aeb4ff6f0c46827fbe","0xb32e9a84ae0b55b8ab715e4ac793a61b277bafa3","0xa7c0d36c4698981fab42a7d8c783674c6fe2592d","0xa84fd90d8640fa63d194601e0b2d1c9094297083","0x3304e22ddaa22bcdc5fca2269b418046ae7b566a","0x923fc76cb13a14e5a87843d309c9f401ec498e2d","0x3cdfb47b0e910d9190ed788726cd72489bf10499","0x417850c1cd0fb428eb63649e9dc4c78ede9a34e8","0x4a9e49a45a4b2545cb177f79c7381a30e1dc261f","0x4aefa39caeadd662ae31ab0ce7c8c2c9c0a013e8","0x87917d879ba83ce3ada6e02d49a10c1ec1988062","0x7aed074ca56f5050d5a2e512ecc5bf7103937d76","0x835678a611b28684005a5e2233695fb6cbbb0007","0x6d8be5cdf0d7dee1f04e25fd70b001ae3b907824","0x7e278a68a35d76a7e4b2c9d8b778acd775c6d832","0x6be5a267b04e9f24cdc1824fd38d63c436be91ab","0xeb25df7c79a85640c4420680461dcdfd91f0dfad","0x3931dab967c3e2dbb492fe12460a66d0fe4cc857","0x25681ab599b4e2ceea31f8b498052c53fc2d74db","0x29fe6c66097f7972d8e47c4f691576327fcf9a12","0xfdd2ba77db02caa6a9869735dac577d809cadd11","0x9bf4001d307dfd62b26a2f1307ee0c0307632d59","0xdee6238780f98c0ca2c2c28453149bea49a3abc9","0x6d9348910e6ed90c1bb170c47965f5f7b8e19763","0xa4e471dbfe8c95d4c44f520b19cee436c01c3267","0xd2c0b70b9b451f7e2688d72460215d84caa6cbe4","0xf6436829cf96ea0f8bc49d300c536fcc4f84c4ed","0xcc71dd74183ea325f537665678263565c0b7e493","0xe4b5b2667e049ac8c79ae6c5a7e3300815aa32be","0x00f9451385bf75910d80374eb42edf36d1a3f243","0xef7fb88f709ac6148c07d070bc71d252e8e13b92","0x8b99f3660622e21f2910ecca7fbe51d654a1517d","0xab83d182f3485cf1d6ccdd34c7cfef95b4c08da4","0x0f7b0c7d9ea425b451d0738c2ece43161eff64bc","0xc365c3315cf926351ccaf13fa7d19c8c4058c8e1","0x66f791456b82921cbc3f89a98c24ea21784973a1","0x2f47a1c2db4a3b78cda44eade915c3b19107ddcc","0xbdd75a97c29294ff805fb2fee65abd99492b32a8","0xf17aced3c7a8daa29ebb90db8d1b6efd8c364a18","0xb3f923eabaf178fc1bd8e13902fc5c61d3ddef5b","0x47ac0fb4f2d84898e4d9e7b4dab3c24507a6d503","0x9be89d2a4cd102d8fecc6bf9da793be995c22541","0x7884f51dc1410387371ce61747cb6264e1daee0b","0xff0a024b66739357c4ed231fb3dbc0c8c22749f5","0xeb2d2f1b8c558a40207669291fda468e50c8a0bb","0xdccf3b77da55107280bd850ea519df3705d1a75a","0xa180fe01b906a1be37be6c534a3300785b20d947","0x29bdfbf7d27462a2d115748ace2bd71a2646946c","0x1fbe2acee135d991592f167ac371f3dd893a508b","0x73f5ebe90f27b46ea12e5795d16c4b408b19cc6f","0xe2fc31f816a9b94326492132018c3aecc4a93ae1","0xf92402bb795fd7cd08fb83839689db79099c8c9c","0x9430801ebaf509ad49202aabc5f5bc6fd8a3daf8","0x8f80c66c70cbc52009babb04c1cadf9b40109289","0x15ece0d7de25436bcfcf3d62a9085ddc7838aee9","0x370b8eaad4e5970a853d25cd26a499150fd38274","0xf3084ed5596c3ef9fcf53689da3b998e621a34c4","0x50460c4cd74094cd591f455cad457e99c4ab8be0","0x9cd1ac952951fe63c658589db0dde32fc55b815b","0x0b95993a39a363d99280ac950f5e4536ab5c5566","0xfc19e4ce0e0a27b09f2011ef0512669a0f76367a","0x61189da79177950a7272c88c6058b96d4bcd6be2","0x34ea4138580435b5a521e460035edb19df1938c1","0xf60c2ea62edbfe808163751dd0d8693dcb30019c","0x43c5b1c2be8ef194a509cf93eb1ab3dbd07b97ed","0x21d45650db732ce5df77685d6021d7d5d1da807f","0x211ee0129a67e7d44514152eb43d9f31103ac46b","0x9223c017a39d4806d1d92c15046ae28c32c6d8e7","0xd5c08681719445a5fdce2bda98b341a49050d821","0xb14a67c63bda5024d2effd53aa16a00bb7f9a30a","0xb650b0b1f183d59343da753d94c068bfea92693d"]}'
```

This creates a named filter called `binance_addresses` that we’ll reference throughout the rest of the pipeline.

# Step 2: Write the Transformation Code

This code extracts ERC20 `Transfer` events and outputs the fields you care about (chain, addresses, token, amount, etc.).

```bash theme={null}
curl --location 'https://app.indexing.co/dw/transformations/binance_transfers' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'content-type: application/json' \
--data '{"code":"function(block) { const txfers = templates.tokenTransfers(block); return txfers.map((txfer, i) => ({ chain: block._network, block_number: txfer.blockNumber, transaction_hash: txfer.transactionHash, log_index: txfer.index || i, timestamp: txfer.timestamp, from_address: txfer.from, to_address: txfer.to, token_address: txfer.token, amount: txfer.amount })); }"}'

```

Want to filter specific tokens or high-value transfers only? Just modify this JavaScript transformation to include logic based on `token_address` or `amount`.

# Step 3: Test Your Transformation

Use a known Ethereum block to test the transformation output before you deploy it.

```bash theme={null}
curl --location --globoff 'https://app.indexing.co/dw/transformations/test?network=ethereum&beat=22731766&filter=binance_addresses&filterKeys[0]=from_address&filterKeys[1]=to_address' \
--header 'x-api-key: YOUR_API_KEY' \
--form 'code="function(block) { const txfers = templates.tokenTransfers(block); return txfers.map((txfer, i) => ({ chain: block._network, block_number: txfer.blockNumber, transaction_hash: txfer.transactionHash, log_index: txfer.index || i, timestamp: txfer.timestamp, from_address: txfer.from, to_address: txfer.to, token_address: txfer.token, amount: txfer.amount })); }"'
```

Make sure your filter is catching transfers as expected before moving on.

# Step 4: Set Up the Destination Table

We’ll deliver data into a PostgreSQL table. Here’s a schema that matches the transformation output:

```sql theme={null}
CREATE TABLE binance_transfers (
  chain TEXT NOT NULL,
  block_number BIGINT NOT NULL,
  transaction_hash TEXT NOT NULL,
  log_index INTEGER NOT NULL,
  timestamp TIMESTAMPTZ NOT NULL,
  from_address TEXT,
  to_address TEXT,
  token_address TEXT,
  amount NUMERIC,
  created_at TIMESTAMPTZ DEFAULT now(),
  PRIMARY KEY (chain, transaction_hash, log_index)
);
```

Prefer a webhook or cloud storage target? Just change the delivery adapter in the next step.

# Step 5: Create the Pipeline

Now deploy the full pipeline into **The Neighborhood** and stream data from any EVM chain in real time.

```bash theme={null}
curl --location 'https://app.indexing.co/dw/pipelines' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'content-type: application/json' \
--data-raw '{
  "name": "binance_transfers",
  "transformation": "binance_transfers",
  "filter": "binance_addresses",
  "filterKeys": ["from_address", "to_address"],
  "networks": ["ethereum, base"],
  "enabled": true,
  "delivery": {
    "adapter": "POSTGRES",
    "connectionUri": "YOUR_POSTGRES_URI",
    "table": "binance_transfers",
    "uniqueKeys": ["chain", "transaction_hash", "log_index"]
  }
}'
```

The `"networks"` field supports:

* `"EVM"` → all EVM-compatible chains
* Or any individual network from our [Network List](https://docs.indexing.co/networks/overview)

***

# Optional: Backfill Historical Data

Want to backfill historical transfers from a specific period?

```bash theme={null}
curl --location 'https://app.indexing.co/dw/pipelines/binance_transfers/backfill' \
--header 'Content-Type: application/json' \
--header 'X-API-KEY: YOUR_API_KEY' \
--data '{
  "network": "ethereum",
  "value": "0x3f5CE5FBFe3E9af3971dD833D26bA9b5C936f0bE",
  "beatStart": 23029865,
  "beatEnd": 23029872,
  "beats": [23029869]
}'

```

You can script this to run over large date ranges or trigger programmatically for new addresses.

***

## Delivery Options

Most developers need the data is streamed into their target database. You can also:

* Send transfers to a webhook
* Store data in S3 or cloud storage
* Filter by `token_address` and `amount` to trigger alerts

The transformation layer is fully programmable and real-time, enabling custom logic for analytics, compliance, trading, or monitoring.

***

# Recap

You’ve now deployed a live pipeline in **The Neighborhood** that:

* Tracks 117 Binance addresses
* Can work across **any EVM chain**
* Streams token transfers into a database or webhook
* Can be customized for filtering, backfills, and alerts

Ready to build your own?

Browse our [Network List](https://docs.indexing.co/networks/overview) to see which networks you would deploy this pipeline on. If the network is not listed, let us know! We can easily onboard new networks for you.

To run these pipelines you can [contact us](https://indexing.co/contact) to get your API key.


# Build Pipelines with Your AI Coding Agent
Source: https://docs.indexing.co/examples/mcp-server

Use the Indexing Co MCP server to build, test, and stream blockchain data pipelines from any MCP-compatible coding agent

# Build Pipelines with Your AI Coding Agent

The Indexing Co [MCP server](https://github.com/indexing-co/indexing-co-mcp) connects AI coding agents to the Indexing Co API and live event stream. Describe your data needs in natural language, and the agent handles pipeline creation, transformation logic, testing, and deployment — no dashboard or config files required.

<img alt="Live Event Stream Preview — colorized terminal output showing USDC transfer events streaming in real-time" />

## What You Get

| Component       | What it does                                                                                                                                                                                                     |
| --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **MCP Server**  | Connects your agent to the Indexing Co API and live event stream via WebSocket                                                                                                                                   |
| **Skill**       | Teaches the agent how to build pipelines — filter/transformation/destination patterns, event signatures, debugging. The MCP server provides the tools; the skill provides the knowledge to use them effectively. |
| **Preview CLI** | Streams live pipeline events to your terminal with colorized, formatted output                                                                                                                                   |

## Setup

### 1. Install the MCP Server

```bash theme={null}
git clone https://github.com/indexing-co/indexing-co-mcp.git
cd indexing-co-mcp
npm install && npm run build
```

### 2. Add Your Credentials

Create `~/.indexing-co/credentials` with your API key:

```
API_KEY=your_api_key
```

Sign up at [accounts.indexing.co](https://accounts.indexing.co) if you don't have an API key yet.

### 3. Register with Your Agent

<Tabs>
  <Tab title="Claude Code">
    ```bash theme={null}
    claude mcp add --scope user indexing-co -- node /path/to/indexing-co-mcp/dist/index.js
    ```

    Install the skill to give Claude pipeline workflow knowledge — how to structure filters, write transformations, pick destinations, and debug delivery:

    ```bash theme={null}
    claude skill add --scope user https://github.com/indexing-co/indexing-co-pipeline-skill
    ```
  </Tab>

  <Tab title="Codex CLI">
    ```bash theme={null}
    codex mcp add indexing-co -- node /path/to/indexing-co-mcp/dist/index.js
    ```

    Codex automatically recognizes MCP tools. For the full pipeline workflow knowledge, install the skill as a custom instruction or system prompt — see the [skill repo](https://github.com/indexing-co/indexing-co-pipeline-skill) for details.
  </Tab>

  <Tab title="Other MCP Agents">
    Point your agent's MCP configuration at the server entry point:

    ```
    node /path/to/indexing-co-mcp/dist/index.js
    ```

    Any MCP-compatible agent can connect by registering the server and providing API credentials. Pair it with the [skill](https://github.com/indexing-co/indexing-co-pipeline-skill) (as a system prompt or instruction set) for the best results.
  </Tab>
</Tabs>

## What You Can Do

Once set up, just describe what you want in natural language:

* *"Index all USDC transfers on Base to my Postgres database"*
* *"Set up a webhook for Uniswap V3 swaps on Ethereum"*
* *"Stream Aave supply events on Arbitrum so I can see them live"*

The agent will walk through the full pipeline workflow: create a filter, write and test a transformation, set up the destination, deploy, and verify.

## MCP Server Tools

The MCP server gives your agent direct access to the Indexing Co API:

| Tool                                                                      | Purpose                                       |
| ------------------------------------------------------------------------- | --------------------------------------------- |
| `list_pipelines` / `get_pipeline` / `create_pipeline` / `delete_pipeline` | Manage pipelines                              |
| `backfill`                                                                | Backfill historical blocks for a pipeline     |
| `list_filters` / `get_filter` / `create_filter` / `delete_filter_values`  | Manage address filters                        |
| `list_transformations` / `get_transformation` / `create_transformation`   | Manage transformation code                    |
| `test_transformation`                                                     | Dry-run a transformation against a live block |
| `subscribe` / `unsubscribe`                                               | Subscribe to live event channels              |
| `get_events` / `query` / `describe_data`                                  | Query stored events with SQL                  |

## Live Event Preview

For pipelines using the `DIRECT` adapter, you can stream events straight to your terminal with the preview CLI:

```bash theme={null}
node /path/to/indexing-co-mcp/dist/cli/preview.js <channel>
```

This renders a live, colorized stream of events as they flow through your pipeline — addresses in magenta, transaction hashes in blue, numbers in yellow, and nested objects indented with recursive colorization. Press Ctrl+C to see a summary with total event count, duration, and average throughput.

### DIRECT Adapter Setup

To use the preview CLI, configure your pipeline with the `DIRECT` adapter:

```json theme={null}
{
  "adapter": "DIRECT",
  "connectionUri": "my-channel-name"
}
```

The `connectionUri` is the channel name you pass to the preview CLI. Events are only sent when at least one subscriber is connected.

<Note>
  The DIRECT adapter can run alongside any other adapter. For example, you can stream to both Postgres and the preview CLI simultaneously by creating two pipelines with the same filter and transformation but different delivery configs.
</Note>

## Example Workflow

Here's what a typical session looks like:

1. **You:** *"I want to track all USDC transfers on Base"*
2. **Agent:** Creates a filter with the Base USDC contract address
3. **Agent:** Writes a transformation using `utils.evmDecodeLogWithMetadata` for Transfer events
4. **Agent:** Tests the transformation against a recent block
5. **Agent:** Deploys the pipeline with your chosen destination
6. **Agent:** Backfills a few blocks and verifies data arrives
7. **You:** *"Stream the events so I can see them"*
8. **Agent:** Launches the preview CLI and triggers a backfill — live events appear in your terminal

## Security

The MCP server runs locally — API credentials stay on your machine. The agent operates with the same permissions as your API key, so treat your credentials accordingly.

## Resources

| Resource        | Link                                                                                                           |
| --------------- | -------------------------------------------------------------------------------------------------------------- |
| MCP Server repo | [github.com/indexing-co/indexing-co-mcp](https://github.com/indexing-co/indexing-co-mcp)                       |
| Skill repo      | [github.com/indexing-co/indexing-co-pipeline-skill](https://github.com/indexing-co/indexing-co-pipeline-skill) |
| Full API docs   | [docs.indexing.co](https://docs.indexing.co)                                                                   |
| Sign up         | [accounts.indexing.co](https://accounts.indexing.co)                                                           |
| Support         | [hello@indexing.co](mailto:hello@indexing.co)                                                                  |


# How to Generate a Database Table from Your Neighborhood Pipeline Output
Source: https://docs.indexing.co/examples/pipeline_to_postgres



The Neighborhood streams decoded onchain data directly to your database. Once you’ve tested your transformation, the next step is preparing the right table to receive incoming data.

To get a real example of your pipeline’s output use the [Test Transformation API](/guide/transformations/test) to run a dry-run and view the event format.

Here’s an example output from a tested transformation:

```json theme={null}
[
  {
    "chain": "ETHEREUM",
    "block": 22282149,
    "transaction_hash": "0xc0814c035946d6889497a82d6515647f939f1dfe5d86d46c4294b3c6b127bad7",
    "log_index": 534,
    "contract_address": "0x87870bca3f3fd6335c3f4ce8392d69350b4fa4e2",
    "decoded": {
      "reserve": "0xD533a949740bb3306d119CC777fa900bA034cd52",
      "onBehalfOf": "0x3f3B17da678a495EbEc8a061657Cb6CFa4901531",
      "referralCode": 0,
      "user": "0x3f3B17da678a495EbEc8a061657Cb6CFa4901531",
      "amount": "15000000000000000000000"
    },
    "event_name": "Supply"
  }
]

```

***

Alternatively, paste your transformation code into an large language model (LLM) like ChatGPT and ask it to generate a table based on this code. The model will make assumptions on the data, so ensure to check the generated table schema.

## Step 1: Generate a Table Schema

Paste the example output into an LLM or a tool like `jsonschema2ddl`, and ask it to generate a `CREATE TABLE` statement for your database of choice (e.g., PostgreSQL, MySQL, SQLite). The primary key has to be a unique combination.

**Example prompt:**

```
Convert this JSON into a CREATE TABLE statement for [your database type].
Use appropriate types (e.g., bigint, text, jsonb). Name the table [your table name].
Add a compound primary key on (chain, transaction_hash, log_index).

```

***

## Step 2: Run the Table Schema in Your Database

Here’s an ideal result if you're using PostgreSQL:

```sql theme={null}
CREATE TABLE AavePool (
  chain TEXT NOT NULL,
  block BIGINT NOT NULL,
  transaction_hash TEXT NOT NULL,
  log_index INTEGER NOT NULL,
  contract_address TEXT NOT NULL,
  event_name TEXT NOT NULL,
  decoded JSONB NOT NULL,
  created_at TIMESTAMPTZ DEFAULT now(),
  PRIMARY KEY (chain, transaction_hash, log_index)
);

```

This schema uses a compound key to ensure idempotency. Since pipelines provide **at-least-once delivery**, uniqueness matters to prevent duplicate rows and ensure data integrity.

***

## Need Help?

Need help setting this up? Send us your sample output at [hello@indexing.co](mailto:hello@indexig.co) — we’ll help generate or review the schema for you.


# Polygon DEX Events
Source: https://docs.indexing.co/examples/polygon_dex_events



## Introduction

This guide shows you how to stream real-time DEX activity from Polygon into your own database. You'll tap into the most active decentralized exchanges on the network: Uniswap, Quickswap, Balancer V2, Sushi, and Curve. The template captures a range of onchain events including swaps, liquidity changes, and more. By the end, you'll have a working pipeline that decodes relevant contract event logs and stores structured trade data for analysis or downstream use.

## Prerequisites

You’ll need:

* A Neighborhood API key. To get access, sign up at [**accounts.indexing.co**](https://accounts.indexing.co) or email [**hello@indexing.co**](mailto:hello@indexing.co)
* curl or Postman
* An active postgres database

## What You’ll Build

A pipeline that:

1. Listens to the majority of Polygon DEX contracts and their events
2. Decodes them with the event metadata
3. Streams transformed data into a unified postgres table

## Step 1: Add the Transformation Logic

We'll want to decode and return all events + unified swaps for known DEXs.

View the full code [here](https://github.com/indexing-co/docs/blob/main/examples/transformations/polygon_dex_events.js)

## Step 2: Create the Transformation

```bash theme={null}
curl https://app.indexing.co/dw/transformations/polygon_dex_events \
  -H 'Content-Type: application/json' \
  -H 'X-API-KEY: <your-api-key>' \
  -F code=@./polygon_dex_events.js
```

## Step 3: Create the Database

```sql theme={null}
create table dex_events (
  contract_address text,
  transaction_hash text,
  log_index int,
  method text,
  timestamp timestamptz,
  decoded jsonb,
  primary key (contract_address, transaction_hash, log_index)
);

create index on dex_events (contract_address, method,timestamp);

create table swaps (
  pool_address text,
  transaction_hash text,
  log_index int,
  timestamp timestamptz,
  token_in_address text,
  token_out_address text,
  token_in_amount numeric,
  token_out_amount numeric,
  from_address text,
  to_address text,
  primary key (pool_address, transaction_hash, log_index)
);

create index on swaps (token_in_address, timestamp);
create index on swaps (token_out_address, timestamp);
```

The `contract_address` and `pool_address` represents the swap pool for `dex_events` and `swaps`, respectively. The above provides a single, primary key index for each table, but you may find you want other indexes added based on scale and query patterns.

## Step 4: Create the Pipeline

```bash theme={null}
curl https://app.indexing.co/dw/pipelines \
  -H 'Content-Type: application/json' \
  -H 'X-API-KEY: <your-api-key>' \
  -d '{
    "name": "polygon_dex_events",
    "transformation": "polygon_dex_events",
    "networks": [
      "polygon"
    ],
    "enabled": true,
    "delivery": {
      "adapter": "POSTGRES",
      "connectionUri": "postgres://...",
      "tableMap": {
        "dex_events": ["contract_address", "transaction_hash", "log_index"],
        "swaps": ["pool_address", "transaction_hash", "log_index"]
      }
    }
  }'
```

## Step 5: Test the Stream

Once live, your database should receive events like:

```json theme={null}
{
  "pool_address": "0x4e3288c9ca110bcc82bf38f09a7b425c095d92bf",
  "transaction_hash": "0xf087c159221c15b751979539d0db9c45b0e509c3f80cc988c9cebc51b7b69e40",
  "log_index": 504,
  "timestamp": "2025-07-16T23:21:42.000Z",
  "token_in_address": "0x2791bca1f2de4661ed88a30c99a7a9449aa84174",
  "token_in_amount": "2323",
  "token_out_address": "0x2791bca1f2de4661ed88a30c99a7a9449aa84174",
  "token_out_amount": "2323"
}
```

You can test this manually and end-to-end using:

```bash theme={null}
curl 'https://app.indexing.co/dw/pipelines/polygon_dex_events/test/polygon/74046728' -H 'X-API-KEY: <your-api-key>' -X POST
```

## Wrap-Up

You've now set up a real-time stream of Polygon DEX events using The Neighborhood. The data you're receiving is contains events from the most used Polygon DEXs. In case you want to add new DEXs we encourage you to reach out to us or adjust the template.

Need help or want to go further?

* Reach out at [indexing.co/contact](https://www.indexing.co/contact)
* Or email us at [hello@indexing.co](mailto:hello@indexing.co)


# Polygon Money Market Events
Source: https://docs.indexing.co/examples/polygon_money_market_events



## Introduction

In this guide, you'll build a real-time pipeline to track lending and borrowing activity from Polygon money markets AAVE and Compound V3. By listening to core protocol contracts, you'll capture events like deposits, borrows, repayments, and liquidations, then decode and stream them directly into your database. By the end, you'll have a working pipeline that decodes relevant contracts event logs and stores structured trade data for analysis or downstream use.

## Prerequisites

You’ll need:

* A Neighborhood API key. To get access, sign up at [**accounts.indexing.co**](https://accounts.indexing.co) or email [**hello@indexing.co**](mailto:hello@indexing.co)
* curl or Postman
* An active postgres database

## What You’ll Build

A pipeline that:

1. Listens to the majority of Polygon money market contracts and their events
2. Decodes them with the event metadata
3. Streams transformed data into a unified postgres table

## Step 1: Create a Contract Filter

Then create the [filter](https://docs.indexing.co/guide/filters/add):

These are the contract addresses we'll want to listen to:

```text theme={null}
0x794a61358D6845594F94dc1DB02A252b5b4814aD
0xF25212E676D1F7F89Cd72fFEe66158f541246445
0xaeB318360f27748Acb200CE616E389A6C9409a07
```

```bash theme={null}
curl https://app.indexing.co/dw/filters/polygon_money_market_addresses \
  -H 'Content-Type: application/json' \
  -H 'X-API-KEY: <your-api-key>' \
  -d '{
    "values": [
      "0x794a61358D6845594F94dc1DB02A252b5b4814aD",
      "0xF25212E676D1F7F89Cd72fFEe66158f541246445",
      "0xaeB318360f27748Acb200CE616E389A6C9409a07"
    ]
  }'
```

## Step 2: Add the Transformation Logic

We'll want to decode and return a unified set of in and out flows for known markets.

View the full code [here](https://github.com/indexing-co/docs/blob/main/examples/transformations/polygon_money_markets.js)

## Step 3: Create the Transformation

```bash theme={null}
curl https://app.indexing.co/dw/transformations/polygon_money_market_events \
  -H 'Content-Type: application/json' \
  -H 'X-API-KEY: <your-api-key>' \
  -F code=@./polygon_money_market_events.js
```

## Step 4: Create the Database

```sql theme={null}
create table money_market_events (
  pool_address text,
  transaction_hash text,
  log_index int,
  method text,
  timestamp timestamptz,
  wallet_address text,
  token_address text,
  amount numeric,
  primary key (pool_address, transaction_hash, log_index)
);
create index on money_market_events (wallet_address, timestamp desc);
```

The `pool_address` represents the liquidity pool that the event is tied to and `method` can be used to identify specific events. The above provides a single, primary key index, but you may find you want other indexes added based on scale and query patterns.

### Example Queries

Identifying USD volume by liquidity pool within the last hour:

```sql theme={null}
select
  pool_address,
  sum(amount) / pow(10, 6) as volume
from
  money_market_events
where
  token_address in (
    '0x2791bca1f2de4661ed88a30c99a7a9449aa84174', -- USDC
    '0xc2132d05d31c914a87c6611c10748aeb04b58e8f' -- USDT
  )
  and timestamp > now() - interval '1 hour'
group by pool_address
order by sum(amount) desc;
```

## Step 5: Create the Pipeline

```bash theme={null}
curl https://app.indexing.co/dw/pipelines \
  -H 'Content-Type: application/json' \
  -H 'X-API-KEY: <your-api-key>' \
  -d '{
    "name": "polygon_money_market_events",
    "transformation": "polygon_money_market_events",
    "filter": "polygon_money_market_addresses",
    "filterKeys": [
      "pool_address"
    ],
    "networks": [
      "polygon"
    ],
    "enabled": true,
    "delivery": {
      "adapter": "POSTGRES",
      "connectionUri": "postgres://...",
      "table": "money_market_events",
      "uniqueKeys": ["pool_address", "transaction_hash", "log_index"]
    }
  }'
```

## Step 6: Test the Stream

Once live, your database should receive events like:

```json theme={null}
{
  "pool_address": "0x794a61358d6845594f94dc1db02a252b5b4814ad",
  "transaction_hash": "0xcaefff01eec692ef13503959437dfac7e1aeee9ecaa5a5d7b640a5dda30cccc6",
  "log_index": 707,
  "timestamp": "2025-07-16T23:12:14.000Z",
  "wallet_address": "0xadeccaba96f86f2eb4fbe219be39a87db7534ddb",
  "token_address": null,
  "amount": "524130000"
}
```

You can test this manually and end-to-end using:

```bash theme={null}
curl 'https://app.indexing.co/dw/pipelines/polygon_money_market_events/test/polygon/74046461' -H 'X-API-KEY: <your-api-key>' -X POST
```

## Wrap-Up

You've now set up a real-time stream of Polygon Money Market events using The Neighborhood. The data you're receiving is contains events from the most used Polygon Money Markets, AAVE and Compound V3. In case you want to add new DEXs we encourage you to reach out to us or adjust the template.

Need help or want to go further?

* Reach out at [indexing.co/contact](https://www.indexing.co/contact)
* Or email us at [hello@indexing.co](mailto:hello@indexing.co)


# Streaming ERC-20 Contract Deployments
Source: https://docs.indexing.co/examples/streaming_erc20_deployments



## Introduction

This tutorial shows you how to detect and stream **ERC-20 contract deployments** in real time using **The Neighborhood’s indexing infrastructure**. Basically we are going to track new token creations.

Unlike event-based pipelines, this example scans the entire chain for contract creation transactions and identifies which of these deployments implement the ERC-20 interface.

> Note: The output of this pipeline can be used to trigger another [pipeline that filters](https://docs.indexing.co/guide/filters/overview) only the token transfers for these deployed tokens, creating a complete token tracking system.

## Prerequisites

You’ll need:

* A Neighborhood API key. To get access, sign up at [**accounts.indexing.co**](https://accounts.indexing.co) or email [**hello@indexing.co**](mailto:hello@indexing.co)
* Basic understanding of EVM transactions and contract bytecode
* `curl` or Postman
* A webhook, database endpoint, or another supported delivery method

## What You’ll Build

A pipeline that:

* Scans every block for contract creation traces
* Detects contracts implementing the ERC-20 standard (using function selectors)
* Streams structured deployment data to a destination of your choice

**Delivery:** Choose where the data should go: your database, a webhook, a Kafka topic - you name it! You can find the full list of supported destinations in our [adapter directory](https://www.notion.so/16e25f031053805da10cf65179f977c6?pvs=21).

## Step 1: Add the Transformation Logic

This transformation inspects each transaction trace within a block. If a contract is deployed and its bytecode contains known ERC-20 method selectors, it emits a record with the deployment details.

```javascript theme={null}
function main(block) {
  const newContracts = [];

  const erc20InterfaceSignatures = [
    '18160ddd', // totalSupply()
    '70a08231', // balanceOf(address)
    'a9059cbb', // transfer(address,uint256)
    '23b872dd', // transferFrom(address,address,uint256)
    '095ea7b3', // approve(address,uint256)
    'dd62ed3e', // allowance(address,address)
  ];

  for (const tx of block.transactions) {
    if (!tx.receipt || !tx.traces?.length) continue;

    for (let ti = 0; ti < tx.traces.length; ti += 1) {
      const result = tx.traces[ti].result;
      if (result?.address && result.code) {
        if (!erc20InterfaceSignatures.find(fourByte => result.code.includes(fourByte))) {
          continue;
        }

        newContracts.push({
          chain: block._network.toLowerCase(),
          timestamp: new Date(block.timestamp * 1000),
          transactionHash: tx.hash,
          traceIndex: ti,
          address: result.address.toLowerCase(),
        });
      }
    }
  }

  return newContracts;
}
```

You can also download the code [here](https://github.com/indexing-co/docs/blob/main/examples/transformations/erc20_contract_deployments.js)

## Step 2: Create the Transformation

Use the following API request to [create your transformation](https://docs.indexing.co/guide/transformations/create) in The Neighborhood:

```bash theme={null}
curl https://app.indexing.co/dw/transformations/erc20_deployments \
  -H 'Content-Type: application/json' \
  -H 'X-API-KEY: <your-api-key>' \
  -F code=@./erc20_contract_deployments.js
```

## Step 3: Create the Pipeline

Since this pipeline scans all contract deployments, no filter step is required. [Create the pipeline](https://docs.indexing.co/guide/pipelines/create) with:

```bash theme={null}
curl https://app.indexing.co/dw/pipelines \
  -H 'Content-Type: application/json' \
  -H 'X-API-KEY: <your-api-key>' \
  -d '{
    "name": "erc20_deployments_pipeline",
    "transformation": "erc20_deployments",
    "networks": [
      "base"
    ],
    "enabled": true,
    "delivery": {
      "adapter": "HTTP",
      "connection": {
        "host": "https://webhook.site/..."
      }
    }
  }'
```

## Step 4: Test the Stream

You can test the transformation logic against block 8925894 on Base, which contains a known ERC-20 deployment:

```json theme={null}
[
  {
    "chain": "base",
    "timestamp": "2024-01-07T15:25:35.000Z",
    "transactionHash": "0xcea27f1618e28ecc59b2faed86cdec29a92218261fe9efe374a39201e93545c5",
    "traceIndex": 0,
    "address": "0x4ed4e862860bed51a9570b96d89af5e1b0efefed"
  }
]
```

Run this test with our [Test endpoint](https://docs.indexing.co/guide/transformations/test):

```bash theme={null}
curl 'https://app.indexing.co/dw/transformations/test?network=base&beat=8925894' \
  -H 'X-API-KEY: <your-api-key>' \
  -F code=@./erc20_contract_deployments.js
```

## Wrap-Up

You’ve now set up a real-time pipeline for detecting ERC-20 contract deployments on **The Neighborhood**.

To go further, **chain this output into a second pipeline** that filters and streams token transfers for these newly deployed tokens.

Need help or want to go further?

* Reach out at [indexing.co/contact](https://www.indexing.co/contact)
* Or email us at [hello@indexing.co](mailto:hello@indexing.co)


# Universal Token Transfers
Source: https://docs.indexing.co/examples/token_transfers



# All Token Transfers

Leveraging our [open source functions](https://docs.indexing.co/guide/transformations/helpers#functions), you can readily get token transfers across any of the [networks](/networks) we support.

Here's how simple it is to get all token transfers:

```javascript theme={null}
function tokenTransfers(block) {
  return templates.tokenTransfers(block);
}
```

This will return transfers matching the following type:

```typescript theme={null}
type NetworkTransfer = {
  amount: number | bigint;
  blockNumber: number;
  from: string;
  index?: string;
  timestamp: string;
  to: string;
  token?: string;
  tokenId?: string;
  tokenType: 'NATIVE' | 'TOKEN' | 'NFT';
  transactionGasFee: bigint;
  transactionHash: string;
};
```

Here's a sample request for testing this against Polygon:

```bash theme={null}
curl "https://app.indexing.co/dw/transformations/test?network=polygon&beat=74046461" \
  -H 'X-API-KEY: <API_KEY>' \
  -H 'Content-Type: application/json' \
  -d '{
    "code": "function(block) { return templates.tokenTransfers(block); }"
  }' | jq
```

# Filtered Transfers

Notably, the above output includes a `tokenType` key. You can leverage this to focus in on particular token types that might be useful.

For instance, this is how you could fetch only NFT transfers:

```javascript theme={null}
function tokenTransfers(block) {
  return templates
    .tokenTransfers(block)
    .filter(txfer => txfer.tokenType === 'NFT');
}
```


# Uniswap swaps across EVM
Source: https://docs.indexing.co/examples/uniswap



# 1. Create a transformation

For this use case, we're going to track Uniswap v2, v3, and v4 swap events. Notably, this will also pick up any protocols that have forked from Uniswap.

Here's a transformation function to pull out all of those events from an EVM block:

```javascript theme={null}
function blockSwaps(block) {
  const swaps = [];

  for (const tx of block.transactions || []) {
    for (const log of tx.receipt?.logs || []) {
      const decodedWithMetadata = utils.evmDecodeLogWithMetadata(log, [
        'event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to)', // V2
        'event Swap(address sender, address recipient, int256 amount0, int256 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick)', // V3
        'event Swap(PoolId indexed id, address indexed sender, int128 amount0, int128 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick, uint24 fee)',
      ]);

      if (decodedWithMetadata) {
        swaps.push({
          chain: block._network,
	        transaction_hash: tx.hash,
	        log_index: log.logIndex,
	        pool_address: log.address?.toLowerCase(),
	        decoded: decodedWithMetadata.decoded,
	      });
      }
    }
  }

	return swaps;
}
```

If we save the above code as `swaps.js`, then we can leverage it to test against any EVM network + block using the [test](/guide/transformations/test) endpoint. Here's how we could do it as a CURL request:

```bash theme={null}
curl "https://app.indexing.co/dw/transformations/test?network=base&beat=25000000" \
	-H "X-API-KEY: <API_KEY>" \
	-F code=@./swaps.js \
	| jq
```

Once we're happy with the results, we can commit the transformation using the [create](/guide/transformations/create) endpoint like this:

```bash theme={null}
curl "https://app.indexing.co/dw/transformations/block_swaps" \
	-H "X-API-KEY: <API_KEY>" \
	-d code=@./swaps.js \
	| jq
```

# 2. Deploy the pipeline

The second, and final step, is simply deploying the pipeline! Use an existing webhook or head over to [webhook.site](https://webhook.site/) to get a temporary one.

You can [create](/guide/pipelines/create) the pipeline with the following payload:

```json theme={null}
{
	"name": "block_swaps",
	"transformation": "block_swaps",
	"networks": ["base"],
	"delivery": {
		"adapter": "HTTP",
		"connection": {
			"host": "<WEBHOOK ENDPOINT>"
		}
	}
}
```

And as a CURL request:

```bash theme={null}
curl https://app.indexing.co/dw/pipelines \
	-H "Content-Type: application/json" \
	-H "X-API-KEY: <API KEY>" \
	-d '{
		"name": "block_swaps",
		"transformation": "block_swaps",
		"networks": ["base"],
		"delivery": {
			"adapter": "HTTP",
			"connection": {
				"host": "<WEBHOOK ENDPOINT>"
			}
		}
	}' \
	| jq
```

<Note>
  You can add any of the supported [networks](/networks) to the pipeline during creation - the more the merrier!
</Note>

It should only take a few seconds to begin seeing data flow. Once you're done expirementing, make sure to disable the pipeline with `enabled: false`:

```bash theme={null}
curl https://app.indexing.co/dw/pipelines \
	-H "Content-Type: application/json" \
	-H "X-API-KEY: <API KEY>" \
	-d '{
    "enabled": false,
		"name": "block_swaps",
		"transformation": "block_swaps",
		"networks": ["base"],
		"delivery": {
			"adapter": "HTTP",
			"connection": {
				"host": "<WEBHOOK ENDPOINT>"
			}
		}
	}' \
	| jq
```


# Architecture and Key Components
Source: https://docs.indexing.co/guide/architecture



The Neighborhood is a distributed data network, purpose-built to get you the transformed, onchain data you actually need—without making you wrangle raw logs or maintain brittle indexers.
This page outlines how The Neighborhood works under the hood and how its modular architecture gives you complete control over your pipeline.

# Core Architecture

The Neighborhood is made up of several composable systems that work together to turn raw blockchain data into clean, actionable payloads:

* **RPC Integration Layer**: Connects directly to blockchain RPCs across EVM, SVM, MoveVM, and other chains—real-time and historical.

* **Parallel Processing Network (aka Neighborhoods)**: Our distributed cluster of nodes process data in parallel and on demand. These Neighborhoods index just in time, reducing latency and cutting down on unnecessary compute.

* **Transformation Engine**: Transforms raw logs into structured output using JavaScript functions you write. Shape your data exactly how you want.

* **Delivery System**: Routes processed data to your destination: Postgres, webhook, Kafka, or more.

* **Configuration API**: Everything is controlled programmatically. Use our API to define pipelines, upload transformations, and manage delivery settings.

# Data Flow

Here’s what happens from block to destination:

1. **Block Ingestion**: New blocks are streamed from live RPCs or pulled from our historical cache.

2. **Distributed Processing**: Blocks are validated and routed to the appropriate Neighborhood nodes.

3. **Filtering**: Your filters determine which addresses, contracts, or event signatures are relevant.

4. **Transformation**: Custom JavaScript transforms run on each matched log or transaction.

5. **Delivery**: The processed payloads are sent to your configured destination in near real-time.

6. **Reorg Handling**: The Neighborhood monitors for chain reorganizations and can emit reorg-aware updates or alerts.

# Modular Pipeline Components

Each pipeline in The Neighborhood is made up of three core parts:

1. **Filters**: Define which chains, contracts, events, or wallet addresses to watch.

2. **Transformations**: Write JavaScript to reshape the data into a format your app can ingest directly.

3. **Delivery**: Choose where the data should go: your database, a webhook, a Kafka topic—you name it. You can find the full list of supported destinations in our [adapter directory](https://www.notion.so/indexing-co/16e25f031053805da10cf65179f977c6?v=097aa09c71c845db9f88d773385d1f5e).

<Note>
  Want to go deeper or have questions about custom deployment patterns like new delivery targets? The Indexing Company is here to help. Reach out at [hello@indexing.co](mailto:hello@indexing.co) or find us on [Farcaster](https://warpcast.com/channel/indexing).
</Note>


# Console
Source: https://docs.indexing.co/guide/console



<Info>
  Have comments, questions, or concerns? Reach out to <a href="mailto:hello@indexing.co">[hello@indexing.co](mailto:hello@indexing.co)</a> 🐇
</Info>

# The Console

The [Console](https://console.indexing.co) is a graphical interface for The Neighborhood. It is the same raw API you already use (filters, transformations, pipelines, and delivery), now with a visual builder on top, so you can go from idea to live pipeline without writing a single curl command.

Everything you can do in the Console maps directly to the API documented in this Guide. Build it by clicking, or build it by curl: the underlying pipelines are identical, and you can switch between the two at any time.

Open it at [console.indexing.co](https://console.indexing.co).

# What You Can Do

* **Start from a template**: Pick a pre-built pipeline from the [template gallery](https://console.indexing.co/templates) (token transfers, swaps, NFT transfers, lending events, and more), choose your networks, and deploy.
* **Describe what you want**: Bring your own agent. Describe the data you're after in plain language and let it draft the filters and transformation for you.
* **Test before you ship**: Run a transformation against a real block and inspect the decoded output, exactly like the [test](/guide/transformations/test) endpoint.
* **Edit the code directly**: Every generated configuration is transparent. View, edit, and export the transformation JavaScript and the pipeline JSON.
* **Deploy and manage**: Save, deploy, enable or disable, and monitor your pipelines from one place.

# Bring Your Own Agent

The Console is agent-friendly by design. Connect the coding agent you already use, like Claude Code, Cursor, or Codex, and let it build, test, and deploy pipelines on your behalf through the Indexing Co MCP server. See the [MCP server walkthrough](/examples/mcp-server) for setup, or browse the per-agent guides at [docs.indexing.co/guides](https://docs.indexing.co).

# No Login Required to Explore

Browse templates, build a pipeline, and test transformations without an account. Authentication is only needed when you want to save, deploy, or manage pipelines.

# Get Started

Open the [Console](https://console.indexing.co) and start from a [template](https://console.indexing.co/templates), or sign up at [accounts.indexing.co](https://accounts.indexing.co) to deploy and manage your pipelines. Email [hello@indexing.co](mailto:hello@indexing.co) for help and free credits.


# Create
Source: https://docs.indexing.co/guide/filters/add

POST /filters/{name}
Add new values for a given filter



# List
Source: https://docs.indexing.co/guide/filters/list

GET /filters/{name}
List values for a given filter



# Overview
Source: https://docs.indexing.co/guide/filters/overview

Or, how to control the firehose

Filters can come in many forms, but there are a couple primary use cases: wallet and contract addresses.

Filters also work *twice* per pipeline:

1. They are applied for each network beat to determine if a beat should even be processed.
2. After processing, the resulting records are filtered again using the pipeline's `filterKeys`.

# Example

Let's say we want to filter `vitalik.eth`'s token transfers.

We'd first [add a filter](/guide/filters/add) for his address, `0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045`.

From there, we could test the following transformation against an Ethereum block containing a token transfer (e.g. block 22062886 with [this tx](0x793e3bb9b8010aba03354383e8101641ed384799be444eaa980dab75cd80e5aa)):

```javascript theme={null}
// vitalik-example.js
function vitalikTokenTransfers(block) {
  const erc20Transfers = [];

  for (const tx of block.transactions) {
    for (const log of tx.receipt?.logs) {
      const decoded = utils.evmDecodeLog(log, [
        'event Transfer(address indexed from, address indexed to, uint256 value)',
      ]);

      if (decoded) {
        erc20Transfers.push({
          transaction_hash: tx.hash,
          log_index: log.logIndex,
          contract_address: log.address.toLowerCase(),
          from: decoded.from,
          to: decoded.to,
        });
      }
    }
  }

  return erc20Transfers;
}
```

NOTE: the above transformation does *not* have its own filter step. Instead, we can specify during [testing](/guide/transformations/test) and in the [pipeline](/guide/pipelines/create) to filter by `from`, `to`, or both.

```bash theme={null}
curl "https://app.indexing.co/dw/transformations/test?network=ethereum&beat=22062886&filter=vitalik&filterKeys\[0\]=to" -H 'x-api-key: <API KEY>' -F code=@./vitalik-example.js | jq
```

^ this will provide a filtered set of token transfers like this:

```json theme={null}
[
  {
    "transaction_hash": "0x9515ed82d894cdaf6d6a6b5952f8438cdaad948e17c9d842deb5c3f311207bc6",
    "log_index": 2,
    "contract_address": "0x7e1fb1be92693ec1da42ee8dfc072990bf3a3000",
    "from": "0x0000000000000000000000000000000000000000",
    "to": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
  }
]
```


# Remove
Source: https://docs.indexing.co/guide/filters/remove

DELETE /filters/{name}
Remove values for a given filter



# Overview
Source: https://docs.indexing.co/guide/overview



<Info>
  Have comments, questions, or concerns? Reach out to <a href="mailto:hello@indexing.co">[hello@indexing.co](mailto:hello@indexing.co)</a> 🐇
</Info>

# Welcome to The Neighborhood

**The Neighborhood** is the fastest way to get transformed, onchain data—delivered exactly how you want it.

We meet the data where it lives (in its raw form onchain), and meet you, our neighbor, where you are—with your existing infra, like databases, webhooks, or Kafka. That gap is bridged by distributed clusters of nodes we call Neighborhoods.

The Neighborhood is a distributed data processing network developed by [The Indexing Company](https://www.indexing.co), a team focused on providing cutting-edge blockchain data infrastructure. While The Neighborhood powers the pipelines, The Indexing Company helps you deploy, optimize, and debug them. Reach out to us anytime at [hello@indexing.co](mailto:hello@indexing.co) or find us on [Farcaster](https://warpcast.com/channel/indexing).

# What You Can Do

Today, the primary way to interact with The Neighborhood is through **pipelines**.

Instead of polling APIs or adapting to rigid subgraph schemas, you get to define:

* What data you want
* How you want it transformed
* Where you want it delivered

Data on demand, just the way you want it.

Each pipeline consists of:

* **Networks**: List of chains to subscribe to
* **Filter**: e.g., contract addresses or wallet addresses
* **Transformation**: JavaScript logic to reshape the data
* **Destination**: Postgres, Webhook, or Kafka

# Authentication

All API endpoints are authenticated using the `X-API-KEY` header.

To get access, sign up at [accounts.indexing.co](https://accounts.indexing.co), email [hello@indexing.co](mailto:hello@indexing.co), or find us on [Farcaster](https://warpcast.com/channel/indexing).

# Multi-Chain Support

The Neighborhood works across many blockchain ecosystems and Virtual Machine (VM) types:

* **EVM**: Ethereum, Optimism, Arbitrum, Base, and more
* **SVM**: Solana and related chains
* **MoveVM**: Sui, Aptos, Movement, etc.
* **UTXO**: Bitcoin, Litecoin, Dogecoin, Cardano, etc.
* **CosmWasm**: Cosmos, Osmosis, Injective and other IBC-compatible chains
* ... and many more: Celestia (data availability), any custom integration with data access

Get the full list of currently supported [networks here](/networks).

# Use Cases

The Neighborhood powers:

* Wallet and portfolio tracking
* DeFi dashboards and market monitors
* Onchain identity and reputation systems
* Cross-chain aggregators
* AI/ML pipelines needing structured blockchain data
* And whatever you're building next!

# Get Started

Sign up for an account at [accounts.indexing.co](https://accounts.indexing.co) to get started with Pipelines. Email [hello@indexing.co](mailto:hello@indexing.co) for help and free credits.


# Backfill
Source: https://docs.indexing.co/guide/pipelines/backfill

POST /pipelines/{name}/backfill
Backfill a given pipeline for a network + filter value combo



# Backfill Wallet
Source: https://docs.indexing.co/guide/pipelines/backfill-wallet

POST /pipelines/{name}/backfill/{wallet}
Backfill a pipeline for a specific wallet address



# Create
Source: https://docs.indexing.co/guide/pipelines/create

POST /pipelines
Create or update a distributed pipeline

# Destinations

There are currently three flavors of destinations available via self-service APIs: Webhooks, WebSockets, and Postgres.

There are [16 total that are currently supported by Indexing Co](https://indexing-co.notion.site/16e25f031053805da10cf65179f977c6?v=097aa09c71c845db9f88d773385d1f5e) generally though - reach out if you need something else!

## Webhooks

Here's an example payload for creating a pipeline that delivers to a webhook:

```json theme={null}
{
  ...
  "delivery": {
    "adapter": "HTTP",
    "connection": {
      "host": "https://webhook.site/...",
      "headers": {
        "some-auth-key": "some-auth-key"
      }
    }
  },
  ...
}
```

### Signing deliveries (HMAC)

For sensitive payloads you can have each delivery signed so your endpoint can verify it came from us, was not modified in transit, and is not a replay. Add a `signing` block to the webhook `connection`:

```json theme={null}
{
  ...
  "delivery": {
    "adapter": "HTTP",
    "connection": {
      "host": "https://your-app.com/webhooks/indexing",
      "headers": {
        "some-auth-key": "some-auth-key"
      },
      "signing": {
        "secret": "whsec_your_shared_secret",
        "header": "X-Indexing-Signature",
        "tsHeader": "X-Indexing-Timestamp"
      }
    }
  },
  ...
}
```

`header` and `tsHeader` are optional and default to `X-Indexing-Signature` and `X-Indexing-Timestamp`. Each delivery then carries:

| Header                 | Value                                                                     |
| ---------------------- | ------------------------------------------------------------------------- |
| `X-Indexing-Timestamp` | Unix time in seconds when the request was signed                          |
| `X-Indexing-Signature` | `sha256=<hex>`, where `<hex> = HMAC_SHA256(secret, "<timestamp>.<body>")` |

To verify, recompute the HMAC over `"<timestamp>.<rawBody>"` and compare it to `X-Indexing-Signature` in constant time:

```js theme={null}
const crypto = require('crypto');

function verify(req, secret) {
  const ts = req.header('X-Indexing-Timestamp');
  const sig = req.header('X-Indexing-Signature'); // "sha256=<hex>"
  if (!ts || !sig) return false;
  if (Math.abs(Date.now() / 1000 - Number(ts)) > 300) return false; // reject replays

  const expected = 'sha256=' + crypto.createHmac('sha256', secret).update(`${ts}.${req.rawBody}`).digest('hex');
  const a = Buffer.from(sig);
  const b = Buffer.from(expected);
  return a.length === b.length && crypto.timingSafeEqual(a, b);
}
```

<Note>
  Verify against the **raw request body bytes**, not a re-serialized JSON object — whitespace or key-ordering differences will break the comparison. In Express, capture the raw body with `express.json({ verify: (req, _res, buf) => { req.rawBody = buf.toString('utf8'); } })`.
</Note>

## WebSockets

Here's an example payload for creating a pipeline that delivers to a websocket:

```json theme={null}
{
  ...
  "delivery": {
    "adapter": "WEBSOCKET",
    "connection": {
      "host": "ws://websocket-host.com/...",
      "headers": {
        "some-auth-key": "some-auth-key"
      }
    }
  },
  ...
}
```

## Postgres

Here's an example payload for creating a pipeline that delivers to a Postgres database:

```json theme={null}
{
  ...
  "delivery": {
    "adapter": "POSTGRES",
    "connectionUri": "postgres://...",
    "table": "vitalik_token_transfers",
    "uniqueKeys": ["transaction_hash", "log_index"]
  },
  ...
}
```

<Note>
  Make sure your database table is already setup! Importantly, this also includes ensuring that there's a unique / primary key index on the table matching the provided `uniqueKeys` in the pipeline.
</Note>


# Disable
Source: https://docs.indexing.co/guide/pipelines/disable

DELETE /pipelines/{name}
Disable Pipeline



# Get
Source: https://docs.indexing.co/guide/pipelines/get

GET /pipelines/{name}
Get Pipeline



# List
Source: https://docs.indexing.co/guide/pipelines/list

GET /pipelines
List all active pipelines



# Disable Networks
Source: https://docs.indexing.co/guide/pipelines/networks-disable

DELETE /pipelines/{name}/networks
Disable Pipeline Networks



# Enable Networks
Source: https://docs.indexing.co/guide/pipelines/networks-enable

POST /pipelines/{name}/networks
Enable Pipeline Networks



# Status
Source: https://docs.indexing.co/guide/pipelines/status

GET /pipelines/{name}/status
Get pipeline health status



# Stream URL
Source: https://docs.indexing.co/guide/pipelines/stream

GET /stream
Get the WebSocket stream URL for real-time pipeline events



# Reliability & Performance
Source: https://docs.indexing.co/guide/quality



# SLAs and Uptime Commitments

The Indexing Company maintains a 99.95% uptime for the internal infrastructure like The Neighborhood and passes along the uptime guarantees of our RPC providers for specific networks (generally 99% or better). Our status page provides real-time information about system performance: [https://admin.indexing.co/status](https://admin.indexing.co/status)

# Data Processing Guarantees

The Neighborhood is built on two core principles:

1. **Meet customers where they are**: We integrate with your existing infrastructure rather than forcing you to adapt to ours.
2. **Be ruthlessly fault tolerant**: We ensure that blockchain data is never lost with "at least once" delivery, even in the event of temporary system issues.

# Chain Reorganization Handling

Chain reorganizations (reorgs) are automatically detected and handled by The Neighborhood:

1. For each new block, we track its unique hash and its parent's hash
2. If a parent hash doesn't match the expected block hash, we detect a reorg
3. Affected blocks are reprocessed to ensure data consistency
4. Depending on your configuration, we can either:
   * Maintain a safe distance from the chain tip (default)
   * Notify you of reorgs for manual handling

# Latency Expectations

The typical latency from onchain confirmation of a block to data delivery is often sub-second for real time data, varying slightly based on specific implementation details and delivery methods. This latency is a starting point, which can be optimized further for specific use cases.

The parallel processing network scales horizontally to handle high volumes of data without sacrificing performance. For services like JITI, full wallet history backfills can complete in as little as one minute, depending on the wallet's activity level and the number of networks being indexed. The eventual goal with the Neighborhood is to have historical data ready in customized schemas at the speed of an API request, which will enabled by the parallel processing of the network.


# Create
Source: https://docs.indexing.co/guide/transformations/create

POST /transformations/{name}
Create or update transformation code



# Get
Source: https://docs.indexing.co/guide/transformations/get

GET /transformations/{name}
Get transformation code



# Helpers
Source: https://docs.indexing.co/guide/transformations/helpers

Functions and packages for transformations.

# Functions

To aid in transformations, we've begun open sourcing common utility functions and templates. You can view all of this on [GitHub](https://github.com/indexing-co/jiti) and as an [npm package](https://www.npmjs.com/package/@indexing/jiti).

<Note>
  Pull requests are welcome! We need the community's help for bugs, new templates, and commonly used utilities.
</Note>

Here's a list of the available functions as they can be used within transformations:

* `templates.tokenTransfers(block)`: pass in an entire block (EVM or not) and get back all of the token transfers within it
* `utils.blockToTimestamp(block)`: derive the timestamp from a given block
* `utils.blockToVM(block)`: helper to determine which VM a given block came from (e.g. EVM, SVM, UTXO)
* `utils.evmAddressToChecksum(address)`: convert an EVM address to its checksum form
* `utils.evmChainToId(chain)`: convert an EVM chain name to a `chainId`; try `block._network` to get the current chain name
* `utils.evmDecodeLog(log, signatures[])`: try decoding an EVM log against a list of event signatures
* `utils.evmDecodeLogWithMetadata(log, signatures[])`: same as `evmDecodeLog`, but also return the name of the matching event
* `utils.evmMethodSignatureToHex(signature)`: convert an EVM event signature (e.g. from an ABI) to its topic0, hexadecimal form

# Available Packages

Although transformations are run in a sandboxed environment, we inject a select few npm packages that can also be used. These include:

* Buffer (from stdlib)
* gzipSync (from zlib)
* [BigNumber](https://www.npmjs.com/package/bignumber.js)
* [borsh](https://www.npmjs.com/package/@coral-xyz/borsh)
* [bs58](https://www.npmjs.com/package/bs58)
* [viem](https://www.npmjs.com/package/viem)


# List
Source: https://docs.indexing.co/guide/transformations/list

GET /transformations
List transformations



# Overview
Source: https://docs.indexing.co/guide/transformations/overview

Making the data work for _you_

In The Neighborhood, our goal is to meet the data where it's at (in its raw form) and you wherever you might find yourself (with a db, webhook, etc).

Transformations are how we bridge that gap. These are simple (or complex) JavaScript functions that run throughout the distributed network. We call this Just In Time Indexing.

Here's a simple example. This function simply takes in a new EVM block and returns its `number` and an ISO formatted `timestamp`.

```javascript theme={null}
function allEVMBlocks(block) {
  return {
    number: block.number,
    timestamp: new Date(block.timestamp * 1000).toISOString(),
  };
}
```

Here's a more complex example counting the number of times each Solana account is found in a block:

```javascript theme={null}
function solanaAccountCount(block) {
  const accountCounts = {};

  for (const tx of block.transactions) {
    if (tx.meta.err) continue;

    const allAccounts = tx.transaction.message.accountKeys
      .concat(tx.meta.loadedAddresses.writable)
      .concat(tx.meta.loadedAddresses.readonly);

    for (const acc of allAccounts) {
      if (!accountCounts[acc]) {
        accountCounts[acc] = 0;
      }
    }

    const allInstructions = tx.transaction.message.instructions.concat(
      tx.meta.innerInstructions.map((ii) => ii.instructions).flat()
    );
    for (const inst of allInstructions) {
      for (const accIdx of inst.accounts) {
        accountCounts[allAccounts[accIdx]] += 1;
      }
    }
  }

  return Object.entries(accountCounts).map(([account, count]) => ({ account, count }));
}
```


# Test
Source: https://docs.indexing.co/guide/transformations/test

POST /transformations/test
Test transformation code without committing it



# 0g
Source: https://docs.indexing.co/networks/0g

Real time indexing for 0g; delivered to you

# Overview

* Network Key: `0G`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/0G/latest](https://jiti.indexing.co/networks/0G/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/0G](https://jiti.indexing.co/status/0G)


# Abstract
Source: https://docs.indexing.co/networks/abstract

Real time indexing for Abstract; delivered to you

# Overview

* Network Key: `ABSTRACT`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/ABSTRACT/latest](https://jiti.indexing.co/networks/ABSTRACT/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/ABSTRACT](https://jiti.indexing.co/status/ABSTRACT)


# Acala
Source: https://docs.indexing.co/networks/acala

Real time indexing for Acala; delivered to you

# Overview

* Network Key: `ACALA`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/ACALA/latest](https://jiti.indexing.co/networks/ACALA/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/ACALA](https://jiti.indexing.co/status/ACALA)


# Aptos
Source: https://docs.indexing.co/networks/aptos

Real time indexing for Aptos; delivered to you

# Overview

* Network Key: `APTOS`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/APTOS/latest](https://jiti.indexing.co/networks/APTOS/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/APTOS](https://jiti.indexing.co/status/APTOS)


# Arbitrum
Source: https://docs.indexing.co/networks/arbitrum

Real time indexing for Arbitrum; delivered to you

# Overview

* Network Key: `ARBITRUM`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/ARBITRUM/latest](https://jiti.indexing.co/networks/ARBITRUM/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/ARBITRUM](https://jiti.indexing.co/status/ARBITRUM)


# Arbitrum Sepolia
Source: https://docs.indexing.co/networks/arbitrum_sepolia

Real time indexing for Arbitrum Sepolia; delivered to you

# Overview

* Network Key: `ARBITRUM_SEPOLIA`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/ARBITRUM\_SEPOLIA/latest](https://jiti.indexing.co/networks/ARBITRUM_SEPOLIA/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/ARBITRUM\_SEPOLIA](https://jiti.indexing.co/status/ARBITRUM_SEPOLIA)


# Astar
Source: https://docs.indexing.co/networks/astar

Real time indexing for Astar; delivered to you

# Overview

* Network Key: `ASTAR`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/ASTAR/latest](https://jiti.indexing.co/networks/ASTAR/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/ASTAR](https://jiti.indexing.co/status/ASTAR)


# Aurora
Source: https://docs.indexing.co/networks/aurora

Real time indexing for Aurora; delivered to you

# Overview

* Network Key: `AURORA`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/AURORA/latest](https://jiti.indexing.co/networks/AURORA/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/AURORA](https://jiti.indexing.co/status/AURORA)


# Avalanche
Source: https://docs.indexing.co/networks/avalanche

Real time indexing for Avalanche; delivered to you

# Overview

* Network Key: `AVALANCHE`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/AVALANCHE/latest](https://jiti.indexing.co/networks/AVALANCHE/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/AVALANCHE](https://jiti.indexing.co/status/AVALANCHE)


# Avalanche Fuji
Source: https://docs.indexing.co/networks/avalanche_fuji

Real time indexing for Avalanche Fuji; delivered to you

# Overview

* Network Key: `AVALANCHE_FUJI`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/AVALANCHE\_FUJI/latest](https://jiti.indexing.co/networks/AVALANCHE_FUJI/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/AVALANCHE\_FUJI](https://jiti.indexing.co/status/AVALANCHE_FUJI)


# Base
Source: https://docs.indexing.co/networks/base

Real time indexing for Base; delivered to you

# Overview

* Network Key: `BASE`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/BASE/latest](https://jiti.indexing.co/networks/BASE/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/BASE](https://jiti.indexing.co/status/BASE)


# Base Sepolia
Source: https://docs.indexing.co/networks/base_sepolia

Real time indexing for Base Sepolia; delivered to you

# Overview

* Network Key: `BASE_SEPOLIA`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/BASE\_SEPOLIA/latest](https://jiti.indexing.co/networks/BASE_SEPOLIA/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/BASE\_SEPOLIA](https://jiti.indexing.co/status/BASE_SEPOLIA)


# Berachain
Source: https://docs.indexing.co/networks/berachain

Real time indexing for Berachain; delivered to you

# Overview

* Network Key: `BERACHAIN`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/BERACHAIN/latest](https://jiti.indexing.co/networks/BERACHAIN/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/BERACHAIN](https://jiti.indexing.co/status/BERACHAIN)


# Bitcoin
Source: https://docs.indexing.co/networks/bitcoin

Real time indexing for Bitcoin; delivered to you

# Overview

* Network Key: `BITCOIN`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/BITCOIN/latest](https://jiti.indexing.co/networks/BITCOIN/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/BITCOIN](https://jiti.indexing.co/status/BITCOIN)


# Bittensor
Source: https://docs.indexing.co/networks/bittensor

Real time indexing for Bittensor; delivered to you

# Overview

* Network Key: `BITTENSOR`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/BITTENSOR/latest](https://jiti.indexing.co/networks/BITTENSOR/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/BITTENSOR](https://jiti.indexing.co/status/BITTENSOR)


# Blast
Source: https://docs.indexing.co/networks/blast

Real time indexing for Blast; delivered to you

# Overview

* Network Key: `BLAST`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/BLAST/latest](https://jiti.indexing.co/networks/BLAST/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/BLAST](https://jiti.indexing.co/status/BLAST)


# Bsc
Source: https://docs.indexing.co/networks/bsc

Real time indexing for Bsc; delivered to you

# Overview

* Network Key: `BSC`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/BSC/latest](https://jiti.indexing.co/networks/BSC/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/BSC](https://jiti.indexing.co/status/BSC)


# Cardano
Source: https://docs.indexing.co/networks/cardano

Real time indexing for Cardano; delivered to you

# Overview

* Network Key: `CARDANO`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/CARDANO/latest](https://jiti.indexing.co/networks/CARDANO/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/CARDANO](https://jiti.indexing.co/status/CARDANO)


# Celestia
Source: https://docs.indexing.co/networks/celestia

Real time indexing for Celestia; delivered to you

# Overview

* Network Key: `CELESTIA`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/CELESTIA/latest](https://jiti.indexing.co/networks/CELESTIA/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/CELESTIA](https://jiti.indexing.co/status/CELESTIA)


# Celo
Source: https://docs.indexing.co/networks/celo

Real time indexing for Celo; delivered to you

# Overview

* Network Key: `CELO`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/CELO/latest](https://jiti.indexing.co/networks/CELO/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/CELO](https://jiti.indexing.co/status/CELO)


# Chiliz
Source: https://docs.indexing.co/networks/chiliz

Real time indexing for Chiliz; delivered to you

# Overview

* Network Key: `CHILIZ`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/CHILIZ/latest](https://jiti.indexing.co/networks/CHILIZ/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/CHILIZ](https://jiti.indexing.co/status/CHILIZ)


# Chiliz Spicy
Source: https://docs.indexing.co/networks/chiliz_spicy

Real time indexing for Chiliz Spicy; delivered to you

# Overview

* Network Key: `CHILIZ_SPICY`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/CHILIZ\_SPICY/latest](https://jiti.indexing.co/networks/CHILIZ_SPICY/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/CHILIZ\_SPICY](https://jiti.indexing.co/status/CHILIZ_SPICY)


# Commons
Source: https://docs.indexing.co/networks/commons

Real time indexing for Commons; delivered to you

# Overview

* Network Key: `COMMONS`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/COMMONS/latest](https://jiti.indexing.co/networks/COMMONS/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/COMMONS](https://jiti.indexing.co/status/COMMONS)


# Core
Source: https://docs.indexing.co/networks/core

Real time indexing for Core; delivered to you

# Overview

* Network Key: `CORE`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/CORE/latest](https://jiti.indexing.co/networks/CORE/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/CORE](https://jiti.indexing.co/status/CORE)


# Cosmos
Source: https://docs.indexing.co/networks/cosmos

Real time indexing for Cosmos; delivered to you

# Overview

* Network Key: `COSMOS`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/COSMOS/latest](https://jiti.indexing.co/networks/COSMOS/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/COSMOS](https://jiti.indexing.co/status/COSMOS)


# Cronos
Source: https://docs.indexing.co/networks/cronos

Real time indexing for Cronos; delivered to you

# Overview

* Network Key: `CRONOS`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/CRONOS/latest](https://jiti.indexing.co/networks/CRONOS/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/CRONOS](https://jiti.indexing.co/status/CRONOS)


# Cyber
Source: https://docs.indexing.co/networks/cyber

Real time indexing for Cyber; delivered to you

# Overview

* Network Key: `CYBER`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/CYBER/latest](https://jiti.indexing.co/networks/CYBER/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/CYBER](https://jiti.indexing.co/status/CYBER)


# Degen
Source: https://docs.indexing.co/networks/degen

Real time indexing for Degen; delivered to you

# Overview

* Network Key: `DEGEN`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/DEGEN/latest](https://jiti.indexing.co/networks/DEGEN/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/DEGEN](https://jiti.indexing.co/status/DEGEN)


# Dogecoin
Source: https://docs.indexing.co/networks/dogecoin

Real time indexing for Dogecoin; delivered to you

# Overview

* Network Key: `DOGECOIN`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/DOGECOIN/latest](https://jiti.indexing.co/networks/DOGECOIN/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/DOGECOIN](https://jiti.indexing.co/status/DOGECOIN)


# Eclipse
Source: https://docs.indexing.co/networks/eclipse

Real time indexing for Eclipse; delivered to you

# Overview

* Network Key: `ECLIPSE`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/ECLIPSE/latest](https://jiti.indexing.co/networks/ECLIPSE/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/ECLIPSE](https://jiti.indexing.co/status/ECLIPSE)


# Enjin
Source: https://docs.indexing.co/networks/enjin

Real time indexing for Enjin; delivered to you

# Overview

* Network Key: `ENJIN`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/ENJIN/latest](https://jiti.indexing.co/networks/ENJIN/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/ENJIN](https://jiti.indexing.co/status/ENJIN)


# Eth Hoodi
Source: https://docs.indexing.co/networks/eth_hoodi

Real time indexing for Eth Hoodi; delivered to you

# Overview

* Network Key: `ETH_HOODI`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/ETH\_HOODI/latest](https://jiti.indexing.co/networks/ETH_HOODI/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/ETH\_HOODI](https://jiti.indexing.co/status/ETH_HOODI)


# Eth Sepolia
Source: https://docs.indexing.co/networks/eth_sepolia

Real time indexing for Eth Sepolia; delivered to you

# Overview

* Network Key: `ETH_SEPOLIA`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/ETH\_SEPOLIA/latest](https://jiti.indexing.co/networks/ETH_SEPOLIA/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/ETH\_SEPOLIA](https://jiti.indexing.co/status/ETH_SEPOLIA)


# Ethereum
Source: https://docs.indexing.co/networks/ethereum

Real time indexing for Ethereum; delivered to you

# Overview

* Network Key: `ETHEREUM`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/ETHEREUM/latest](https://jiti.indexing.co/networks/ETHEREUM/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/ETHEREUM](https://jiti.indexing.co/status/ETHEREUM)


# Ethereum Beacon
Source: https://docs.indexing.co/networks/ethereum_beacon

Real time indexing for Ethereum Beacon; delivered to you

# Overview

* Network Key: `ETHEREUM_BEACON`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/ETHEREUM\_BEACON/latest](https://jiti.indexing.co/networks/ETHEREUM_BEACON/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/ETHEREUM\_BEACON](https://jiti.indexing.co/status/ETHEREUM_BEACON)


# Ethereum Classic
Source: https://docs.indexing.co/networks/ethereum_classic

Real time indexing for Ethereum Classic; delivered to you

# Overview

* Network Key: `ETHEREUM_CLASSIC`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/ETHEREUM\_CLASSIC/latest](https://jiti.indexing.co/networks/ETHEREUM_CLASSIC/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/ETHEREUM\_CLASSIC](https://jiti.indexing.co/status/ETHEREUM_CLASSIC)


# Fantom
Source: https://docs.indexing.co/networks/fantom

Real time indexing for Fantom; delivered to you

# Overview

* Network Key: `FANTOM`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/FANTOM/latest](https://jiti.indexing.co/networks/FANTOM/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/FANTOM](https://jiti.indexing.co/status/FANTOM)


# Fantom Testnet
Source: https://docs.indexing.co/networks/fantom_testnet

Real time indexing for Fantom Testnet; delivered to you

# Overview

* Network Key: `FANTOM_TESTNET`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/FANTOM\_TESTNET/latest](https://jiti.indexing.co/networks/FANTOM_TESTNET/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/FANTOM\_TESTNET](https://jiti.indexing.co/status/FANTOM_TESTNET)


# Filecoin
Source: https://docs.indexing.co/networks/filecoin

Real time indexing for Filecoin; delivered to you

# Overview

* Network Key: `FILECOIN`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/FILECOIN/latest](https://jiti.indexing.co/networks/FILECOIN/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/FILECOIN](https://jiti.indexing.co/status/FILECOIN)


# Filecoin Evm
Source: https://docs.indexing.co/networks/filecoin_evm

Real time indexing for Filecoin Evm; delivered to you

# Overview

* Network Key: `FILECOIN_EVM`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/FILECOIN\_EVM/latest](https://jiti.indexing.co/networks/FILECOIN_EVM/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/FILECOIN\_EVM](https://jiti.indexing.co/status/FILECOIN_EVM)


# Fogo
Source: https://docs.indexing.co/networks/fogo

Real time indexing for Fogo; delivered to you

# Overview

* Network Key: `FOGO`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/FOGO/latest](https://jiti.indexing.co/networks/FOGO/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/FOGO](https://jiti.indexing.co/status/FOGO)


# Fraxtal
Source: https://docs.indexing.co/networks/fraxtal

Real time indexing for Fraxtal; delivered to you

# Overview

* Network Key: `FRAXTAL`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/FRAXTAL/latest](https://jiti.indexing.co/networks/FRAXTAL/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/FRAXTAL](https://jiti.indexing.co/status/FRAXTAL)


# Gnosis
Source: https://docs.indexing.co/networks/gnosis

Real time indexing for Gnosis; delivered to you

# Overview

* Network Key: `GNOSIS`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/GNOSIS/latest](https://jiti.indexing.co/networks/GNOSIS/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/GNOSIS](https://jiti.indexing.co/status/GNOSIS)


# Hashfire
Source: https://docs.indexing.co/networks/hashfire

Real time indexing for Hashfire; delivered to you

# Overview

* Network Key: `HASHFIRE`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/HASHFIRE/latest](https://jiti.indexing.co/networks/HASHFIRE/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/HASHFIRE](https://jiti.indexing.co/status/HASHFIRE)


# Hedera
Source: https://docs.indexing.co/networks/hedera

Real time indexing for Hedera; delivered to you

# Overview

* Network Key: `HEDERA`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/HEDERA/latest](https://jiti.indexing.co/networks/HEDERA/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/HEDERA](https://jiti.indexing.co/status/HEDERA)


# Hemi
Source: https://docs.indexing.co/networks/hemi

Real time indexing for Hemi; delivered to you

# Overview

* Network Key: `HEMI`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/HEMI/latest](https://jiti.indexing.co/networks/HEMI/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/HEMI](https://jiti.indexing.co/status/HEMI)


# Hemi Testnet
Source: https://docs.indexing.co/networks/hemi_testnet

Real time indexing for Hemi Testnet; delivered to you

# Overview

* Network Key: `HEMI_TESTNET`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/HEMI\_TESTNET/latest](https://jiti.indexing.co/networks/HEMI_TESTNET/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/HEMI\_TESTNET](https://jiti.indexing.co/status/HEMI_TESTNET)


# Hyper Core
Source: https://docs.indexing.co/networks/hyper_core

Real time indexing for Hyper Core; delivered to you

# Overview

* Network Key: `HYPER_CORE`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/HYPER\_CORE/latest](https://jiti.indexing.co/networks/HYPER_CORE/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/HYPER\_CORE](https://jiti.indexing.co/status/HYPER_CORE)


# Hyper Evm
Source: https://docs.indexing.co/networks/hyper_evm

Real time indexing for Hyper Evm; delivered to you

# Overview

* Network Key: `HYPER_EVM`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/HYPER\_EVM/latest](https://jiti.indexing.co/networks/HYPER_EVM/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/HYPER\_EVM](https://jiti.indexing.co/status/HYPER_EVM)


# Injective
Source: https://docs.indexing.co/networks/injective

Real time indexing for Injective; delivered to you

# Overview

* Network Key: `INJECTIVE`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/INJECTIVE/latest](https://jiti.indexing.co/networks/INJECTIVE/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/INJECTIVE](https://jiti.indexing.co/status/INJECTIVE)


# Ink
Source: https://docs.indexing.co/networks/ink

Real time indexing for Ink; delivered to you

# Overview

* Network Key: `INK`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/INK/latest](https://jiti.indexing.co/networks/INK/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/INK](https://jiti.indexing.co/status/INK)


# Kaia
Source: https://docs.indexing.co/networks/kaia

Real time indexing for Kaia; delivered to you

# Overview

* Network Key: `KAIA`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/KAIA/latest](https://jiti.indexing.co/networks/KAIA/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/KAIA](https://jiti.indexing.co/status/KAIA)


# Kusama
Source: https://docs.indexing.co/networks/kusama

Real time indexing for Kusama; delivered to you

# Overview

* Network Key: `KUSAMA`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/KUSAMA/latest](https://jiti.indexing.co/networks/KUSAMA/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/KUSAMA](https://jiti.indexing.co/status/KUSAMA)


# Linea
Source: https://docs.indexing.co/networks/linea

Real time indexing for Linea; delivered to you

# Overview

* Network Key: `LINEA`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/LINEA/latest](https://jiti.indexing.co/networks/LINEA/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/LINEA](https://jiti.indexing.co/status/LINEA)


# Linea Sepolia
Source: https://docs.indexing.co/networks/linea_sepolia

Real time indexing for Linea Sepolia; delivered to you

# Overview

* Network Key: `LINEA_SEPOLIA`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/LINEA\_SEPOLIA/latest](https://jiti.indexing.co/networks/LINEA_SEPOLIA/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/LINEA\_SEPOLIA](https://jiti.indexing.co/status/LINEA_SEPOLIA)


# Litecoin
Source: https://docs.indexing.co/networks/litecoin

Real time indexing for Litecoin; delivered to you

# Overview

* Network Key: `LITECOIN`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/LITECOIN/latest](https://jiti.indexing.co/networks/LITECOIN/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/LITECOIN](https://jiti.indexing.co/status/LITECOIN)


# Mantle
Source: https://docs.indexing.co/networks/mantle

Real time indexing for Mantle; delivered to you

# Overview

* Network Key: `MANTLE`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/MANTLE/latest](https://jiti.indexing.co/networks/MANTLE/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/MANTLE](https://jiti.indexing.co/status/MANTLE)


# Megaeth
Source: https://docs.indexing.co/networks/megaeth

Real time indexing for Megaeth; delivered to you

# Overview

* Network Key: `MEGAETH`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/MEGAETH/latest](https://jiti.indexing.co/networks/MEGAETH/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/MEGAETH](https://jiti.indexing.co/status/MEGAETH)


# Mode
Source: https://docs.indexing.co/networks/mode

Real time indexing for Mode; delivered to you

# Overview

* Network Key: `MODE`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/MODE/latest](https://jiti.indexing.co/networks/MODE/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/MODE](https://jiti.indexing.co/status/MODE)


# Monad
Source: https://docs.indexing.co/networks/monad

Real time indexing for Monad; delivered to you

# Overview

* Network Key: `MONAD`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/MONAD/latest](https://jiti.indexing.co/networks/MONAD/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/MONAD](https://jiti.indexing.co/status/MONAD)


# Oasis Sapphire
Source: https://docs.indexing.co/networks/oasis_sapphire

Real time indexing for Oasis Sapphire; delivered to you

# Overview

* Network Key: `OASIS_SAPPHIRE`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/OASIS\_SAPPHIRE/latest](https://jiti.indexing.co/networks/OASIS_SAPPHIRE/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/OASIS\_SAPPHIRE](https://jiti.indexing.co/status/OASIS_SAPPHIRE)


# Oasys
Source: https://docs.indexing.co/networks/oasys

Real time indexing for Oasys; delivered to you

# Overview

* Network Key: `OASYS`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/OASYS/latest](https://jiti.indexing.co/networks/OASYS/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/OASYS](https://jiti.indexing.co/status/OASYS)


# Op Sepolia
Source: https://docs.indexing.co/networks/op_sepolia

Real time indexing for Op Sepolia; delivered to you

# Overview

* Network Key: `OP_SEPOLIA`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/OP\_SEPOLIA/latest](https://jiti.indexing.co/networks/OP_SEPOLIA/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/OP\_SEPOLIA](https://jiti.indexing.co/status/OP_SEPOLIA)


# Optimism
Source: https://docs.indexing.co/networks/optimism

Real time indexing for Optimism; delivered to you

# Overview

* Network Key: `OPTIMISM`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/OPTIMISM/latest](https://jiti.indexing.co/networks/OPTIMISM/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/OPTIMISM](https://jiti.indexing.co/status/OPTIMISM)


# The Networks
Source: https://docs.indexing.co/networks/overview

105 supported networks and counting

Indexing Co supports 105 networks. *All* of these are available for real time processing in The Neighborhood.

The most up to date list can be viewed via an API [here](https://jiti.indexing.co/networks)

<Note>
  Don't see what you need? Reach out!

  We can usually onboard any network within 24 hours
</Note>

# SLAs

We pass along the uptime guarantees of our RPC providers. This varies by chain, but is generally 99.9% or better. For our internal infrastructure, we maintain a 99.95% uptime.

View more about how we support networks and working with us [here](https://indexing-co.notion.site/Indexing-Co-and-You-15e25f03105380489b3fecdc2f6d8408).


# Plasma
Source: https://docs.indexing.co/networks/plasma

Real time indexing for Plasma; delivered to you

# Overview

* Network Key: `PLASMA`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/PLASMA/latest](https://jiti.indexing.co/networks/PLASMA/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/PLASMA](https://jiti.indexing.co/status/PLASMA)


# Plume
Source: https://docs.indexing.co/networks/plume

Real time indexing for Plume; delivered to you

# Overview

* Network Key: `PLUME`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/PLUME/latest](https://jiti.indexing.co/networks/PLUME/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/PLUME](https://jiti.indexing.co/status/PLUME)


# Polkadot
Source: https://docs.indexing.co/networks/polkadot

Real time indexing for Polkadot; delivered to you

# Overview

* Network Key: `POLKADOT`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/POLKADOT/latest](https://jiti.indexing.co/networks/POLKADOT/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/POLKADOT](https://jiti.indexing.co/status/POLKADOT)


# Polygon
Source: https://docs.indexing.co/networks/polygon

Real time indexing for Polygon; delivered to you

# Overview

* Network Key: `POLYGON`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/POLYGON/latest](https://jiti.indexing.co/networks/POLYGON/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/POLYGON](https://jiti.indexing.co/status/POLYGON)


# Provenance
Source: https://docs.indexing.co/networks/provenance

Real time indexing for Provenance; delivered to you

# Overview

* Network Key: `PROVENANCE`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/PROVENANCE/latest](https://jiti.indexing.co/networks/PROVENANCE/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/PROVENANCE](https://jiti.indexing.co/status/PROVENANCE)


# Quai
Source: https://docs.indexing.co/networks/quai

Real time indexing for Quai; delivered to you

# Overview

* Network Key: `QUAI`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/QUAI/latest](https://jiti.indexing.co/networks/QUAI/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/QUAI](https://jiti.indexing.co/status/QUAI)


# Redbelly
Source: https://docs.indexing.co/networks/redbelly

Real time indexing for Redbelly; delivered to you

# Overview

* Network Key: `REDBELLY`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/REDBELLY/latest](https://jiti.indexing.co/networks/REDBELLY/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/REDBELLY](https://jiti.indexing.co/status/REDBELLY)


# Ripple
Source: https://docs.indexing.co/networks/ripple

Real time indexing for Ripple; delivered to you

# Overview

* Network Key: `RIPPLE`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/RIPPLE/latest](https://jiti.indexing.co/networks/RIPPLE/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/RIPPLE](https://jiti.indexing.co/status/RIPPLE)


# Ronin
Source: https://docs.indexing.co/networks/ronin

Real time indexing for Ronin; delivered to you

# Overview

* Network Key: `RONIN`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/RONIN/latest](https://jiti.indexing.co/networks/RONIN/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/RONIN](https://jiti.indexing.co/status/RONIN)


# Scroll
Source: https://docs.indexing.co/networks/scroll

Real time indexing for Scroll; delivered to you

# Overview

* Network Key: `SCROLL`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/SCROLL/latest](https://jiti.indexing.co/networks/SCROLL/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/SCROLL](https://jiti.indexing.co/status/SCROLL)


# Scroll Sepolia
Source: https://docs.indexing.co/networks/scroll_sepolia

Real time indexing for Scroll Sepolia; delivered to you

# Overview

* Network Key: `SCROLL_SEPOLIA`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/SCROLL\_SEPOLIA/latest](https://jiti.indexing.co/networks/SCROLL_SEPOLIA/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/SCROLL\_SEPOLIA](https://jiti.indexing.co/status/SCROLL_SEPOLIA)


# Sei Evm
Source: https://docs.indexing.co/networks/sei_evm

Real time indexing for Sei Evm; delivered to you

# Overview

* Network Key: `SEI_EVM`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/SEI\_EVM/latest](https://jiti.indexing.co/networks/SEI_EVM/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/SEI\_EVM](https://jiti.indexing.co/status/SEI_EVM)


# Shape
Source: https://docs.indexing.co/networks/shape

Real time indexing for Shape; delivered to you

# Overview

* Network Key: `SHAPE`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/SHAPE/latest](https://jiti.indexing.co/networks/SHAPE/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/SHAPE](https://jiti.indexing.co/status/SHAPE)


# Skale Base Sepolia
Source: https://docs.indexing.co/networks/skale_base_sepolia

Real time indexing for Skale Base Sepolia; delivered to you

# Overview

* Network Key: `SKALE_BASE_SEPOLIA`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/SKALE\_BASE\_SEPOLIA/latest](https://jiti.indexing.co/networks/SKALE_BASE_SEPOLIA/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/SKALE\_BASE\_SEPOLIA](https://jiti.indexing.co/status/SKALE_BASE_SEPOLIA)


# Solana
Source: https://docs.indexing.co/networks/solana

Real time indexing for Solana; delivered to you

# Overview

* Network Key: `SOLANA`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/SOLANA/latest](https://jiti.indexing.co/networks/SOLANA/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/SOLANA](https://jiti.indexing.co/status/SOLANA)


# Solana Devnet
Source: https://docs.indexing.co/networks/solana_devnet

Real time indexing for Solana Devnet; delivered to you

# Overview

* Network Key: `SOLANA_DEVNET`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/SOLANA\_DEVNET/latest](https://jiti.indexing.co/networks/SOLANA_DEVNET/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/SOLANA\_DEVNET](https://jiti.indexing.co/status/SOLANA_DEVNET)


# Soneium
Source: https://docs.indexing.co/networks/soneium

Real time indexing for Soneium; delivered to you

# Overview

* Network Key: `SONEIUM`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/SONEIUM/latest](https://jiti.indexing.co/networks/SONEIUM/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/SONEIUM](https://jiti.indexing.co/status/SONEIUM)


# Sonic
Source: https://docs.indexing.co/networks/sonic

Real time indexing for Sonic; delivered to you

# Overview

* Network Key: `SONIC`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/SONIC/latest](https://jiti.indexing.co/networks/SONIC/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/SONIC](https://jiti.indexing.co/status/SONIC)


# Stable
Source: https://docs.indexing.co/networks/stable

Real time indexing for Stable; delivered to you

# Overview

* Network Key: `STABLE`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/STABLE/latest](https://jiti.indexing.co/networks/STABLE/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/STABLE](https://jiti.indexing.co/status/STABLE)


# Starknet
Source: https://docs.indexing.co/networks/starknet

Real time indexing for Starknet; delivered to you

# Overview

* Network Key: `STARKNET`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/STARKNET/latest](https://jiti.indexing.co/networks/STARKNET/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/STARKNET](https://jiti.indexing.co/status/STARKNET)


# Stellar
Source: https://docs.indexing.co/networks/stellar

Real time indexing for Stellar; delivered to you

# Overview

* Network Key: `STELLAR`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/STELLAR/latest](https://jiti.indexing.co/networks/STELLAR/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/STELLAR](https://jiti.indexing.co/status/STELLAR)


# Story
Source: https://docs.indexing.co/networks/story

Real time indexing for Story; delivered to you

# Overview

* Network Key: `STORY`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/STORY/latest](https://jiti.indexing.co/networks/STORY/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/STORY](https://jiti.indexing.co/status/STORY)


# Sui
Source: https://docs.indexing.co/networks/sui

Real time indexing for Sui; delivered to you

# Overview

* Network Key: `SUI`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/SUI/latest](https://jiti.indexing.co/networks/SUI/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/SUI](https://jiti.indexing.co/status/SUI)


# Tempo
Source: https://docs.indexing.co/networks/tempo

Real time indexing for Tempo; delivered to you

# Overview

* Network Key: `TEMPO`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/TEMPO/latest](https://jiti.indexing.co/networks/TEMPO/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/TEMPO](https://jiti.indexing.co/status/TEMPO)


# Terra
Source: https://docs.indexing.co/networks/terra

Real time indexing for Terra; delivered to you

# Overview

* Network Key: `TERRA`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/TERRA/latest](https://jiti.indexing.co/networks/TERRA/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/TERRA](https://jiti.indexing.co/status/TERRA)


# Terra Classic
Source: https://docs.indexing.co/networks/terra_classic

Real time indexing for Terra Classic; delivered to you

# Overview

* Network Key: `TERRA_CLASSIC`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/TERRA\_CLASSIC/latest](https://jiti.indexing.co/networks/TERRA_CLASSIC/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/TERRA\_CLASSIC](https://jiti.indexing.co/status/TERRA_CLASSIC)


# Ton
Source: https://docs.indexing.co/networks/ton

Real time indexing for Ton; delivered to you

# Overview

* Network Key: `TON`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/TON/latest](https://jiti.indexing.co/networks/TON/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/TON](https://jiti.indexing.co/status/TON)


# Tron
Source: https://docs.indexing.co/networks/tron

Real time indexing for Tron; delivered to you

# Overview

* Network Key: `TRON`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/TRON/latest](https://jiti.indexing.co/networks/TRON/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/TRON](https://jiti.indexing.co/status/TRON)


# Unichain
Source: https://docs.indexing.co/networks/unichain

Real time indexing for Unichain; delivered to you

# Overview

* Network Key: `UNICHAIN`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/UNICHAIN/latest](https://jiti.indexing.co/networks/UNICHAIN/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/UNICHAIN](https://jiti.indexing.co/status/UNICHAIN)


# World
Source: https://docs.indexing.co/networks/world

Real time indexing for World; delivered to you

# Overview

* Network Key: `WORLD`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/WORLD/latest](https://jiti.indexing.co/networks/WORLD/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/WORLD](https://jiti.indexing.co/status/WORLD)


# Xpla
Source: https://docs.indexing.co/networks/xpla

Real time indexing for Xpla; delivered to you

# Overview

* Network Key: `XPLA`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/XPLA/latest](https://jiti.indexing.co/networks/XPLA/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/XPLA](https://jiti.indexing.co/status/XPLA)


# Xpla Testnet
Source: https://docs.indexing.co/networks/xpla_testnet

Real time indexing for Xpla Testnet; delivered to you

# Overview

* Network Key: `XPLA_TESTNET`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/XPLA\_TESTNET/latest](https://jiti.indexing.co/networks/XPLA_TESTNET/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/XPLA\_TESTNET](https://jiti.indexing.co/status/XPLA_TESTNET)


# Zcash
Source: https://docs.indexing.co/networks/zcash

Real time indexing for Zcash; delivered to you

# Overview

* Network Key: `ZCASH`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/ZCASH/latest](https://jiti.indexing.co/networks/ZCASH/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/ZCASH](https://jiti.indexing.co/status/ZCASH)


# Zksync
Source: https://docs.indexing.co/networks/zksync

Real time indexing for Zksync; delivered to you

# Overview

* Network Key: `ZKSYNC`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/ZKSYNC/latest](https://jiti.indexing.co/networks/ZKSYNC/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/ZKSYNC](https://jiti.indexing.co/status/ZKSYNC)


# Zora
Source: https://docs.indexing.co/networks/zora

Real time indexing for Zora; delivered to you

# Overview

* Network Key: `ZORA`

# Preview

Click the following link to view a preview of the raw data available: [https://jiti.indexing.co/networks/ZORA/latest](https://jiti.indexing.co/networks/ZORA/latest)

# Status

Click here to view the latest status: [https://jiti.indexing.co/status/ZORA](https://jiti.indexing.co/status/ZORA)