diff --git a/nginx.conf b/nginx.conf
index 8a15a6238cb2..bde3913a84ca 100644
--- a/nginx.conf
+++ b/nginx.conf
@@ -69,7 +69,7 @@ http {
         rewrite ^/docs/en/cookbook/grafting/$                           $scheme://$http_host/docs/en/subgraphs/cookbook/grafting/                           permanent;
         rewrite ^/docs/en/cookbook/immutable-entities-bytes-as-ids/$    $scheme://$http_host/docs/en/subgraphs/best-practices/immutable-entities-bytes-as-ids/ permanent;
         rewrite ^/docs/en/subgraphs/cookbook/immutable-entities-bytes-as-ids/$ $scheme://$http_host/docs/en/subgraphs/best-practices/immutable-entities-bytes-as-ids/ permanent;
-        rewrite ^/docs/en/cookbook/near/$                               $scheme://$http_host/docs/en/subgraphs/cookbook/near/                               permanent;
+        rewrite ^/docs/en/cookbook/near/$                               $scheme://$http_host/docs/en/supported-networks/                                    permanent;
         rewrite ^/docs/en/cookbook/pruning/$                            $scheme://$http_host/docs/en/subgraphs/best-practices/pruning/                      permanent;
         rewrite ^/docs/en/subgraphs/cookbook/pruning/$                  $scheme://$http_host/docs/en/subgraphs/best-practices/pruning/                      permanent;
         rewrite ^/docs/en/cookbook/quick-start/$                        $scheme://$http_host/docs/en/subgraphs/quick-start/                                 permanent;
@@ -80,6 +80,7 @@ http {
         rewrite ^/docs/en/cookbook/timeseries/$                         $scheme://$http_host/docs/en/subgraphs/best-practices/timeseries/                   permanent;
         rewrite ^/docs/en/subgraphs/cookbook/timeseries/$               $scheme://$http_host/docs/en/subgraphs/best-practices/timeseries/                   permanent;
         rewrite ^/docs/en/cookbook/transfer-to-the-graph/$              $scheme://$http_host/docs/en/subgraphs/cookbook/transfer-to-the-graph/              permanent;
+        rewrite ^/docs/en/subgraphs/cookbook/near/$                     $scheme://$http_host/docs/en/supported-networks/                                    permanent;
         rewrite ^/docs/en/subgraphs/cookbook/(.*)$                      $scheme://$http_host/docs/en/subgraphs/guides/$1                                    permanent;
         rewrite ^/docs/en/curating/$                                    $scheme://$http_host/docs/en/resources/roles/curating/                              permanent;
         rewrite ^/docs/en/delegating/$                                  $scheme://$http_host/docs/en/resources/roles/delegating/delegating/                 permanent;
@@ -150,7 +151,7 @@ http {
         rewrite ^/docs/en/substreams/sps/$                              $scheme://$http_host/docs/en/substreams/sps/introduction/                           permanent;
         rewrite ^/docs/en/supported-network-requirements/$              $scheme://$http_host/docs/en/indexing/supported-network-requirements/               permanent;
         rewrite ^/docs/en/supported-networks/arweave/$                  $scheme://$http_host/docs/en/subgraphs/cookbook/arweave/                            permanent;
-        rewrite ^/docs/en/supported-networks/near/$                     $scheme://$http_host/docs/en/subgraphs/cookbook/near/                               permanent;
+        rewrite ^/docs/en/supported-networks/near/$                     $scheme://$http_host/docs/en/supported-networks/                                    permanent;
         rewrite ^/docs/en/tap/$                                         $scheme://$http_host/docs/en/indexing/tap/                                          permanent;
         rewrite ^/docs/en/tokenomics/$                                  $scheme://$http_host/docs/en/resources/tokenomics/                                  permanent;
         rewrite ^/docs/en/ai-suite/$                                    $scheme://$http_host/docs/en/ai-overview/                                           permanent;
@@ -291,6 +292,17 @@ http {
         rewrite ^/docs/en/supported-networks/injective-mainnet/$    $scheme://$http_host/docs/en/supported-networks/injective/        permanent;
         rewrite ^/docs/en/supported-networks/solana-mainnet-beta/$  $scheme://$http_host/docs/en/supported-networks/solana/           permanent;
 
+        # --- supported networks: deprecated networks removed from the registry (v0.8.8) ---
+        rewrite ^/docs/en/subgraphs/guides/near/$                           $scheme://$http_host/docs/en/supported-networks/                      permanent;
+        rewrite ^/docs/en/supported-networks/fuse/$                         $scheme://$http_host/docs/en/supported-networks/                      permanent;
+        rewrite ^/docs/en/supported-networks/fuse-testnet/$                 $scheme://$http_host/docs/en/supported-networks/                      permanent;
+        rewrite ^/docs/en/supported-networks/kaia/$                         $scheme://$http_host/docs/en/supported-networks/                      permanent;
+        rewrite ^/docs/en/supported-networks/kaia-testnet/$                 $scheme://$http_host/docs/en/supported-networks/                      permanent;
+        rewrite ^/docs/en/supported-networks/near-mainnet/$                 $scheme://$http_host/docs/en/supported-networks/                      permanent;
+        rewrite ^/docs/en/supported-networks/near-testnet/$                 $scheme://$http_host/docs/en/supported-networks/                      permanent;
+        rewrite ^/docs/en/supported-networks/viction/$                      $scheme://$http_host/docs/en/supported-networks/                      permanent;
+        rewrite ^/docs/en/supported-networks/zksync-era-sepolia/$           $scheme://$http_host/docs/en/supported-networks/                      permanent;
+
         location / {
             try_files $uri $uri.html $uri/index.html =404;
         }
diff --git a/website/route-lockfile.txt b/website/route-lockfile.txt
index ec59d3b64416..8fb7afb6123e 100644
--- a/website/route-lockfile.txt
+++ b/website/route-lockfile.txt
@@ -51,7 +51,6 @@
 /en/subgraphs/existing-subgraphs/standard-subgraphs/
 /en/subgraphs/guides/enums/
 /en/subgraphs/guides/grafting/
-/en/subgraphs/guides/near/
 /en/subgraphs/guides/secure-api-keys-nextjs/
 /en/subgraphs/guides/subgraph-composition/
 /en/subgraphs/guides/subgraph-debug-forking/
@@ -135,8 +134,6 @@
 /en/supported-networks/joc-testnet/
 /en/supported-networks/joc/
 /en/supported-networks/jungle4/
-/en/supported-networks/kaia-testnet/
-/en/supported-networks/kaia/
 /en/supported-networks/linea-sepolia/
 /en/supported-networks/linea/
 /en/supported-networks/litecoin/
@@ -149,8 +146,6 @@
 /en/supported-networks/monad/
 /en/supported-networks/moonbeam/
 /en/supported-networks/moonriver/
-/en/supported-networks/near-mainnet/
-/en/supported-networks/near-testnet/
 /en/supported-networks/neox-testnet/
 /en/supported-networks/neox/
 /en/supported-networks/optimism-sepolia/
@@ -186,7 +181,6 @@
 /en/supported-networks/tron/
 /en/supported-networks/unichain-testnet/
 /en/supported-networks/unichain/
-/en/supported-networks/viction/
 /en/supported-networks/wax-testnet/
 /en/supported-networks/wax/
 /en/supported-networks/worldchain/
@@ -194,6 +188,5 @@
 /en/supported-networks/xlayer-sepolia/
 /en/supported-networks/zetachain/
 /en/supported-networks/zilliqa-testnet/
-/en/supported-networks/zksync-era-sepolia/
 /en/supported-networks/zksync-era/
 /en/supported-networks/zora/
diff --git a/website/src/HomePage.tsx b/website/src/HomePage.tsx
index e14b1bb8f44b..6e5a0c12ce4c 100644
--- a/website/src/HomePage.tsx
+++ b/website/src/HomePage.tsx
@@ -163,7 +163,7 @@ export default function HomePage({ supportedNetworks }: { supportedNetworks: Sup
           <p>
             {t('index.supportedNetworks.description.base', [
               <ExperimentalLink key="link-1" href="/supported-networks/">
-                60+ {t('index.supportedNetworks.description.networks')}
+                {t('index.supportedNetworks.description.networks')}
               </ExperimentalLink>,
               <ExperimentalLink key="link" href="info@thegraph.foundation">
                 {t('index.supportedNetworks.description.completeThisForm')}
diff --git a/website/src/pages/en/about.mdx b/website/src/pages/en/about.mdx
index 9d005bf3205f..46e813de8300 100644
--- a/website/src/pages/en/about.mdx
+++ b/website/src/pages/en/about.mdx
@@ -5,7 +5,7 @@ description: This page summarizes the core concepts and basics of The Graph Netw
 
 ## What is The Graph?
 
-The Graph is a suite of blockchain data infrastructure products that extract, process, and deliver scalable blockchain data solutions across 60+ networks. The Graph enables application developers, data analysts, AI agents, and enterprise teams that need structured, reliable, and real-time access to blockchain data. Products include Subgraphs and Substreams. As of early 2026, The Graph has served over 1.27 trillion queries to more than 75,000 projects, powered by 50+ independent Indexer nodes worldwide.
+The Graph is a suite of blockchain data infrastructure products that extract, process, and deliver scalable blockchain data solutions. The Graph enables application developers, data analysts, AI agents, and enterprise teams that need structured, reliable, and real-time access to blockchain data. Products include Subgraphs and Substreams. As of early 2026, The Graph has served over 1.27 trillion queries to more than 75,000 projects, powered by 50+ independent Indexer nodes worldwide.
 
 To learn more about The Graph from a non-technical perspective, visit [The Graph Overview](https://thegraph.com/what-is-the-graph/).
 
diff --git a/website/src/pages/en/gateways/subgraphs/overview.mdx b/website/src/pages/en/gateways/subgraphs/overview.mdx
index d84c516767dc..e7a0bf208d93 100644
--- a/website/src/pages/en/gateways/subgraphs/overview.mdx
+++ b/website/src/pages/en/gateways/subgraphs/overview.mdx
@@ -19,7 +19,7 @@ A Subgraph Gateway is the entry point between Data Consumers and the Indexers wh
 
 The Graph is an indexing and query protocol for blockchain data. One of The Graph's products are Subgraphs, which open APIs that extract, process, and store blockchain data so anyone can query it. Through The Graph protocol, the Subgraph Network is the decentralized set of independent Indexers who sync those Subgraphs and serve those results to end consumers.
 
-The network hosts [15,000+ published Subgraphs across dozens of chains](https://thegraph.com/explorer), including high-demand ones like Uniswap, ENS, and Lido. With [Graph Horizon now live](https://thegraph.com/blog/horizon-upgrade-live/), The Graph protocol has generalized into an open marketplace of interchangeable data services: the Subgraph data service is the first, and the payment rails in this documentation (Graph Tally and Horizon Escrow) are the same ones future services will use.
+The network hosts [15,000+ published Subgraphs across many chains](https://thegraph.com/explorer), including high-demand ones like Uniswap, ENS, and Lido. With [Graph Horizon now live](https://thegraph.com/blog/horizon-upgrade-live/), The Graph protocol has generalized into an open marketplace of interchangeable data services: the Subgraph data service is the first, and the payment rails in this documentation (Graph Tally and Horizon Escrow) are the same ones future services will use.
 
 A Subgraph Gateway lets a service provider put all of this to work under their own brand. Consumers send GraphQL queries to a gateway endpoint, and it discovers which Indexers can serve each one, routes to the best candidates, returns the response, and pays the Indexers it used. It is not strictly required (as consumers can query Indexers directly), but since individual Indexers are independent operators that may slow down or drop offline at any time, a Gateway absorbs that variability to maintain higher quality of service (QoS) while handling per-query payment.
 
@@ -37,7 +37,7 @@ Running a Gateway gives service providers and their customers query access to ev
 
 ### Support More Indexed Chains
 
-The Graph Network indexes Subgraphs across dozens of chains, and that coverage grows as new chains are integrated. Routing through a Gateway means Operators can support more chains for their customers without operating a node on each one: as The Graph adds chain support, Gateway Operators can serve those Subgraphs through the same endpoint. This lets a service provider expand multichain coverage at the speed of the network rather than the speed of their own infrastructure buildout. An Operator is not limited to the chains already integrated, either: an Operator that needs a new chain can help drive its integration onto the network, covered in [Chain Integrations](/gateways/subgraphs/ecosystem/chain-integrations/).
+The Graph Network indexes Subgraphs across many chains, and that coverage grows as new chains are integrated. Routing through a Gateway means Operators can support more chains for their customers without operating a node on each one: as The Graph adds chain support, Gateway Operators can serve those Subgraphs through the same endpoint. This lets a service provider expand multichain coverage at the speed of the network rather than the speed of their own infrastructure buildout. An Operator is not limited to the chains already integrated, either: an Operator that needs a new chain can help drive its integration onto the network, covered in [Chain Integrations](/gateways/subgraphs/ecosystem/chain-integrations/).
 
 ### Offset Indexing Infrastructure Costs
 
diff --git a/website/src/pages/en/index.json b/website/src/pages/en/index.json
index dbf678e0d9b5..1f9f37063fb4 100644
--- a/website/src/pages/en/index.json
+++ b/website/src/pages/en/index.json
@@ -2,7 +2,7 @@
   "title": "Home",
   "hero": {
     "title": "The Graph Docs",
-    "description": "The Graph is a blockchain data solution that powers applications, analytics, and AI on 60+ chains. The Graph's core products include Subgraphs for indexing smart contracts and Substreams for real-time and historical data streaming.",
+    "description": "The Graph is a blockchain data solution that powers applications, analytics, and AI. The Graph's core products include Subgraphs for indexing smart contracts and Substreams for real-time and historical data streaming.",
     "cta1": "How The Graph works",
     "cta2": "Build your first Subgraph"
   },
@@ -50,7 +50,7 @@
     "infoLink": "Contact The Graph Foundation",
     "description": {
       "base": "The Graph supports {0}. To add a new network, {1}",
-      "networks": "networks",
+      "networks": "a growing list of networks",
       "completeThisForm": "complete this form"
     },
     "seeAllNetworks": "See all {0} networks",
diff --git a/website/src/pages/en/subgraphs/guides/_meta.js b/website/src/pages/en/subgraphs/guides/_meta.js
index 385bc230b75d..c3ea33cb5a4a 100644
--- a/website/src/pages/en/subgraphs/guides/_meta.js
+++ b/website/src/pages/en/subgraphs/guides/_meta.js
@@ -5,5 +5,4 @@ export default {
   'subgraph-composition': 'Composable Subgraphs',
   enums: 'Using Enums',
   'secure-api-keys-nextjs': 'Securing API Keys with Next.js',
-  near: 'NEAR Subgraphs',
 }
diff --git a/website/src/pages/en/subgraphs/guides/near.mdx b/website/src/pages/en/subgraphs/guides/near.mdx
deleted file mode 100644
index a1bc322d79dd..000000000000
--- a/website/src/pages/en/subgraphs/guides/near.mdx
+++ /dev/null
@@ -1,283 +0,0 @@
----
-title: Building Subgraphs on NEAR
----
-
-This guide is an introduction to building Subgraphs indexing smart contracts on the [NEAR blockchain](https://docs.near.org/).
-
-## What is NEAR?
-
-[NEAR](https://near.org/) is a smart contract platform for building decentralized applications. Visit the [official documentation](https://docs.near.org/concepts/basics/protocol) for more information.
-
-## What are NEAR Subgraphs?
-
-The Graph gives developers tools to process blockchain events and make the resulting data easily available via a GraphQL API, known individually as a Subgraph. [Graph Node](https://github.com/graphprotocol/graph-node) is now able to process NEAR events, which means that NEAR developers can now build Subgraphs to index their smart contracts.
-
-Subgraphs are event-based, which means that they listen for and then process onchain events. There are currently two types of handlers supported for NEAR Subgraphs:
-
-- Block handlers: these are run on every new block
-- Receipt handlers: run every time a message is executed at a specified account
-
-[From the NEAR documentation](https://docs.near.org/build/data-infrastructure/lake-data-structures/receipt):
-
-> A Receipt is the only actionable object in the system. When we talk about "processing a transaction" on the NEAR platform, this eventually means "applying receipts" at some point.
-
-## Building a NEAR Subgraph
-
-`@graphprotocol/graph-cli` is a command-line tool for building and deploying Subgraphs.
-
-`@graphprotocol/graph-ts` is a library of Subgraph-specific types.
-
-NEAR Subgraph development requires `graph-cli` above version `0.23.0`, and `graph-ts` above version `0.23.0`.
-
-> Building a NEAR Subgraph is very similar to building a Subgraph that indexes Ethereum.
-
-There are three aspects of Subgraph definition:
-
-**subgraph.yaml:** the Subgraph manifest, defining the data sources of interest, and how they should be processed. NEAR is a new `kind` of data source.
-
-**schema.graphql:** a schema file that defines what data is stored for your Subgraph, and how to query it via GraphQL. The requirements for NEAR Subgraphs are covered by [the existing documentation](/developing/creating-a-subgraph/#the-graphql-schema).
-
-**AssemblyScript Mappings:** [AssemblyScript code](/subgraphs/developing/creating/graph-ts/api/) that translates from the event data to the entities defined in your schema. NEAR support introduces NEAR-specific data types and new JSON parsing functionality.
-
-During Subgraph development there are two key commands:
-
-```bash
-$ graph codegen # generates types from the schema file identified in the manifest
-$ graph build # generates Web Assembly from the AssemblyScript files, and prepares all the Subgraph files in a /build folder
-```
-
-### Subgraph Manifest Definition
-
-The Subgraph manifest (`subgraph.yaml`) identifies the data sources for the Subgraph, the triggers of interest, and the functions that should be run in response to those triggers. See below for an example Subgraph manifest for a NEAR Subgraph:
-
-```yaml
-specVersion: 1.3.0
-schema:
-  file: ./src/schema.graphql # link to the schema file
-dataSources:
-  - kind: near
-    network: near-mainnet
-    source:
-      account: app.good-morning.near # This data source will monitor this account
-      startBlock: 10662188 # Required for NEAR
-    mapping:
-      apiVersion: 0.0.9
-      language: wasm/assemblyscript
-      blockHandlers:
-        - handler: handleNewBlock # the function name in the mapping file
-      receiptHandlers:
-        - handler: handleReceipt # the function name in the mapping file
-      file: ./src/mapping.ts # link to the file with the Assemblyscript mappings
-```
-
-- NEAR Subgraphs introduce a new `kind` of data source (`near`)
-- The `network` should correspond to a network on the hosting Graph Node. On Subgraph Studio, NEAR's mainnet is `near-mainnet`, and NEAR's testnet is `near-testnet`
-- NEAR data sources introduce an optional `source.account` field, which is a human-readable ID corresponding to a [NEAR account](https://docs.near.org/concepts/protocol/account-model). This can be an account or a sub-account.
-- NEAR data sources introduce an alternative optional `source.accounts` field, which contains optional suffixes and prefixes. At least prefix or suffix must be specified, they will match the any account starting or ending with the list of values respectively. The example below would match: `[app|good].*[morning.near|morning.testnet]`. If only a list of prefixes or suffixes is necessary the other field can be omitted.
-
-```yaml
-accounts:
-  prefixes:
-    - app
-    - good
-  suffixes:
-    - morning.near
-    - morning.testnet
-```
-
-NEAR data sources support two types of handlers:
-
-- `blockHandlers`: run on every new NEAR block. No `source.account` is required.
-- `receiptHandlers`: run on every receipt where the data source's `source.account` is the recipient. Note that only exact matches are processed ([subaccounts](https://docs.near.org/tutorials/crosswords/basics/add-functions-call#create-a-subaccount) must be added as independent data sources).
-
-### Schema Definition
-
-Schema definition describes the structure of the resulting Subgraph database and the relationships between entities. This is agnostic of the original data source. There are more details on Subgraph schema definition [here](/developing/creating-a-subgraph/#the-graphql-schema).
-
-### AssemblyScript Mappings
-
-The handlers for processing events are written in [AssemblyScript](https://www.assemblyscript.org/).
-
-NEAR indexing introduces NEAR-specific data types to the [AssemblyScript API](/subgraphs/developing/creating/graph-ts/api/).
-
-```typescript
-
-class ExecutionOutcome {
-      gasBurnt: u64,
-      blockHash: Bytes,
-      id: Bytes,
-      logs: Array<string>,
-      receiptIds: Array<Bytes>,
-      tokensBurnt: BigInt,
-      executorId: string,
-  }
-
-class ActionReceipt {
-      predecessorId: string,
-      receiverId: string,
-      id: CryptoHash,
-      signerId: string,
-      gasPrice: BigInt,
-      outputDataReceivers: Array<DataReceiver>,
-      inputDataIds: Array<CryptoHash>,
-      actions: Array<ActionValue>,
-  }
-
-class BlockHeader {
-      height: u64,
-      prevHeight: u64,// Always zero when version < V3
-      epochId: Bytes,
-      nextEpochId: Bytes,
-      chunksIncluded: u64,
-      hash: Bytes,
-      prevHash: Bytes,
-      timestampNanosec: u64,
-      randomValue: Bytes,
-      gasPrice: BigInt,
-      totalSupply: BigInt,
-      latestProtocolVersion: u32,
-  }
-
-class ChunkHeader {
-      gasUsed: u64,
-      gasLimit: u64,
-      shardId: u64,
-      chunkHash: Bytes,
-      prevBlockHash: Bytes,
-      balanceBurnt: BigInt,
-  }
-
-class Block {
-      author: string,
-      header: BlockHeader,
-      chunks: Array<ChunkHeader>,
-  }
-
-class ReceiptWithOutcome {
-      outcome: ExecutionOutcome,
-      receipt: ActionReceipt,
-      block: Block,
-  }
-```
-
-These types are passed to block & receipt handlers:
-
-- Block handlers will receive a `Block`
-- Receipt handlers will receive a `ReceiptWithOutcome`
-
-Otherwise, the rest of the [AssemblyScript API](/subgraphs/developing/creating/graph-ts/api/) is available to NEAR Subgraph developers during mapping execution.
-
-This includes a new JSON parsing function - logs on NEAR are frequently emitted as stringified JSONs. A new `json.fromString(...)` function is available as part of the [JSON API](/subgraphs/developing/creating/graph-ts/api/#json-api) to allow developers to easily process these logs.
-
-## Deploying a NEAR Subgraph
-
-Once you have a built Subgraph, it is time to deploy it to Graph Node for indexing. NEAR Subgraphs can be deployed to any Graph Node `>=v0.26.x` (this version has not yet been tagged & released).
-
-Subgraph Studio and the upgrade Indexer on The Graph Network currently supports indexing NEAR mainnet and testnet in beta, with the following network names:
-
-- `near-mainnet`
-- `near-testnet`
-
-More information on creating and deploying Subgraphs on Subgraph Studio can be found [here](/deploying/deploying-a-subgraph-to-studio/).
-
-As a quick primer - the first step is to "create" your Subgraph - this only needs to be done once. On Subgraph Studio, this can be done from [your Dashboard](https://thegraph.com/studio/): "Create a Subgraph".
-
-Once your Subgraph has been created, you can deploy your Subgraph by using the `graph deploy` CLI command:
-
-```sh
-$ graph create --node <graph-node-url> <subgraph-name> # creates a Subgraph on a local Graph Node (on Subgraph Studio, this is done via the UI)
-$ graph deploy --node <graph-node-url> --ipfs https://ipfs.thegraph.com <subgraph-name> # uploads the build files to a specified IPFS endpoint, and then deploys the Subgraph to a specified Graph Node based on the manifest IPFS hash
-```
-
-The node configuration will depend on where the Subgraph is being deployed.
-
-### Subgraph Studio
-
-```sh
-graph auth
-graph deploy <subgraph-name>
-```
-
-### Local Graph Node (based on default configuration)
-
-```sh
-graph deploy --node http://localhost:8020/ --ipfs http://localhost:5001 <subgraph-name>
-```
-
-Once your Subgraph has been deployed, it will be indexed by Graph Node. You can check its progress by querying the Subgraph itself:
-
-```graphql
-{
-  _meta {
-    block {
-      number
-    }
-  }
-}
-```
-
-### Indexing NEAR with a Local Graph Node
-
-Running a Graph Node that indexes NEAR has the following operational requirements:
-
-- NEAR Indexer Framework with Firehose instrumentation
-- NEAR Firehose Component(s)
-- Graph Node with Firehose endpoint configured
-
-We will provide more information on running the above components soon.
-
-## Querying a NEAR Subgraph
-
-The GraphQL endpoint for NEAR Subgraphs is determined by the schema definition, with the existing API interface. Please visit the [GraphQL API documentation](/subgraphs/querying/graphql-api/) for more information.
-
-## Example Subgraphs
-
-Here are some example Subgraphs for reference:
-
-[NEAR Blocks](https://github.com/graphprotocol/graph-tooling/tree/main/examples/near-blocks)
-
-[NEAR Receipts](https://github.com/graphprotocol/graph-tooling/tree/main/examples/near-receipts)
-
-## FAQ
-
-### How does the beta work?
-
-NEAR support is in beta, which means that there may be changes to the API.
-
-### Can a Subgraph index both NEAR and EVM chains?
-
-No, a Subgraph can only support data sources from one chain/network.
-
-### Can Subgraphs react to more specific triggers?
-
-Currently, only Block and Receipt triggers are supported. We are investigating triggers for function calls to a specified account. We are also interested in supporting event triggers, once NEAR has native event support.
-
-### Will receipt handlers trigger for accounts and their sub-accounts?
-
-If an `account` is specified, that will only match the exact account name. It is possible to match sub-accounts by specifying an `accounts` field, with `suffixes` and `prefixes` specified to match accounts and sub-accounts, for example the following would match all `mintbase1.near` sub-accounts:
-
-```yaml
-accounts:
-  suffixes:
-    - mintbase1.near
-```
-
-### Can NEAR Subgraphs make view calls to NEAR accounts during mappings?
-
-This is not supported. We are evaluating whether this functionality is required for indexing.
-
-### Can I use data source templates in my NEAR Subgraph?
-
-This is not currently supported. We are evaluating whether this functionality is required for indexing.
-
-### Ethereum Subgraphs support "pending" and "current" versions, how can I deploy a "pending" version of a NEAR Subgraph?
-
-Pending functionality is not yet supported for NEAR Subgraphs. In the interim, you can deploy a new version to a different "named" Subgraph, and then when that is synced with the chain head, you can redeploy to your primary "named" Subgraph, which will use the same underlying deployment ID, so the main Subgraph will be instantly synced.
-
-### My question hasn't been answered, where can I get more help building NEAR Subgraphs?
-
-If it is a general question about Subgraph development, there is a lot more information in the rest of the [Developer documentation](/subgraphs/quick-start/). Otherwise please join [The Graph Protocol Discord](https://discord.gg/graphprotocol) and ask in the #near channel or email near@thegraph.com.
-
-## References
-
-- [NEAR developer documentation](https://docs.near.org/tutorials/crosswords/basics/set-up-skeleton)
diff --git a/website/src/supportedNetworks/GetApiKeyButton.tsx b/website/src/supportedNetworks/GetApiKeyButton.tsx
new file mode 100644
index 000000000000..661e4821c057
--- /dev/null
+++ b/website/src/supportedNetworks/GetApiKeyButton.tsx
@@ -0,0 +1,93 @@
+import { type ReactNode } from 'react'
+
+import { ExperimentalButton } from '@edgeandnode/gds'
+import { ArrowUpRight } from '@edgeandnode/gds/icons'
+
+import { Heading } from '@/components'
+
+import { useCurrentNetwork } from './NetworkContext'
+
+const SUBGRAPH_STUDIO_API_KEYS_URL = 'https://thegraph.com/studio/apikeys/'
+const SUBSTREAMS_KEY_PROVIDERS = [
+  { match: 'streamingfast.io', href: 'https://thegraph.market/' },
+  { match: 'pinax.network', href: 'https://app.pinax.network/' },
+]
+
+type Product = 'subgraphs' | 'substreams'
+
+/**
+ * "Get API Key" call to action for a network page's Subgraphs or Substreams section.
+ *
+ * - `subgraphs` links to the API Keys page in Subgraph Studio.
+ * - `substreams` links to The Graph Market, the preferred provider. Networks the registry lists
+ *   without a The Graph Market endpoint fall back to Pinax Network, since a The Graph Market key
+ *   would not stream that network.
+ */
+export function GetApiKeyButton({ product }: { product: Product }) {
+  const network = useCurrentNetwork()
+  const href =
+    product === 'subgraphs'
+      ? SUBGRAPH_STUDIO_API_KEYS_URL
+      : (SUBSTREAMS_KEY_PROVIDERS.find((provider) =>
+          (network?.services.substreams ?? []).some((url) => url.includes(provider.match)),
+        )?.href ?? 'https://thegraph.market/')
+
+  return (
+    <span className="graph-docs-not-markdown shrink-0">
+      <ExperimentalButton
+        variant="primary"
+        size="large"
+        href={href}
+        target="_blank"
+        iconAfter={<ArrowUpRight alt="" />}
+      >
+        Get API Key
+      </ExperimentalButton>
+    </span>
+  )
+}
+
+const GRAPH_EXPLORER_URL = 'https://thegraph.com/explorer/'
+
+/**
+ * A markdown-styled `h2` with a call-to-action button beside it. The heading keeps the standard
+ * `h2` styling and anchor link; on narrow screens the button wraps below the heading.
+ */
+function SectionHeadingWithButton({ id, title, button }: { id: string; title: ReactNode; button: ReactNode }) {
+  return (
+    <div className="mb-8 mt-12 flex flex-wrap items-center justify-between gap-x-6 gap-y-3">
+      <Heading.H2 id={id} className="relative m-0">
+        {title}
+      </Heading.H2>
+      {button}
+    </div>
+  )
+}
+
+/** "Indexing {Chain} with Subgraphs/Substreams" section heading with a "Get API Key" button beside it. */
+export function ProductSectionHeading({ product, id, title }: { product: Product; id: string; title: ReactNode }) {
+  return <SectionHeadingWithButton id={id} title={title} button={<GetApiKeyButton product={product} />} />
+}
+
+/** "Find Existing Subgraphs on {Chain}" section heading with an "Explore" button linking to Graph Explorer. */
+export function ExploreSectionHeading({ id, title }: { id: string; title: ReactNode }) {
+  return (
+    <SectionHeadingWithButton
+      id={id}
+      title={title}
+      button={
+        <span className="graph-docs-not-markdown shrink-0">
+          <ExperimentalButton
+            variant="primary"
+            size="large"
+            href={GRAPH_EXPLORER_URL}
+            target="_blank"
+            iconAfter={<ArrowUpRight alt="" />}
+          >
+            Explore
+          </ExperimentalButton>
+        </span>
+      }
+    />
+  )
+}
diff --git a/website/src/supportedNetworks/NetworkContext.tsx b/website/src/supportedNetworks/NetworkContext.tsx
new file mode 100644
index 000000000000..dc66ce1b2578
--- /dev/null
+++ b/website/src/supportedNetworks/NetworkContext.tsx
@@ -0,0 +1,66 @@
+import { createContext, type ReactNode, useContext } from 'react'
+
+import { Callout } from '@/components'
+
+import { type SupportedNetwork } from './utils'
+
+// The network whose Supported Networks page is rendering. `NetworkDetailsPage` provides it so
+// the shared custom-content partials (./customContent/_*.mdx) can branch on registry data
+// instead of per-page props.
+export const NetworkContext = createContext<SupportedNetwork | null>(null)
+
+export function useCurrentNetwork(): SupportedNetwork | null {
+  return useContext(NetworkContext)
+}
+
+/** Whether Subgraph Studio indexes this network (a Studio entry in `services.subgraphs`). */
+function useHasStudioIndexing(): boolean {
+  return useCurrentNetwork()?.subgraphsStudio ?? true
+}
+
+/** `description` of each `kind: 'backstop'` entry in the network's `services.subgraphs`. */
+function useBackstopDescriptions(): string[] {
+  const network = useCurrentNetwork()
+  return (network?.services.subgraphs ?? []).flatMap((entry) =>
+    typeof entry !== 'string' && entry.kind === 'backstop' && entry.description ? [entry.description] : [],
+  )
+}
+
+/** Renders `children` when Subgraph Studio indexes the current network, `fallback` otherwise. */
+export function StudioIndexing({ children, fallback = null }: { children?: ReactNode; fallback?: ReactNode }) {
+  return <>{useHasStudioIndexing() ? children : fallback}</>
+}
+
+/**
+ * Warning shown on networks Subgraph Studio can deploy and publish to, but does not index.
+ * Adds the registry's backstop `description` (community indexing directions) when present.
+ */
+export function SubgraphStudioIndexingNotice({ chainName }: { chainName: string }) {
+  const hasStudioIndexing = useHasStudioIndexing()
+  const backstopDescriptions = useBackstopDescriptions()
+  if (hasStudioIndexing) return null
+  return (
+    <Callout data-callout-type="warning">
+      This network does not have Subgraph Studio indexing support. Publish your Subgraph to The Graph Network to get
+      indexing support on {chainName}.{backstopDescriptions.length > 0 && ` ${backstopDescriptions.join(' ')}`}
+    </Callout>
+  )
+}
+
+/**
+ * Recommended curation signal for the current network: 1,000 GRT where the network earns indexing
+ * rewards (`issuanceRewards: true`), 500 GRT for community-backstop-only networks.
+ */
+export function RecommendedSignal() {
+  return <>{useCurrentNetwork()?.issuanceRewards ? '1,000' : '500'}</>
+}
+
+/** Renders `rewards` on networks that earn indexing rewards (`issuanceRewards: true`), `otherwise` elsewhere. */
+export function IndexingRewardsText({ rewards, otherwise }: { rewards: ReactNode; otherwise: ReactNode }) {
+  return <>{useCurrentNetwork()?.issuanceRewards ? rewards : otherwise}</>
+}
+
+/** Renders its children unless `hide` is set; lets MDX partials make a markdown block optional per page. */
+export function ShowUnless({ hide, children }: { hide?: boolean; children?: ReactNode }) {
+  return <>{hide ? null : children}</>
+}
diff --git a/website/src/supportedNetworks/NetworkDetailsPage.tsx b/website/src/supportedNetworks/NetworkDetailsPage.tsx
index 3d9477693e83..bc4835178f67 100644
--- a/website/src/supportedNetworks/NetworkDetailsPage.tsx
+++ b/website/src/supportedNetworks/NetworkDetailsPage.tsx
@@ -1,5 +1,3 @@
-import { Fragment } from 'react'
-
 import { ExperimentalCopyButton, ExperimentalDescriptionList, ExperimentalLink } from '@edgeandnode/gds'
 import { NetworkIcon } from '@edgeandnode/go'
 
@@ -7,25 +5,18 @@ import { Card, Heading, TimeIcon } from '@/components'
 import { useI18n } from '@/i18n'
 
 import { customNetworkContent } from './customContent'
+import { NetworkContext } from './NetworkContext'
 import { subgraphsAndSubstreamsCards, subgraphsOnlyCards, substreamsOnlyCards } from './ResourceCards'
-import { type SubstreamsTier, type SupportedNetwork } from './utils'
+import { type SubgraphsTier, type SubstreamsTier, type SupportedNetwork } from './utils'
 
-// Product-support rows shown at the top of each network page. Labels mirror the tiers used
-// in the Supported Networks table (see ./utils), rendered here as plain text instead of chips.
-// The Subgraphs row is built from the underlying flags rather than the single top tier, so a
-// network that earns rewards *and* relies on backstop indexing (e.g. Rootstock) shows both.
+// Product-support rows shown at the top of each network page. The Subgraphs row has two lines:
+// payments always run through Subgraph Studio (API keys and billing), and indexing mirrors the
+// network's top Subgraphs tier in the Supported Networks table (see `getSubgraphsTier` in ./utils).
 const SUBGRAPHS_STUDIO_URL = 'https://thegraph.com/studio/'
-const SUBGRAPHS_REWARDS_URL =
-  'https://thegraph.com/docs/en/subgraphs/developing/deploying-publishing/publishing-a-subgraph/'
-function getSubgraphsRow(network: SupportedNetwork): {
-  linkLabel: string
-  suffixes: { label: string; href?: string }[]
-} {
-  const suffixes: { label: string; href?: string }[] = []
-  if (network.subgraphsBackstop) suffixes.push({ label: 'Community Indexing' })
-  if (network.issuanceRewards) suffixes.push({ label: 'Network Rewards', href: SUBGRAPHS_REWARDS_URL })
-  // Networks without Studio deploys still use Studio for API keys and billing.
-  return { linkLabel: network.subgraphsStudio ? 'Subgraph Studio' : 'Subgraph Studio (API Keys)', suffixes }
+const SUBGRAPHS_INDEXING_LABEL: Record<Exclude<SubgraphsTier, 'none'>, string> = {
+  rewards: 'The Graph Network',
+  network: 'Community Support',
+  studio: 'Subgraph Studio',
 }
 const SUBSTREAMS_MODEL_LABEL: Record<Exclude<SubstreamsTier, 'none'>, string> = {
   other: 'Non-EVM',
@@ -33,20 +24,21 @@ const SUBSTREAMS_MODEL_LABEL: Record<Exclude<SubstreamsTier, 'none'>, string> =
   extended: 'Extended EVM',
 }
 // Substreams provider endpoints (from `services.substreams`) mapped to their public brand + link.
+// Listed in preference order; only the first match is shown. Data Nexus is intentionally omitted:
+// it is always available through The Graph Market.
 const SUBSTREAMS_PROVIDERS: { match: string; name: string; href: string }[] = [
   { match: 'streamingfast.io', name: 'The Graph Market', href: 'https://thegraph.market/' },
   { match: 'pinax.network', name: 'Pinax Network', href: 'https://pinax.network/' },
-  { match: 'data.nexus', name: 'Data Nexus', href: 'https://data.nexus/' },
 ]
 
 export default function NetworkDetailsPage({ network }: { network: SupportedNetwork }) {
   const { t } = useI18n()
   const CustomContent = customNetworkContent[network.id]
-  // Providers listed under `services.substreams` in the networks registry, kept in a stable
-  // brand-preferred order (The Graph Market, then Pinax Network, then Data Nexus).
+  // The preferred Substreams provider listed under `services.substreams` in the networks registry:
+  // The Graph Market when available, otherwise Pinax Network.
   const substreamsProviders = SUBSTREAMS_PROVIDERS.filter((provider) =>
     (network.services.substreams ?? []).some((url) => url.includes(provider.match)),
-  )
+  ).slice(0, 1)
   const cards = (() => {
     if (network.evm) {
       const hasSubgraphs = network.subgraphsSupportLevel !== 'none'
@@ -64,60 +56,50 @@ export default function NetworkDetailsPage({ network }: { network: SupportedNetw
     }
   })()
   // The both-products card set fills a full 3x3 grid; the other sets use a 3-on-top,
-  // 2-on-bottom layout.
+  // 2-on-bottom layout. Cards size to their content (no fixed min height).
   const guidesItemClassName =
     cards.length === 6
-      ? 'col-span-full lg:col-span-2 lg:min-h-64'
-      : 'col-span-full [&:nth-child(-n+3)]:lg:col-span-2 [&:nth-child(-n+3)]:lg:min-h-64 [&:nth-child(n+4)]:lg:col-span-3'
+      ? 'col-span-full lg:col-span-2'
+      : 'col-span-full [&:nth-child(-n+3)]:lg:col-span-2 [&:nth-child(n+4)]:lg:col-span-3'
 
   return (
     <div className="col-[container]">
       <div className="mb-5 mt-12 flex flex-col gap-3">
         <NetworkIcon network={network} variant={network.iconVariant} size={10} />
-        <h2 className="leading-tight mt-0 text-24 text-white">{network.fullName}</h2>
+        <h2 className="text-heading-medium mt-0 text-white xs:text-heading-large">{network.fullName}</h2>
       </div>
 
       <div className="grid grid-cols-2 gap-4">
         <div className="col-span-2">
           <div>
             <ExperimentalDescriptionList size="medium">
-              {network.subgraphsTier !== 'none' &&
-                (() => {
-                  const subgraphs = getSubgraphsRow(network)
-                  return (
-                    <ExperimentalDescriptionList.Item label="Subgraphs">
+              {network.subgraphsTier !== 'none' && (
+                <ExperimentalDescriptionList.Item label="Subgraphs">
+                  <span className="flex flex-col items-end text-right">
+                    <span>
                       <ExperimentalLink className="text-14" href={SUBGRAPHS_STUDIO_URL} target="_blank">
-                        {subgraphs.linkLabel}
+                        Payments: Subgraph Studio
                       </ExperimentalLink>
-                      {subgraphs.suffixes.map((suffix) => (
-                        <Fragment key={suffix.label}>
-                          {' • '}
-                          {suffix.href ? (
-                            <ExperimentalLink className="text-14" href={suffix.href} target="_blank">
-                              {suffix.label}
-                            </ExperimentalLink>
-                          ) : (
-                            suffix.label
-                          )}
-                        </Fragment>
-                      ))}
-                    </ExperimentalDescriptionList.Item>
-                  )
-                })()}
+                    </span>
+                    <span>Indexing: {SUBGRAPHS_INDEXING_LABEL[network.subgraphsTier]}</span>
+                  </span>
+                </ExperimentalDescriptionList.Item>
+              )}
               {network.substreamsTier !== 'none' && (
                 <ExperimentalDescriptionList.Item
                   label={`Substreams (${SUBSTREAMS_MODEL_LABEL[network.substreamsTier]})`}
                 >
-                  {substreamsProviders.length > 0
-                    ? substreamsProviders.map((provider, index) => (
-                        <Fragment key={provider.name}>
-                          {index > 0 && ' • '}
+                  {substreamsProviders.length > 0 ? (
+                    <span className="flex flex-col items-end text-right">
+                      {substreamsProviders.map((provider) => (
+                        <span key={provider.name}>
                           <ExperimentalLink className="text-14" href={provider.href} target="_blank">
-                            {provider.name}
+                            Full Service: {provider.name}
                           </ExperimentalLink>
-                        </Fragment>
-                      ))
-                    : null}
+                        </span>
+                      ))}
+                    </span>
+                  ) : null}
                 </ExperimentalDescriptionList.Item>
               )}
               <ExperimentalDescriptionList.Item label={t('index.supportedNetworks.type')}>
@@ -154,7 +136,7 @@ export default function NetworkDetailsPage({ network }: { network: SupportedNetw
               {network.docsUrl && (
                 <ExperimentalDescriptionList.Item label={t('index.supportedNetworks.docs')}>
                   <ExperimentalLink className="text-14" href={network.docsUrl} target="_blank">
-                    {network.docsUrl}
+                    {network.shortName} Docs
                   </ExperimentalLink>
                 </ExperimentalDescriptionList.Item>
               )}
@@ -166,12 +148,17 @@ export default function NetworkDetailsPage({ network }: { network: SupportedNetw
       <hr />
 
       {CustomContent && (
-        <div className="mb-16 mt-8">
-          <CustomContent />
-        </div>
+        <>
+          <div className="mb-16 mt-8">
+            <NetworkContext.Provider value={network}>
+              <CustomContent />
+            </NetworkContext.Provider>
+          </div>
+          <hr />
+        </>
       )}
 
-      <Heading.H3>{t('index.supportedNetworks.guides')}</Heading.H3>
+      <Heading.H2>{t('index.supportedNetworks.guides')}</Heading.H2>
       <div className="grid grid-cols-6 gap-4">
         {cards.map((card) => (
           <Card
diff --git a/website/src/supportedNetworks/NetworksTable.tsx b/website/src/supportedNetworks/NetworksTable.tsx
index bbe87f59962c..8c5fc7230054 100644
--- a/website/src/supportedNetworks/NetworksTable.tsx
+++ b/website/src/supportedNetworks/NetworksTable.tsx
@@ -21,7 +21,7 @@ import { useI18n } from '@/i18n'
 import { getNetworkSlug } from './slugs'
 import { type SubgraphsTier, type SubstreamsTier, type SupportedNetwork } from './utils'
 
-// Tier chip tones. GDS calls Galactic Aqua `turquoise` and Nebula Pink `pink`; `space` is its
+// Tier chip tones. GDS calls Galactic Aqua `turquoise`, Nebula Pink `pink`, and its yellow scale `solar`; `space` is its
 // lavender-gray scale. Brighter hues use lower opacity so every chip reads with similar weight,
 // on both the page and hovered row surfaces.
 const TIER_CHIP_STYLES = {
@@ -37,6 +37,8 @@ const TIER_CHIP_STYLES = {
     border-turquoise/10 bg-turquoise/[0.095] data-[treatment=borderless]:bg-turquoise/[0.12]`,
   green: `[--tier-chip-accent:theme(colors.starfield-400)]
     border-starfield-300/10 bg-starfield-400/[0.12] data-[treatment=borderless]:bg-starfield-400/[0.18]`,
+  yellow: `[--tier-chip-accent:theme(colors.solar-300)]
+    border-solar-300/10 bg-solar-300/[0.12] data-[treatment=borderless]:bg-solar-300/[0.18]`,
 }
 
 type TierChipProps = { label: string; tone: keyof typeof TIER_CHIP_STYLES }
@@ -49,7 +51,7 @@ const SUBGRAPHS_CHIPS: Record<Exclude<SubgraphsTier, 'none'>, TierChipProps> = {
 const SUBSTREAMS_CHIPS: Record<Exclude<SubstreamsTier, 'none'>, TierChipProps> = {
   base: { label: 'BASE', tone: 'turquoise' },
   extended: { label: 'EXTENDED', tone: 'green' },
-  other: { label: 'NON-EVM', tone: 'neutral' },
+  other: { label: 'NON-EVM', tone: 'yellow' },
 }
 
 // Switch to 'borderless' to compare the stronger fill across the table and legend during development.
diff --git a/website/src/supportedNetworks/customContent/README.md b/website/src/supportedNetworks/customContent/README.md
index eef6e9a086f7..d433f914506f 100644
--- a/website/src/supportedNetworks/customContent/README.md
+++ b/website/src/supportedNetworks/customContent/README.md
@@ -58,3 +58,42 @@ Props:
 The provider sentence on each network page ("… via [The Graph Market] and [Pinax Network]") should list only the providers in that network's `services.substreams` entries in the registry: `streamingfast.io` → The Graph Market, `pinax.network` → Pinax Network, `data.nexus` → Data Nexus.
 
 Non-EVM networks (Solana, Bitcoin, Injective, Stellar, etc.) use bespoke Substreams wording and keep their section inline rather than using these blocks.
+
+### Subgraphs section
+
+Two partials cover the standard "Indexing _{Chain}_ with Subgraphs" section for EVM networks:
+
+- `_subgraph-community.mdx` — networks indexed on The Graph Network (indexing rewards and/or community backstop indexing). Walks readers through the Subgraph Studio UI flow: create in Studio, deploy from the CLI, publish to The Graph Network from the Studio dashboard.
+- `_subgraph-studio.mdx` — networks Subgraph Studio indexes but with no guaranteed indexing on The Graph Network yet.
+
+```mdx
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+<SubgraphCommunity
+  chainName="BSC"
+  title="BNB Smart Chain"
+  networkId="bsc"
+  slug="bsc"
+  explorerUrl="https://bscscan.com"
+  explorerName="BscScan"
+  rpcUrl="https://bsc-dataseed.bnbchain.org"
+/>
+```
+
+Studio indexing support is read from the registry, not from props. `NetworkDetailsPage` provides the current network through `NetworkContext` (`../NetworkContext.tsx`), and when a network has no `kind: 'studio'` entry in `services.subgraphs`, `_subgraph-community.mdx` shows a warning to publish to The Graph Network for indexing, followed by the `description` of each `kind: 'backstop'` entry (e.g. "InfraDAO provides indexing support for all published Subgraphs with 500+ GRT in signal on Anubis Mainnet."). The curation signal recommended in the publish step is also registry-driven (`RecommendedSignal`): 1,000 GRT on networks with `issuanceRewards: true`, 500 GRT on community-only networks. Update the registry, not the page, to change any of these.
+
+### "Get API Key" buttons
+
+Every "Indexing _{Chain}_ with Subgraphs" and "Indexing _{Chain}_ with Substreams" section heading is a `ProductSectionHeading` (`../GetApiKeyButton.tsx`): a standard `h2` with a primary GDS "Get API Key" button beside it (the button wraps below the heading on narrow screens). Pass the heading text as `title`, not as children, so MDX doesn't wrap it in a paragraph inside the `h2`:
+
+```mdx
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+<ProductSectionHeading
+  product="substreams"
+  id="indexing-bitcoin-with-substreams"
+  title="Indexing Bitcoin with Substreams"
+/>
+```
+
+`product="subgraphs"` links to the Subgraph Studio API Keys page. `product="substreams"` links to The Graph Market, falling back to Pinax Network only when the registry lists no The Graph Market endpoint for the network. The shared partials already include it; add it by hand to bespoke (non-EVM) Substreams sections.
diff --git a/website/src/supportedNetworks/customContent/_subgraph-community.mdx b/website/src/supportedNetworks/customContent/_subgraph-community.mdx
index cac6638e03b1..29974c84ec03 100644
--- a/website/src/supportedNetworks/customContent/_subgraph-community.mdx
+++ b/website/src/supportedNetworks/customContent/_subgraph-community.mdx
@@ -1,63 +1,81 @@
 {/* Reusable "community" Subgraph section.
 
-The community model: publish Subgraphs directly to The Graph Network and add curation signal so select Indexers on the network pick them up (a curation backstop). Renders "### Indexing {Chain} with Subgraphs" + the Quick Start (Steps 1-4). Each network page keeps its own intro and any chain-specific "Find Existing Subgraphs" card grid inline.
+For networks that are indexed on The Graph Network (indexing rewards and/or a community indexing backstop). The default path is the Subgraph Studio UI: create the Subgraph in Studio, deploy to it from the CLI, then publish to The Graph Network from the Studio dashboard. Renders "### Indexing {Chain} with Subgraphs" + the Quick Start (Steps 1-5). Each network page keeps its own intro and any chain-specific "Find Existing Subgraphs" card grid inline.
 
-Props: - chainName (required) short name in body copy, e.g. "BSC", "Polygon" - title (optional) heading name; defaults to chainName (e.g. "BNB Smart Chain") - networkId (required) `graph init` / manifest network id, e.g. "bsc", "matic" - slug (required) example Subgraph slug base, e.g. "bsc", "polygon" - explorerUrl (required) block explorer URL, e.g. "https://bscscan.com" - explorerName (required) explorer brand for the ABI hint, e.g. "BscScan", "Blockscout" - rpcUrl (required) RPC endpoint used for local verification - customNetwork (optional) network not in `graph init`'s list; enter it manually - noStudio (optional) no Subgraph Studio staging; publish direct / verify locally */}
+Studio indexing support and the recommended curation signal (1,000 GRT on networks with indexing rewards, 500 GRT on community-only networks) are read from the networks registry (via NetworkContext), not from props. When a network has no `kind: 'studio'` entry in `services.subgraphs`, a warning renders telling readers to publish to The Graph Network for indexing, followed by the `description` of the network's `kind: 'backstop'` entry (community indexing directions), and the Studio-playground copy switches to local verification.
 
-import { Callout, CodeBlock } from '@/components'
+Props: - chainName (required) short name in body copy, e.g. "BSC", "Polygon" - title (optional) heading name; defaults to chainName (e.g. "BNB Smart Chain") - networkId (required) `graph init` / manifest network id, e.g. "bsc", "matic" - slug (required) example Subgraph slug base, e.g. "bsc", "polygon" - explorerUrl (required) block explorer URL, e.g. "https://bscscan.com" - explorerName (required) explorer brand for the ABI hint, e.g. "BscScan", "Blockscout" - rpcUrl (required) RPC endpoint used for local verification with Graph Node Dev Mode (gnd) - customNetwork (optional) network not in `graph init`'s list; enter it manually - hideExplorerSearch (optional) omit the "Search Graph Explorer for Existing Subgraphs" section, for pages with their own "Find Existing Subgraphs" section */}
+
+import { CodeBlock } from '@/components'
+import {
+  IndexingRewardsText,
+  RecommendedSignal,
+  ShowUnless,
+  StudioIndexing,
+  SubgraphStudioIndexingNotice,
+} from '@/supportedNetworks/NetworkContext'
 import { ExperimentalCodeInline as Code } from '@edgeandnode/gds'
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
 
-### Indexing {props?.title ?? props?.chainName} with Subgraphs [#indexing-with-subgraphs]
+---
 
-Getting smart contract data is hard. You write your own indexer, run your own database, and handle chain reorganizations yourself. The Graph removes that work, giving you an open API, called a [Subgraph](/subgraphs/overview/), that you query with GraphQL.
+<ProductSectionHeading product="subgraphs" id="indexing-with-subgraphs" title={`Indexing ${props?.title ?? props?.chainName} with Subgraphs`} />
 
-{props.chainName} is EVM-compatible, so the Subgraph workflow is the same as on most EVM chains. You point a Subgraph at your {props.chainName} contract, define the entities you want, and Indexers on The Graph Network keep those entities current and queryable.
+Getting smart contract data is hard. You write your own indexer, run your own database, and handle chain reorganizations yourself. [Subgraphs](/subgraphs/overview/) remove that work, giving you an open API that you query with GraphQL.
 
-#### Quick Start: Build Your Own Subgraph
+{props.chainName} is EVM-compatible, so the Subgraph workflow is the same as on most EVM chains. You point a Subgraph at your {props.chainName} contract, define the entities you want, deploy and publish it through [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/), and Indexers on The Graph Network keep those entities current and queryable.
 
-Building a Subgraph for {props.chainName} takes three steps:
+<SubgraphStudioIndexingNotice chainName={props.chainName} />
 
-1. Initialize a Subgraph project from your {props.chainName} contract.
-2. Publish it to The Graph Network for decentralized indexing.
-3. Query it over GraphQL with an API key.
+<ShowUnless hide={props.hideExplorerSearch}>
 
-See the [Subgraph pricing page](https://thegraph.com/studio-pricing/) for current query rates and free-tier limits.
+### Search Graph Explorer for Existing Subgraphs
 
-{props.noStudio && (
+Before you build, check whether the data you need is already live. [Graph Explorer](https://thegraph.com/explorer/) lists every Subgraph published to The Graph Network:
 
-  <Callout data-callout-type="note">
-    {props.chainName} is supported on The Graph Network, but does not currently have Subgraph Studio testing/staging support. Skip the standard <Code>graph deploy</Code> and Studio playground path. Instead, you can validate your Subgraph locally (see below) or publish directly to The Graph Network, where a decentralized Indexer that supports {props.chainName} indexes it.
-  </Callout>
-)}
+- **Filter by network:** on the Subgraphs page, filter by {props.chainName} to see the Subgraphs indexing it, then sort by most queried, most curated, or recently updated.
+- **Search by contract:** enter a contract address in the search bar to find the Subgraphs that index it.
+- **Try it first:** open any Subgraph to test queries in its playground and copy its query URL.
 
-##### Step 1: Initialize your Subgraph project
+If an existing Subgraph covers your use case, skip to [querying it with your API key](#step-5-query-your-subgraph). For a full tour, see [Using Graph Explorer](/subgraphs/existing-subgraphs/explorer/).
 
-Install the Graph CLI with the package manager you prefer:
+</ShowUnless>
 
-```sh
-# npm
-npm install -g @graphprotocol/graph-cli@latest
+### Quick Start: Build Your Own Subgraph
 
-# or yarn
-yarn global add @graphprotocol/graph-cli
-```
+Building a Subgraph for {props.chainName} takes five steps:
 
-Verify the install:
+1. Create your Subgraph in Subgraph Studio.
+2. Build a Subgraph project from your smart contract.
+3. Deploy it to Subgraph Studio.
+4. Publish it to The Graph Network from Subgraph Studio.
+5. Query Subgraph with your API key.
 
-```sh
-graph --version
-```
+See the [Subgraph pricing page](https://thegraph.com/studio-pricing/) for current query rates and free-tier limits.
 
-Initialize from your {props.chainName} contract:
+#### Step 1: Create your Subgraph in Subgraph Studio
 
-```sh
-graph init
-```
+Open [Subgraph Studio](https://thegraph.com/studio/) and connect your wallet. Create a Subgraph, copy its **slug** and your **deploy key** from the Subgraph details page to use in the CLI. For a full walkthrough, see [Using Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/).
+
+#### Step 2: Initialize and build your Subgraph project
+
+Install the Graph CLI, verify the install, and initialize a project from your {props.chainName} contract:
+
+<CodeBlock>
+  <code className="language-sh">{`# Install the Graph CLI (or with yarn: yarn global add @graphprotocol/graph-cli)
+npm install -g @graphprotocol/graph-cli@latest
+
+# Verify the install
+graph --version
+
+# Initialize from your ${props.chainName} contract
+graph init`}</code>
+</CodeBlock>
 
 The CLI walks you through a set of prompts{props.customNetwork ? `. ${props.chainName} is a custom EVM network, so provide the network details manually when asked` : ''}:
 
 - **Protocol**: choose `ethereum`. {props.chainName} is EVM-compatible.
-- **Subgraph slug**: an identifier for your Subgraph, for example <Code>{`my-${props.slug}-subgraph`}</Code>.
+- **Subgraph slug**: use the slug of the Subgraph you created in Subgraph Studio, for example <Code>{`my-${props.slug}-subgraph`}</Code>.
 - **Directory**: where the project is scaffolded.
 - **Ethereum network**: {props.customNetwork ? <>enter <Code>{props.networkId}</Code> as the network identifier.</> : <>select <Code>{props.networkId}</Code> from the list of supported networks.</>}
 - **Contract address**: the address of the contract you want to index. Find it on <a href={props.explorerUrl} target="_blank" rel="noreferrer">{props.explorerUrl.replace(/^https?:\/\//, '')}</a>.
@@ -66,26 +84,7 @@ The CLI walks you through a set of prompts{props.customNetwork ? `. ${props.chai
 - **Contract name**: the name of your contract.
 - **Index contract events as entities**: set this to `true`. The CLI then scaffolds entities and mappings for every emitted event.
 
-<Callout data-callout-type="note">
-  {props.customNetwork ? (
-    <>
-      The <Code>network</Code> value you enter (<Code>{props.networkId}</Code>) must match the network identifier that
-      The Graph has registered for {props.chainName}. If <Code>graph init</Code> does not recognize the network,
-      scaffold with any EVM network and set the <Code>network</Code> field manually in <Code>subgraph.yaml</Code> (next
-      step).
-    </>
-  ) : (
-    <>
-      The <Code>network</Code> value for {props.chainName} is <Code>{props.networkId}</Code>. <Code>graph init</Code>{' '}
-      recognizes it directly, so you can select it from the list of supported networks. You can also set the{' '}
-      <Code>network</Code> field manually in <Code>subgraph.yaml</Code> (next step).
-    </>
-  )}
-</Callout>
-
-##### Step 2: Write and build your Subgraph
-
-You work with three files:
+To customize your Subgraph, you work with three files:
 
 - **Manifest:** `subgraph.yaml` defines which data sources your Subgraph indexes.
 - **Schema:** `schema.graphql` defines the entities you want to query.
@@ -107,56 +106,71 @@ Point the manifest at {props.chainName}:
       startBlock: 123456 # your contract's deployment block`}</code>
 </CodeBlock>
 
-For a full walkthrough of schema and mapping authoring, see [Creating a Subgraph](/subgraphs/developing/creating/starting-your-subgraph/).
-
-Generate types and build:
+For a full walkthrough of schema and mapping authoring, see [Creating a Subgraph](/subgraphs/developing/creating/starting-your-subgraph/). Then generate types and build:
 
 ```sh
 graph codegen && graph build
 ```
 
-**Optional: verify locally before publishing.** {props.noStudio ? `The Studio playground cannot index ${props.chainName}, so test` : 'You can test'} indexing with a local [Graph Node](https://github.com/graphprotocol/graph-node) pointed at an RPC endpoint for {props.chainName}. In your `docker-compose.yml`, set the Ethereum environment to {props.customNetwork ? `your ${props.chainName} network` : props.chainName}:
+#### Step 3: Deploy to Subgraph Studio
 
-<CodeBlock>
-  <code className="language-yaml">{`environment:
-  ethereum: '${props.networkId}:${props.rpcUrl}'`}</code>
-</CodeBlock>
+Authenticate the CLI and deploy your Subgraph to Subgraph Studio:
 
-Create and deploy to your local node:
+```sh
+# Authenticate with the deploy key from your Subgraph details page
+graph auth <DEPLOY_KEY>
 
-<CodeBlock>
-  <code className="language-sh">{`graph create --node http://localhost:8020/ my-${props.slug}-subgraph
-graph deploy --node http://localhost:8020/ --ipfs http://localhost:5001 my-${props.slug}-subgraph`}</code>
-</CodeBlock>
+# Deploy to Subgraph Studio (the CLI asks for a version label such as 0.0.1)
+graph deploy <SUBGRAPH_SLUG>
+```
+
+<StudioIndexing
+  fallback={
+    <p>
+      Deploying uploads your Subgraph to Subgraph Studio so you can publish it from the dashboard. Subgraph Studio does
+      not index {props.chainName}, so the deployment does not sync in the Studio playground. To check your Subgraph
+      before publishing, verify it locally with Graph Node Dev Mode (below).
+    </p>
+  }
+>
 
-Query the local endpoint until your entities look right, then publish.
+Deploying pushes your Subgraph to Subgraph Studio, where you can test it in the playground, query the development endpoint, and check indexing logs. It does not publish it to the decentralized network yet.
 
-##### Step 3: Publish & Curate on The Graph Network
+</StudioIndexing>
 
-{props.noStudio ? `This is the recommended path for ${props.chainName}.` : ''}
+#### Optional: Verify locally with Graph Node Dev Mode
 
-Publishing is an on-chain action that:
+Run your Subgraph on your machine with [Graph Node Dev Mode (GND)](/subgraphs/developing/creating/graph-node-dev/), pointed at an RPC endpoint for {props.chainName}. From your Subgraph project directory:
 
-- makes your Subgraph available for decentralized [Indexers](/indexing/overview/){props.noStudio ? ` that support ${props.chainName}` : ''} to index,
-- makes it publicly searchable and queryable in [Graph Explorer](https://thegraph.com/explorer/),
-- and makes it available for [Curators](/resources/roles/curating/) to add signal.
+<CodeBlock>
+  <code className="language-sh">{`# Install gnd with the Graph CLI
+graph node install
 
-Build, then publish from the Graph CLI:
+# Build, deploy, and index your Subgraph locally, redeploying on changes
+gnd --ethereum-rpc ${props.networkId}:${props.rpcUrl} --watch`}</code>
+</CodeBlock>
 
-```sh
-graph codegen && graph build
-graph publish
-```
+Query your Subgraph at `http://localhost:8000/subgraphs/name/subgraph-0/` until your entities look right, then publish. On Windows, `gnd` also needs a `--postgres-url`. See [Graph Node Dev Mode](/subgraphs/developing/creating/graph-node-dev/) for setup.
+
+#### Step 4: Publish & Curate on The Graph Network
+
+<StudioIndexing fallback={<p>Publishing is how your Subgraph gets indexed on {props.chainName}.</p>} />
+
+Publishing a Subgraph is an on-chain action that:
+
+- makes it available for [Curators](/resources/roles/curating/) to add signal that attracts Indexers,
+- makes your Subgraph available for decentralized [Indexers](/indexing/overview/) to index,
+- and makes it publicly searchable and queryable in [Graph Explorer](https://thegraph.com/explorer/).
 
-A browser window opens. Connect your wallet, add metadata (name, description, image), and publish your Subgraph. The `--protocol-network` flag refers to where The Graph's protocol contracts live (Arbitrum One), not to {props.chainName}.
+To publish, open your Subgraph in the [Subgraph Studio](https://thegraph.com/studio/) dashboard and click **Publish**. Connect your wallet, add metadata (name, description, image), and confirm the transaction. Publishing happens on Arbitrum One, where The Graph's protocol contracts live, not on {props.chainName}. For details, see [Publishing a Subgraph](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/), which also covers publishing from the CLI with `graph publish`.
 
-> [!TIP] During the publish transaction, you can add 500 GRT in curation signal to save on gas fees. Signal tells Indexers that your Subgraph is worth indexing. Any Subgraph with 500 GRT or more signal will automatically be indexed; without signal, no Indexer is incentivized to pick up your Subgraph.
+> [!TIP] During the publish transaction, you can add GRT in curation signal to save on gas fees. Signal tells Indexers that your Subgraph is worth indexing. Any Subgraph with <RecommendedSignal /> GRT or more signal <IndexingRewardsText rewards="will be likely to be indexed quickly" otherwise="will automatically be indexed" />; without signal, no Indexer is incentivized to pick up your Subgraph.
 
-##### Step 4: Query your Subgraph
+#### Step 5: Query your Subgraph
 
 After you publish, open your Subgraph in [Graph Explorer](https://thegraph.com/explorer/) and copy its query URL from the **Query** button.
 
-1. Create an API key from the API Keys dashboard at [thegraph.com/studio](https://thegraph.com/studio/). This dashboard handles {props.noStudio ? 'keys and billing for The Graph Network on Arbitrum, independent of which chains Studio can index' : 'API keys and billing for The Graph Network'}.
+1. Create an API key from the API Keys dashboard at [thegraph.com/studio](https://thegraph.com/studio/). This dashboard handles API keys and billing for The Graph Network.
 2. Send GraphQL queries to the query URL with your API key.
 
 See the [Subgraph pricing page](https://thegraph.com/studio-pricing/) for query rates, and [Querying The Graph](/subgraphs/querying/introduction/) for the full query API.
diff --git a/website/src/supportedNetworks/customContent/_subgraph-studio.mdx b/website/src/supportedNetworks/customContent/_subgraph-studio.mdx
index f42af2b70844..1153d2a2a1f1 100644
--- a/website/src/supportedNetworks/customContent/_subgraph-studio.mdx
+++ b/website/src/supportedNetworks/customContent/_subgraph-studio.mdx
@@ -6,10 +6,13 @@ Props: - chainName (required) short name in body copy, e.g. "Sei", "Chiliz" - ti
 
 import { Callout, CodeBlock } from '@/components'
 import { ExperimentalCodeInline as Code } from '@edgeandnode/gds'
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
 
-### Indexing {props?.title ?? props?.chainName} with Subgraphs [#indexing-with-subgraphs]
+---
 
-Getting smart contract data is hard. You write your own indexer, run your own database, and handle chain reorganizations yourself. The Graph removes that work, giving you an open API, called a [Subgraph](/subgraphs/overview/), that you query with GraphQL.
+<ProductSectionHeading product="subgraphs" id="indexing-with-subgraphs" title={`Indexing ${props?.title ?? props?.chainName} with Subgraphs`} />
+
+Getting smart contract data is hard. You write your own indexer, run your own database, and handle chain reorganizations yourself. [Subgraphs](/subgraphs/overview/) remove that work, giving you an open API that you query with GraphQL.
 
 {props.chainName} is EVM-compatible, so the Subgraph workflow is the same as on most EVM chains. You develop and test your Subgraph in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/), then query it through the development endpoint.
 
@@ -20,38 +23,35 @@ Getting smart contract data is hard. You write your own indexer, run your own da
   are not guaranteed to index and serve it yet.
 </Callout>
 
-#### Quick Start: Build Your Own Subgraph
+### Quick Start: Build Your Own Subgraph
 
 Building a Subgraph for {props.chainName} takes four steps:
 
 1. Create your Subgraph in Subgraph Studio.
-2. Initialize a Subgraph project from your {props.chainName} contract.
+2. Build a Subgraph project from your smart contract.
 3. Deploy it to Subgraph Studio and test it in the playground.
 4. Query it over GraphQL with the development endpoint.
 
 See the [Subgraph pricing page](https://thegraph.com/studio-pricing/) for current query rates and free-tier limits.
 
-##### Step 1: Create your Subgraph in Subgraph Studio
+#### Step 1: Create your Subgraph in Subgraph Studio
 
-Open [Subgraph Studio](https://thegraph.com/studio/) and connect your wallet (MetaMask, Coinbase Wallet, WalletConnect, or Safe). Create a Subgraph, then copy its **slug** and your **deploy key** from the Subgraph details page — you use both from the CLI. For a full walkthrough, see [Using Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/).
+Open [Subgraph Studio](https://thegraph.com/studio/) and connect your wallet. Create a Subgraph, copy its **slug** and your **deploy key** from the Subgraph details page to use in the CLI. For a full walkthrough, see [Using Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/).
 
-##### Step 2: Initialize your Subgraph project
+#### Step 2: Initialize your Subgraph project
 
-Install the Graph CLI with the package manager you prefer:
+Install the Graph CLI, verify the install, and initialize a project from your {props.chainName} contract:
 
-```sh
-# npm
+<CodeBlock>
+  <code className="language-sh">{`# Install the Graph CLI (or with yarn: yarn global add @graphprotocol/graph-cli)
 npm install -g @graphprotocol/graph-cli@latest
 
-# or yarn
-yarn global add @graphprotocol/graph-cli
-```
-
-Initialize from your {props.chainName} contract:
+# Verify the install
+graph --version
 
-```sh
-graph init
-```
+# Initialize from your ${props.chainName} contract
+graph init`}</code>
+</CodeBlock>
 
 The CLI walks you through a set of prompts:
 
@@ -87,23 +87,21 @@ For a full walkthrough of schema and mapping authoring, see [Creating a Subgraph
 graph codegen && graph build
 ```
 
-##### Step 3: Deploy to Subgraph Studio
+#### Step 3: Deploy to Subgraph Studio
 
-Authenticate the CLI with the deploy key from your Subgraph details page:
+Authenticate the CLI and deploy your Subgraph to Subgraph Studio:
 
 ```sh
+# Authenticate with the deploy key from your Subgraph details page
 graph auth <DEPLOY_KEY>
-```
 
-Then deploy your Subgraph to Subgraph Studio (the CLI asks for a version label such as `0.0.1`):
-
-```sh
+# Deploy to Subgraph Studio (the CLI asks for a version label such as 0.0.1)
 graph deploy <SUBGRAPH_SLUG>
 ```
 
 Deploying pushes your Subgraph to Subgraph Studio, where you can test it in the playground and check indexing logs. It does not publish it to the decentralized network — see [Using Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/) for details.
 
-##### Step 4: Query your Subgraph
+#### Step 4: Query your Subgraph
 
 Once your Subgraph is syncing in Studio, test your queries against the **development query URL** shown on the Subgraph details page.
 
diff --git a/website/src/supportedNetworks/customContent/_substreams-base.mdx b/website/src/supportedNetworks/customContent/_substreams-base.mdx
index 93dfe6224e24..a748e92f39fc 100644
--- a/website/src/supportedNetworks/customContent/_substreams-base.mdx
+++ b/website/src/supportedNetworks/customContent/_substreams-base.mdx
@@ -2,19 +2,23 @@
 
 Props: - chainName (required): short name used in the body copy, e.g. "Blast", "MegaETH". - title (optional): heading display name; defaults to chainName. - keyProvider (optional): set to "pinax" when the network has no The Graph Market endpoint, so step 1 points to Pinax Network for the API key. */}
 
-### Indexing {props?.title ?? props?.chainName} with Substreams [#indexing-with-substreams]
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+---
+
+<ProductSectionHeading product="substreams" id="indexing-with-substreams" title={`Indexing ${props?.title ?? props?.chainName} with Substreams`} />
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). {props?.chainName} is served with the base EVM block model, so Substreams modules have access to block, transaction, and event (log) data. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on {props?.chainName}; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
-1. Install the Substreams CLI and {props?.keyProvider === 'pinax' ? <>get an API key from [Pinax Network](https://app.pinax.network/)</> : <>get a key at [thegraph.market](https://thegraph.market/) (no personal information required)</>}.
+1. Install the Substreams CLI and {props?.keyProvider === 'pinax' ? <>get an API key from <a href="https://app.pinax.network/" target="_blank" rel="noreferrer">Pinax Network</a></> : <>get a key at <a href="https://thegraph.market/" target="_blank" rel="noreferrer">The Graph Market</a></>}.
 2. Scaffold a project with `substreams init` and choose the EVM path, pointing it at your {props?.chainName} contract.
 3. Write your extraction and transformation logic in Rust, then run `substreams build`.
 4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/_substreams-extended.mdx b/website/src/supportedNetworks/customContent/_substreams-extended.mdx
index 2bbdfad14bc9..2830528495f6 100644
--- a/website/src/supportedNetworks/customContent/_substreams-extended.mdx
+++ b/website/src/supportedNetworks/customContent/_substreams-extended.mdx
@@ -2,19 +2,23 @@
 
 Props: - chainName (required): short name used in the body copy, e.g. "BSC", "Polygon". - title (optional): heading display name; defaults to chainName (e.g. "BNB Smart Chain" when chainName is "BSC"). - keyProvider (optional): set to "pinax" when the network has no The Graph Market endpoint, so step 1 points to Pinax Network for the API key. */}
 
-### Indexing {props?.title ?? props?.chainName} with Substreams [#indexing-with-substreams]
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+---
+
+<ProductSectionHeading product="substreams" id="indexing-with-substreams" title={`Indexing ${props?.title ?? props?.chainName} with Substreams`} />
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). {props?.chainName} is served with the extended EVM block model, so Substreams modules have access to full transaction, call, and event data. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules — DEX trades, token transfers, contract events, and more — that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on {props?.chainName}; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
-1. Install the Substreams CLI and {props?.keyProvider === 'pinax' ? <>get an API key from [Pinax Network](https://app.pinax.network/)</> : <>get a key at [thegraph.market](https://thegraph.market/) (no personal information required)</>}.
+1. Install the Substreams CLI and {props?.keyProvider === 'pinax' ? <>get an API key from <a href="https://app.pinax.network/" target="_blank" rel="noreferrer">Pinax Network</a></> : <>get a key at <a href="https://thegraph.market/" target="_blank" rel="noreferrer">The Graph Market</a></>}.
 2. Scaffold a project with `substreams init` and choose the EVM path, pointing it at your {props?.chainName} contract.
 3. Write your extraction and transformation logic in Rust, then run `substreams build`.
 4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/anubis.mdx b/website/src/supportedNetworks/customContent/anubis.mdx
index 093cc29deded..165a9587b3c3 100644
--- a/website/src/supportedNetworks/customContent/anubis.mdx
+++ b/website/src/supportedNetworks/customContent/anubis.mdx
@@ -1,6 +1,6 @@
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Getting Started on Anubis
+## Getting Started on Anubis
 
 Anubis Chain is a privacy-focused, EVM-compatible Layer 1 that pairs base-layer privacy (PLONK ZK proofs and selective disclosure) with publicly verifiable onchain data, live on mainnet since April 2026 and already running 1M+ transactions a day across a growing DeFi ecosystem (RocketSwap, AWAKE). A subgraph could index that onchain activity — DEX swaps, pools, and liquidity; lending and RWA positions; token transfers and holder balances; and contract events — and serve it via GraphQL. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
@@ -14,5 +14,4 @@ Importantly, Anubis is a selective-privacy chain. A Subgraph can only index data
   explorerName="Blockscout"
   rpcUrl="https://rpc.anubispace.org"
   customNetwork
-  noStudio
 />
diff --git a/website/src/supportedNetworks/customContent/arbitrum-one.mdx b/website/src/supportedNetworks/customContent/arbitrum-one.mdx
index e7c16758c8e6..7d2b887ad174 100644
--- a/website/src/supportedNetworks/customContent/arbitrum-one.mdx
+++ b/website/src/supportedNetworks/customContent/arbitrum-one.mdx
@@ -1,14 +1,14 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on Arbitrum One
+## Indexing Data on Arbitrum One
 
 Arbitrum One is an Ethereum Layer 2 built by Offchain Labs using optimistic-rollup technology, and one of the largest L2s by total value locked, with a deep DeFi, perps, and gaming ecosystem. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
 Arbitrum One is supported by The Graph in two ways:
 
-- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/) and [Pinax Network](https://app.pinax.network/docs?from=nav).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/) while Indexers on The Graph Network sync and serve queries.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [The Graph Market](https://thegraph.market/).
 
 <SubgraphCommunity
   chainName="Arbitrum One"
diff --git a/website/src/supportedNetworks/customContent/arbitrum-sepolia.mdx b/website/src/supportedNetworks/customContent/arbitrum-sepolia.mdx
index 227f30303807..05135880e975 100644
--- a/website/src/supportedNetworks/customContent/arbitrum-sepolia.mdx
+++ b/website/src/supportedNetworks/customContent/arbitrum-sepolia.mdx
@@ -1,14 +1,14 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on Arbitrum Sepolia Testnet
+## Indexing Data on Arbitrum Sepolia Testnet
 
 Arbitrum Sepolia Testnet is the primary public test network for Arbitrum One, the Offchain Labs Ethereum Layer 2, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
 Arbitrum Sepolia Testnet is supported by The Graph in two ways:
 
-- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/) while Indexers on The Graph Network sync and serve queries.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [Pinax Network](https://app.pinax.network/docs?from=nav).
 
 <SubgraphCommunity
   chainName="Arbitrum Sepolia Testnet"
diff --git a/website/src/supportedNetworks/customContent/arc-testnet.mdx b/website/src/supportedNetworks/customContent/arc-testnet.mdx
index 16257a0d14b0..4ac39891d154 100644
--- a/website/src/supportedNetworks/customContent/arc-testnet.mdx
+++ b/website/src/supportedNetworks/customContent/arc-testnet.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Arc Testnet
+## Indexing Data on Arc Testnet
 
 Arc Testnet is the public test network for Arc, Circle's EVM-compatible Layer 1 for stablecoin finance, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/arc.mdx b/website/src/supportedNetworks/customContent/arc.mdx
index d5869613955e..f4fd690fb276 100644
--- a/website/src/supportedNetworks/customContent/arc.mdx
+++ b/website/src/supportedNetworks/customContent/arc.mdx
@@ -1,15 +1,15 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Arc
+## Indexing Data on Arc
 
 Arc is an EVM-compatible Layer 1 built by Circle for stablecoin finance, using USDC as its native gas token and designed for payments, FX, and institutional settlement. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
 Arc is supported by The Graph in two ways:
 
-- You can [develop and publish Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/) in Subgraph Studio — publishing is enabled, though guaranteed indexing via The Graph Network is not yet available.
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers develop, publish, and query their Subgraphs in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/), though guaranteed indexing via The Graph Network is not yet available for Arc.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [The Graph Market](https://thegraph.market/).
 
 <SubgraphStudio chainName="Arc" networkId="arc" slug="arc" explorerUrl="https://arcscan.app" explorerName="Arcscan" />
 
-<SubstreamsExtended chainName="Arc" keyProvider="pinax" />
+<SubstreamsExtended chainName="Arc" />
diff --git a/website/src/supportedNetworks/customContent/avalanche.mdx b/website/src/supportedNetworks/customContent/avalanche.mdx
index 14780b28a05c..f71d7117a966 100644
--- a/website/src/supportedNetworks/customContent/avalanche.mdx
+++ b/website/src/supportedNetworks/customContent/avalanche.mdx
@@ -1,14 +1,14 @@
 import SubstreamsBase from './_substreams-base.mdx'
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on Avalanche
+## Indexing Data on Avalanche
 
 Avalanche C-Chain is the EVM-compatible contract chain of the Avalanche network, a high-throughput Layer 1 with sub-second finality and a broad DeFi, gaming, and institutional ecosystem, with AVAX as its native token. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
 Avalanche is supported by The Graph in two ways:
 
-- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/) and [Pinax Network](https://app.pinax.network/docs?from=nav).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/) while Indexers on The Graph Network sync and serve queries.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [The Graph Market](https://thegraph.market/).
 
 <SubgraphCommunity
   chainName="Avalanche"
diff --git a/website/src/supportedNetworks/customContent/base-sepolia.mdx b/website/src/supportedNetworks/customContent/base-sepolia.mdx
index ba42c7d4e929..1bfb0aa77ff2 100644
--- a/website/src/supportedNetworks/customContent/base-sepolia.mdx
+++ b/website/src/supportedNetworks/customContent/base-sepolia.mdx
@@ -1,6 +1,6 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 
-### Indexing Data on Base Sepolia Testnet
+## Indexing Data on Base Sepolia Testnet
 
 Base Sepolia Testnet is the primary public test network for Base, Coinbase's OP Stack Ethereum Layer 2, where teams deploy and validate contracts before mainnet. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
 
diff --git a/website/src/supportedNetworks/customContent/base.mdx b/website/src/supportedNetworks/customContent/base.mdx
index 0b21301ca49d..f734fec76ce5 100644
--- a/website/src/supportedNetworks/customContent/base.mdx
+++ b/website/src/supportedNetworks/customContent/base.mdx
@@ -1,14 +1,14 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on Base
+## Indexing Data on Base
 
 Base is an Ethereum Layer 2 built on the OP Stack and part of the Optimism Superchain, incubated by Coinbase, with one of the fastest-growing DeFi, consumer, and onchain-social ecosystems in crypto. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
 Base is supported by The Graph in two ways:
 
-- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/) and [Pinax Network](https://app.pinax.network/docs?from=nav).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/) while Indexers on The Graph Network sync and serve queries.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [The Graph Market](https://thegraph.market/).
 
 <SubgraphCommunity
   chainName="Base"
diff --git a/website/src/supportedNetworks/customContent/blast-mainnet.mdx b/website/src/supportedNetworks/customContent/blast-mainnet.mdx
index 27d5f97836ed..3115883753b0 100644
--- a/website/src/supportedNetworks/customContent/blast-mainnet.mdx
+++ b/website/src/supportedNetworks/customContent/blast-mainnet.mdx
@@ -1,6 +1,6 @@
 import SubstreamsBase from './_substreams-base.mdx'
 
-### Indexing Data on Blast
+## Indexing Data on Blast
 
 Blast is an Ethereum Layer 2 built on the OP Stack that offers native yield on ETH and stablecoins for its DeFi and dApp ecosystem. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
 
diff --git a/website/src/supportedNetworks/customContent/boba-testnet.mdx b/website/src/supportedNetworks/customContent/boba-testnet.mdx
index 787fd161fd55..15d4a6527053 100644
--- a/website/src/supportedNetworks/customContent/boba-testnet.mdx
+++ b/website/src/supportedNetworks/customContent/boba-testnet.mdx
@@ -1,6 +1,6 @@
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on Boba Sepolia Testnet
+## Indexing Data on Boba Sepolia Testnet
 
 Boba Sepolia Testnet is the public test network for Boba Network, an Ethereum Layer 2 optimistic rollup, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/boba.mdx b/website/src/supportedNetworks/customContent/boba.mdx
index 3b7db709058d..c5c465f97dec 100644
--- a/website/src/supportedNetworks/customContent/boba.mdx
+++ b/website/src/supportedNetworks/customContent/boba.mdx
@@ -1,6 +1,6 @@
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on Boba
+## Indexing Data on Boba
 
 Boba Network is an Ethereum Layer 2 optimistic rollup that adds hybrid compute for calling external APIs from smart contracts, supporting DeFi and consumer applications. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/bsc.mdx b/website/src/supportedNetworks/customContent/bsc.mdx
index 1856f0427740..c95ed98b915e 100644
--- a/website/src/supportedNetworks/customContent/bsc.mdx
+++ b/website/src/supportedNetworks/customContent/bsc.mdx
@@ -2,8 +2,9 @@ import SubstreamsExtended from './_substreams-extended.mdx'
 import { Card } from '@/components'
 import SubgraphCommunity from './_subgraph-community.mdx'
 import { Subgraph } from '@edgeandnode/gds/icons'
+import { ExploreSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
 
-### Indexing Data on BNB Smart Chain
+## Indexing Data on BSC
 
 BNB Smart Chain (BSC) is a high-performance, EVM-compatible Layer 1 that has run in production since September 2020, with sub-second block times and transaction fees of a fraction of a cent. It hosts one of the largest DeFi ecosystems in crypto — tens of billions of dollars in total value locked across protocols like PancakeSwap (DEX), Venus (lending), and 1,500+ live dApps spanning trading, gaming, and payments.
 
@@ -11,10 +12,12 @@ The Graph can index that onchain activity, including DEX swaps, pools, and liqui
 
 BSC is supported by The Graph in two ways:
 
-- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/) and [Pinax Network](https://app.pinax.network/docs?from=nav).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/) while Indexers on The Graph Network sync and serve queries.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [The Graph Market](https://thegraph.market/).
 
-### Find Existing Subgraphs on BNB Smart Chain
+---
+
+<ExploreSectionHeading id="find-existing-subgraphs-on-bsc" title="Find Existing Subgraphs on BSC" />
 
 Before you build, check whether the data you need is already live. Many of the most-used protocols on BSC publish Subgraphs on The Graph that you can query today:
 
@@ -61,12 +64,12 @@ Browse [Graph Explorer](https://thegraph.com/explorer/) to search all published
 
 <SubgraphCommunity
   chainName="BSC"
-  title="BNB Smart Chain"
   networkId="bsc"
   slug="bsc"
   explorerUrl="https://bscscan.com"
   explorerName="BscScan"
   rpcUrl="https://bsc.rpc.service.pinax.network"
+  hideExplorerSearch
 />
 
-<SubstreamsExtended chainName="BSC" title="BNB Smart Chain" />
+<SubstreamsExtended chainName="BSC" />
diff --git a/website/src/supportedNetworks/customContent/btc.mdx b/website/src/supportedNetworks/customContent/btc.mdx
index 1beed5e3d7f9..0c5a69c5ac4e 100644
--- a/website/src/supportedNetworks/customContent/btc.mdx
+++ b/website/src/supportedNetworks/customContent/btc.mdx
@@ -1,22 +1,30 @@
-### Indexing Data on Bitcoin
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+## Indexing Data on Bitcoin
 
 Bitcoin is the original and largest proof-of-work blockchain, securing the BTC asset and a growing ecosystem of layers and protocols built on top of it. The Graph can stream that onchain activity — blocks and transactions, inputs and outputs, and address activity — as real-time data with Substreams.
 
 Bitcoin is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/) and [Pinax Network](https://app.pinax.network/docs?from=nav).
 
-### Indexing Bitcoin with Substreams
+---
+
+<ProductSectionHeading
+  product="substreams"
+  id="indexing-bitcoin-with-substreams"
+  title="Indexing Bitcoin with Substreams"
+/>
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Bitcoin's blocks, transactions, and their inputs and outputs. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Bitcoin; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
-1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+1. Install the Substreams CLI and get a key at [The Graph Market](https://thegraph.market/).
 2. `substreams init` does not have a template for Bitcoin yet, so set up the project by hand: write a [`substreams.yaml` manifest](https://docs.substreams.dev/reference-material/manifest-and-components/manifests) with `network: btc` and a Rust map module that takes `sf.bitcoin.type.v1.Block` as its input (the protobuf definitions are published on [Buf](https://buf.build/streamingfast/firehose-bitcoin)).
 3. Write your extraction and transformation logic in Rust, then run `substreams build`.
 4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/celo-sepolia.mdx b/website/src/supportedNetworks/customContent/celo-sepolia.mdx
index ebc2c46bd6fe..7ed564c23abd 100644
--- a/website/src/supportedNetworks/customContent/celo-sepolia.mdx
+++ b/website/src/supportedNetworks/customContent/celo-sepolia.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Celo Sepolia Testnet
+## Indexing Data on Celo Sepolia Testnet
 
 Celo Sepolia Testnet is the public test network for Celo, an Ethereum Layer 2 focused on mobile-first payments and stablecoins, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/celo.mdx b/website/src/supportedNetworks/customContent/celo.mdx
index 9a6544051ce4..05e3afd648f7 100644
--- a/website/src/supportedNetworks/customContent/celo.mdx
+++ b/website/src/supportedNetworks/customContent/celo.mdx
@@ -1,14 +1,14 @@
 import SubstreamsBase from './_substreams-base.mdx'
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on Celo
+## Indexing Data on Celo
 
 Celo is an Ethereum Layer 2 (formerly a standalone Layer 1) focused on mobile-first payments, stablecoins, and real-world assets, with low fees and CELO as its native token. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
 Celo is supported by The Graph in two ways:
 
-- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/) while Indexers on The Graph Network sync and serve queries.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [Pinax Network](https://app.pinax.network/docs?from=nav).
 
 <SubgraphCommunity
   chainName="Celo"
diff --git a/website/src/supportedNetworks/customContent/chapel.mdx b/website/src/supportedNetworks/customContent/chapel.mdx
index 1f88cd278b58..e59d6bd92c15 100644
--- a/website/src/supportedNetworks/customContent/chapel.mdx
+++ b/website/src/supportedNetworks/customContent/chapel.mdx
@@ -1,14 +1,14 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on BNB Smart Chain Chapel Testnet
+## Indexing Data on BNB Smart Chain Chapel Testnet
 
 BNB Smart Chain Chapel Testnet is the public test network for BNB Smart Chain, the EVM-compatible Layer 1, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
 BNB Smart Chain Chapel Testnet is supported by The Graph in two ways:
 
-- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/) while Indexers on The Graph Network sync and serve queries.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [Pinax Network](https://app.pinax.network/docs?from=nav).
 
 <SubgraphCommunity
   chainName="BNB Smart Chain Chapel Testnet"
diff --git a/website/src/supportedNetworks/customContent/chiliz-testnet.mdx b/website/src/supportedNetworks/customContent/chiliz-testnet.mdx
index 3ec4be4326f2..d0269624f0d3 100644
--- a/website/src/supportedNetworks/customContent/chiliz-testnet.mdx
+++ b/website/src/supportedNetworks/customContent/chiliz-testnet.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Chiliz Spicy Testnet
+## Indexing Data on Chiliz Spicy Testnet
 
 Chiliz Spicy Testnet is the public test network for Chiliz, the sports and entertainment EVM Layer 1, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/chiliz.mdx b/website/src/supportedNetworks/customContent/chiliz.mdx
index a56ec506d6ad..77106137a184 100644
--- a/website/src/supportedNetworks/customContent/chiliz.mdx
+++ b/website/src/supportedNetworks/customContent/chiliz.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Chiliz
+## Indexing Data on Chiliz
 
 Chiliz is an EVM-compatible Layer 1 built for sports and entertainment, powering fan tokens and fan-engagement apps, with CHZ as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/eos.mdx b/website/src/supportedNetworks/customContent/eos.mdx
index a1aa661eb4d5..e72090ed4462 100644
--- a/website/src/supportedNetworks/customContent/eos.mdx
+++ b/website/src/supportedNetworks/customContent/eos.mdx
@@ -1,18 +1,26 @@
-### Indexing Data on Vaulta
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+## Indexing Data on Vaulta
 
 Vaulta (formerly EOS) is a high-performance Antelope-based Layer 1, repositioned around Web3 banking and financial applications. The Graph can stream that onchain activity — transactions and actions, token transfers and balances, and smart-contract activity — as real-time data with Substreams.
 
 Vaulta is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
 
-### Indexing Vaulta with Substreams
+---
+
+<ProductSectionHeading
+  product="substreams"
+  id="indexing-vaulta-with-substreams"
+  title="Indexing Vaulta with Substreams"
+/>
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Vaulta's blocks, transactions, and actions. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Vaulta; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
diff --git a/website/src/supportedNetworks/customContent/etherlink-mainnet.mdx b/website/src/supportedNetworks/customContent/etherlink-mainnet.mdx
index fa940e7f3e08..4e90381ce783 100644
--- a/website/src/supportedNetworks/customContent/etherlink-mainnet.mdx
+++ b/website/src/supportedNetworks/customContent/etherlink-mainnet.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Etherlink
+## Indexing Data on Etherlink
 
 Etherlink is an EVM-compatible Layer 2 built on Tezos Smart Rollups, offering low fees and fast confirmations with XTZ for gas. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/etherlink-shadownet.mdx b/website/src/supportedNetworks/customContent/etherlink-shadownet.mdx
index 25c138820cde..cfbbe0a99d5c 100644
--- a/website/src/supportedNetworks/customContent/etherlink-shadownet.mdx
+++ b/website/src/supportedNetworks/customContent/etherlink-shadownet.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Etherlink Shadownet Testnet
+## Indexing Data on Etherlink Shadownet Testnet
 
 Etherlink Shadownet is a public test network for Etherlink, the EVM Layer 2 built on Tezos Smart Rollups, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/fraxtal.mdx b/website/src/supportedNetworks/customContent/fraxtal.mdx
index cc306b4052e0..0744013b0ea1 100644
--- a/website/src/supportedNetworks/customContent/fraxtal.mdx
+++ b/website/src/supportedNetworks/customContent/fraxtal.mdx
@@ -1,6 +1,6 @@
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on Fraxtal
+## Indexing Data on Fraxtal
 
 Fraxtal is an Ethereum Layer 2 built on the OP Stack by Frax Finance, designed around the Frax stablecoin and staking ecosystem. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/fuji.mdx b/website/src/supportedNetworks/customContent/fuji.mdx
index 746ef53c688b..b9c858278f79 100644
--- a/website/src/supportedNetworks/customContent/fuji.mdx
+++ b/website/src/supportedNetworks/customContent/fuji.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Avalanche Fuji Testnet
+## Indexing Data on Avalanche Fuji Testnet
 
 Avalanche Fuji Testnet is the primary public test network for the Avalanche C-Chain, the EVM contract chain of the Avalanche network, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/fuse-testnet.mdx b/website/src/supportedNetworks/customContent/fuse-testnet.mdx
deleted file mode 100644
index 82c4570e3864..000000000000
--- a/website/src/supportedNetworks/customContent/fuse-testnet.mdx
+++ /dev/null
@@ -1,16 +0,0 @@
-import SubgraphCommunity from './_subgraph-community.mdx'
-
-### Indexing Data on Fuse Testnet
-
-Fuse Testnet is the public test network for Fuse, an EVM-compatible chain for payments and business use cases, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
-
-Fuse Testnet is supported by The Graph with Subgraphs — open APIs you publish to The Graph Network, where Indexers sync and serve the data while you manage your service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
-
-<SubgraphCommunity
-  chainName="Fuse Testnet"
-  networkId="fuse-testnet"
-  slug="fuse-testnet"
-  explorerUrl="https://explorer.fusespark.io"
-  explorerName="Blockscout"
-  rpcUrl="https://rpc.fusespark.io"
-/>
diff --git a/website/src/supportedNetworks/customContent/fuse.mdx b/website/src/supportedNetworks/customContent/fuse.mdx
deleted file mode 100644
index 9390ddabb378..000000000000
--- a/website/src/supportedNetworks/customContent/fuse.mdx
+++ /dev/null
@@ -1,16 +0,0 @@
-import SubgraphCommunity from './_subgraph-community.mdx'
-
-### Indexing Data on Fuse
-
-Fuse is an EVM-compatible chain focused on payments and real-world business use cases, with fast, low-cost transactions and FUSE as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
-
-Fuse is supported by The Graph with Subgraphs — open APIs you publish to The Graph Network, where Indexers sync and serve the data while you manage your service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
-
-<SubgraphCommunity
-  chainName="Fuse"
-  networkId="fuse"
-  slug="fuse"
-  explorerUrl="https://explorer.fuse.io"
-  explorerName="Blockscout"
-  rpcUrl="https://rpc.fuse.io"
-/>
diff --git a/website/src/supportedNetworks/customContent/gnosis-chiado.mdx b/website/src/supportedNetworks/customContent/gnosis-chiado.mdx
index d9223776e9f2..66dcca7eee26 100644
--- a/website/src/supportedNetworks/customContent/gnosis-chiado.mdx
+++ b/website/src/supportedNetworks/customContent/gnosis-chiado.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Gnosis Chiado Testnet
+## Indexing Data on Gnosis Chiado Testnet
 
 Gnosis Chiado Testnet is the public test network for Gnosis Chain, the EVM-compatible Layer 1 (formerly xDai), where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/gnosis-cl.mdx b/website/src/supportedNetworks/customContent/gnosis-cl.mdx
index 89308847e52f..b0d6a971305e 100644
--- a/website/src/supportedNetworks/customContent/gnosis-cl.mdx
+++ b/website/src/supportedNetworks/customContent/gnosis-cl.mdx
@@ -1,18 +1,26 @@
-### Indexing Data on Gnosis Beacon Chain
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+## Indexing Data on Gnosis Beacon Chain
 
 Gnosis Chain is an Ethereum-compatible network secured by its own proof-of-stake validator set, and the Gnosis Beacon Chain is its consensus layer. The Graph can stream that consensus-layer activity — blocks and epochs, validator activity, attestations, deposits, and slashings — as real-time data with Substreams.
 
 Gnosis Beacon Chain is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
 
-### Indexing Gnosis Beacon Chain with Substreams
+---
+
+<ProductSectionHeading
+  product="substreams"
+  id="indexing-gnosis-beacon-chain-with-substreams"
+  title="Indexing Gnosis Beacon Chain with Substreams"
+/>
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Gnosis Beacon Chain's consensus-layer blocks — validators, attestations, deposits, and slashings. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Gnosis Beacon Chain; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
diff --git a/website/src/supportedNetworks/customContent/gnosis.mdx b/website/src/supportedNetworks/customContent/gnosis.mdx
index c14ea8a96032..7ae4342ccb3b 100644
--- a/website/src/supportedNetworks/customContent/gnosis.mdx
+++ b/website/src/supportedNetworks/customContent/gnosis.mdx
@@ -1,6 +1,6 @@
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on Gnosis
+## Indexing Data on Gnosis
 
 Gnosis Chain is an EVM-compatible Layer 1 (formerly xDai) secured by the GNO token and a large community validator set, focused on stability, payments, and public-goods infrastructure, with xDAI — a stable native gas token — for fees. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/hemi-sepolia.mdx b/website/src/supportedNetworks/customContent/hemi-sepolia.mdx
index 755ec60d605f..1689d12ac79e 100644
--- a/website/src/supportedNetworks/customContent/hemi-sepolia.mdx
+++ b/website/src/supportedNetworks/customContent/hemi-sepolia.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Hemi Sepolia Testnet
+## Indexing Data on Hemi Sepolia Testnet
 
 Hemi Sepolia Testnet is the public test network for Hemi, the modular Bitcoin-and-Ethereum Layer 2, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/hemi.mdx b/website/src/supportedNetworks/customContent/hemi.mdx
index eb1093697081..89fe4311988c 100644
--- a/website/src/supportedNetworks/customContent/hemi.mdx
+++ b/website/src/supportedNetworks/customContent/hemi.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Hemi
+## Indexing Data on Hemi
 
 Hemi is a modular Layer 2 that combines Bitcoin and Ethereum into a single supernetwork, exposing Bitcoin state to EVM smart contracts through its hVM, with ETH for gas. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/hoodi-cl.mdx b/website/src/supportedNetworks/customContent/hoodi-cl.mdx
index 20f64c5730fd..a7cb67a5fc74 100644
--- a/website/src/supportedNetworks/customContent/hoodi-cl.mdx
+++ b/website/src/supportedNetworks/customContent/hoodi-cl.mdx
@@ -1,18 +1,26 @@
-### Indexing Data on Hoodi Beacon Chain
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+## Indexing Data on Hoodi Beacon Chain
 
 Hoodi is an Ethereum proof-of-stake testnet, and its Beacon Chain is the consensus layer that coordinates validators on the test network. The Graph can stream that consensus-layer activity — blocks and epochs, validator activity, attestations, deposits, and slashings — as real-time data with Substreams.
 
 Hoodi Beacon Chain is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
 
-### Indexing Hoodi Beacon Chain with Substreams
+---
+
+<ProductSectionHeading
+  product="substreams"
+  id="indexing-hoodi-beacon-chain-with-substreams"
+  title="Indexing Hoodi Beacon Chain with Substreams"
+/>
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Hoodi Beacon Chain's consensus-layer blocks — validators, attestations, deposits, and slashings. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Hoodi Beacon Chain; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
diff --git a/website/src/supportedNetworks/customContent/hoodi.mdx b/website/src/supportedNetworks/customContent/hoodi.mdx
index 97d30d3857ce..5ae50b7978c4 100644
--- a/website/src/supportedNetworks/customContent/hoodi.mdx
+++ b/website/src/supportedNetworks/customContent/hoodi.mdx
@@ -1,14 +1,14 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Ethereum Hoodi Testnet
+## Indexing Data on Ethereum Hoodi Testnet
 
 Ethereum Hoodi Testnet is a public Ethereum test network used by validators and application developers to test protocol upgrades and contracts before mainnet. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
 Ethereum Hoodi Testnet is supported by The Graph in two ways:
 
-- You can [develop and publish Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/) in Subgraph Studio — publishing is enabled, though guaranteed indexing via The Graph Network is not yet available.
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/) and [Pinax Network](https://app.pinax.network/docs?from=nav).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers develop, publish, and query their Subgraphs in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/), though guaranteed indexing via The Graph Network is not yet available for Ethereum Hoodi Testnet.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [The Graph Market](https://thegraph.market/).
 
 <SubgraphStudio
   chainName="Ethereum Hoodi Testnet"
diff --git a/website/src/supportedNetworks/customContent/hyper-evm.mdx b/website/src/supportedNetworks/customContent/hyper-evm.mdx
index 28e1f6c8a815..745a46160b19 100644
--- a/website/src/supportedNetworks/customContent/hyper-evm.mdx
+++ b/website/src/supportedNetworks/customContent/hyper-evm.mdx
@@ -1,6 +1,6 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 
-### Indexing Data on HyperEVM
+## Indexing Data on HyperEVM
 
 HyperEVM is the general-purpose EVM layer of Hyperliquid, the high-performance L1 best known for its onchain perpetuals exchange. It brings EVM smart contracts to the Hyperliquid ecosystem, with native token HYPE and tight integration with HyperCore, Hyperliquid's order-book and perps layer. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
 
diff --git a/website/src/supportedNetworks/customContent/index.ts b/website/src/supportedNetworks/customContent/index.ts
index 5d360ea01dc0..1d49ead72a0f 100644
--- a/website/src/supportedNetworks/customContent/index.ts
+++ b/website/src/supportedNetworks/customContent/index.ts
@@ -23,8 +23,6 @@ import Etherlink from './etherlink-mainnet.mdx'
 import EtherlinkShadownet from './etherlink-shadownet.mdx'
 import Fraxtal from './fraxtal.mdx'
 import Fuji from './fuji.mdx'
-import Fuse from './fuse.mdx'
-import FuseTestnet from './fuse-testnet.mdx'
 import Gnosis from './gnosis.mdx'
 import GnosisChiado from './gnosis-chiado.mdx'
 import GnosisBeacon from './gnosis-cl.mdx'
@@ -41,8 +39,6 @@ import Ink from './ink.mdx'
 import Joc from './joc.mdx'
 import JocTestnet from './joc-testnet.mdx'
 import Jungle4 from './jungle4.mdx'
-import Kaia from './kaia.mdx'
-import KaiaTestnet from './kaia-testnet.mdx'
 import Linea from './linea.mdx'
 import LineaSepolia from './linea-sepolia.mdx'
 import Litecoin from './litecoin.mdx'
@@ -51,8 +47,6 @@ import EthereumBeacon from './mainnet-cl.mdx'
 import Polygon from './matic.mdx'
 import MegaEth from './megaeth.mdx'
 import Monad from './monad.mdx'
-import Near from './near-mainnet.mdx'
-import NearTestnet from './near-testnet.mdx'
 import NeoX from './neox.mdx'
 import NeoXTestnet from './neox-testnet.mdx'
 import Optimism from './optimism.mdx'
@@ -87,7 +81,6 @@ import Tron from './tron.mdx'
 import TronEvm from './tron-evm.mdx'
 import Unichain from './unichain.mdx'
 import UnichainTestnet from './unichain-testnet.mdx'
-import Viction from './viction.mdx'
 import Wax from './wax.mdx'
 import WaxTestnet from './wax-testnet.mdx'
 import WorldChain from './worldchain.mdx'
@@ -97,7 +90,6 @@ import Zetachain from './zetachain.mdx'
 import Zilliqa from './zilliqa.mdx'
 import ZilliqaTestnet from './zilliqa-testnet.mdx'
 import ZksyncEra from './zksync-era.mdx'
-import ZksyncEraSepolia from './zksync-era-sepolia.mdx'
 import Zora from './zora.mdx'
 
 /**
@@ -167,8 +159,6 @@ export const customNetworkContent: Record<string, ComponentType> = {
   celo: Celo,
   tempo: Tempo,
   'xlayer-mainnet': XLayer,
-  'near-mainnet': Near,
-  'near-testnet': NearTestnet,
   'starknet-testnet': StarknetTestnet,
   'stellar-testnet': StellarTestnet,
   'injective-testnet': InjectiveTestnet,
@@ -177,8 +167,6 @@ export const customNetworkContent: Record<string, ComponentType> = {
   // Community Subgraph custom content
   boba: Boba,
   'boba-testnet': BobaTestnet,
-  fuse: Fuse,
-  'fuse-testnet': FuseTestnet,
   fraxtal: Fraxtal,
   rootstock: Rootstock,
   'rootstock-testnet': RootstockTestnet,
@@ -210,11 +198,7 @@ export const customNetworkContent: Record<string, ComponentType> = {
   'xlayer-sepolia': XLayerSepolia,
   zilliqa: Zilliqa,
   'zilliqa-testnet': ZilliqaTestnet,
-  'zksync-era-sepolia': ZksyncEraSepolia,
-  kaia: Kaia,
-  'kaia-testnet': KaiaTestnet,
   neox: NeoX,
   'neox-testnet': NeoXTestnet,
-  viction: Viction,
   zetachain: Zetachain,
 }
diff --git a/website/src/supportedNetworks/customContent/injective-evm-testnet.mdx b/website/src/supportedNetworks/customContent/injective-evm-testnet.mdx
index b7855998b520..7a55f50f4631 100644
--- a/website/src/supportedNetworks/customContent/injective-evm-testnet.mdx
+++ b/website/src/supportedNetworks/customContent/injective-evm-testnet.mdx
@@ -1,6 +1,6 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 
-### Indexing Data on Injective EVM Testnet
+## Indexing Data on Injective EVM Testnet
 
 Injective EVM Testnet is the public test network for Injective's EVM environment, where teams deploy and validate contracts before mainnet. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
 
diff --git a/website/src/supportedNetworks/customContent/injective-evm.mdx b/website/src/supportedNetworks/customContent/injective-evm.mdx
index 3912e72a5927..079c869510b3 100644
--- a/website/src/supportedNetworks/customContent/injective-evm.mdx
+++ b/website/src/supportedNetworks/customContent/injective-evm.mdx
@@ -1,14 +1,14 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on Injective EVM
+## Indexing Data on Injective EVM
 
 Injective EVM is the EVM environment of Injective, a Layer 1 blockchain optimized for finance and DeFi, bringing Ethereum smart contracts to the Injective ecosystem with INJ as its native token. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
 Injective EVM is supported by The Graph in two ways:
 
-- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/) while Indexers on The Graph Network sync and serve queries.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [The Graph Market](https://thegraph.market/).
 
 <SubgraphCommunity
   chainName="Injective EVM"
diff --git a/website/src/supportedNetworks/customContent/injective-mainnet.mdx b/website/src/supportedNetworks/customContent/injective-mainnet.mdx
index 6d1a59284d86..6d3899820649 100644
--- a/website/src/supportedNetworks/customContent/injective-mainnet.mdx
+++ b/website/src/supportedNetworks/customContent/injective-mainnet.mdx
@@ -1,22 +1,30 @@
-### Indexing Data on Injective
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+## Indexing Data on Injective
 
 Injective is a Cosmos-based Layer 1 optimized for finance, with a focus on onchain trading, derivatives, and DeFi. The Graph can stream that onchain activity — transactions and messages, DEX and derivatives activity, token transfers and balances, and smart-contract events — as real-time data with Substreams.
 
 Injective is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
 
-### Indexing Injective with Substreams
+---
+
+<ProductSectionHeading
+  product="substreams"
+  id="indexing-injective-with-substreams"
+  title="Indexing Injective with Substreams"
+/>
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Injective's Cosmos blocks, transactions, and events. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Injective; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
-1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+1. Install the Substreams CLI and get a key at [The Graph Market](https://thegraph.market/).
 2. Scaffold a project with `substreams init` and follow the prompts for Injective.
 3. Write your extraction and transformation logic in Rust, then run `substreams build`.
 4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/injective-testnet.mdx b/website/src/supportedNetworks/customContent/injective-testnet.mdx
index 669e00979da2..72b6197b791f 100644
--- a/website/src/supportedNetworks/customContent/injective-testnet.mdx
+++ b/website/src/supportedNetworks/customContent/injective-testnet.mdx
@@ -1,22 +1,30 @@
-### Indexing Data on Injective Testnet
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+## Indexing Data on Injective Testnet
 
 Injective Testnet is the public test network for Injective, a Cosmos-based Layer 1 optimized for finance and DeFi, where teams deploy and validate contracts before mainnet. The Graph can stream that onchain activity — transactions and messages, DEX and derivatives activity, token transfers and balances, and smart-contract events — as real-time data with Substreams.
 
 Injective Testnet is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
 
-### Indexing Injective Testnet with Substreams
+---
+
+<ProductSectionHeading
+  product="substreams"
+  id="indexing-injective-testnet-with-substreams"
+  title="Indexing Injective Testnet with Substreams"
+/>
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Injective Testnet's Cosmos blocks, transactions, and events. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Injective Testnet; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
-1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+1. Install the Substreams CLI and get a key at [The Graph Market](https://thegraph.market/).
 2. Scaffold a project with `substreams init` and follow the prompts for Injective.
 3. Write your extraction and transformation logic in Rust, then run `substreams build`.
 4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/ink.mdx b/website/src/supportedNetworks/customContent/ink.mdx
index 57f39da7a3c7..41dcd9ec70f6 100644
--- a/website/src/supportedNetworks/customContent/ink.mdx
+++ b/website/src/supportedNetworks/customContent/ink.mdx
@@ -1,6 +1,6 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 
-### Indexing Data on Ink
+## Indexing Data on Ink
 
 Ink is an Ethereum Layer 2 built on the OP Stack and part of the Optimism Superchain, incubated by Kraken with a focus on DeFi — bringing low fees and fast, Ethereum-secured settlement to onchain finance. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
 
diff --git a/website/src/supportedNetworks/customContent/joc-testnet.mdx b/website/src/supportedNetworks/customContent/joc-testnet.mdx
index e29e6062ea8c..8dcaf88833d0 100644
--- a/website/src/supportedNetworks/customContent/joc-testnet.mdx
+++ b/website/src/supportedNetworks/customContent/joc-testnet.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Japan Open Chain Testnet
+## Indexing Data on Japan Open Chain Testnet
 
 Japan Open Chain Testnet is the public test network for Japan Open Chain, the enterprise EVM Layer 1, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/joc.mdx b/website/src/supportedNetworks/customContent/joc.mdx
index 16a9496ce921..949620a167aa 100644
--- a/website/src/supportedNetworks/customContent/joc.mdx
+++ b/website/src/supportedNetworks/customContent/joc.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Japan Open Chain
+## Indexing Data on Japan Open Chain
 
 Japan Open Chain is an EVM-compatible Layer 1 operated by trusted Japanese enterprises and designed for compliant, business-grade applications, with JOC as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/jungle4.mdx b/website/src/supportedNetworks/customContent/jungle4.mdx
index aeef3cc78693..04e2680d0a17 100644
--- a/website/src/supportedNetworks/customContent/jungle4.mdx
+++ b/website/src/supportedNetworks/customContent/jungle4.mdx
@@ -1,18 +1,26 @@
-### Indexing Data on Vaulta Jungle4 Testnet
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+## Indexing Data on Vaulta Jungle4 Testnet
 
 Vaulta Jungle4 Testnet is a public test network for Vaulta (formerly EOS), an Antelope-based Layer 1, where teams deploy and validate contracts and applications before mainnet. The Graph can stream that onchain activity — transactions and actions, token transfers and balances, and smart-contract activity — as real-time data with Substreams.
 
 Vaulta Jungle4 Testnet is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
 
-### Indexing Vaulta Jungle4 Testnet with Substreams
+---
+
+<ProductSectionHeading
+  product="substreams"
+  id="indexing-vaulta-jungle4-testnet-with-substreams"
+  title="Indexing Vaulta Jungle4 Testnet with Substreams"
+/>
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Vaulta Jungle4 Testnet's blocks, transactions, and actions. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Vaulta Jungle4 Testnet; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
diff --git a/website/src/supportedNetworks/customContent/kaia-testnet.mdx b/website/src/supportedNetworks/customContent/kaia-testnet.mdx
deleted file mode 100644
index 82233059bf9d..000000000000
--- a/website/src/supportedNetworks/customContent/kaia-testnet.mdx
+++ /dev/null
@@ -1,15 +0,0 @@
-import SubgraphStudio from './_subgraph-studio.mdx'
-
-### Indexing Data on Kaia Kairos Testnet
-
-Kaia Kairos Testnet is the public test network for Kaia, the EVM-compatible Layer 1 formed by the merger of Klaytn and Finschia, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
-
-Kaia Kairos Testnet is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Kaia Kairos Testnet.
-
-<SubgraphStudio
-  chainName="Kaia Kairos Testnet"
-  networkId="kaia-testnet"
-  slug="kaia-testnet"
-  explorerUrl="https://kairos.kaiascan.io"
-  explorerName="KaiaScan"
-/>
diff --git a/website/src/supportedNetworks/customContent/kaia.mdx b/website/src/supportedNetworks/customContent/kaia.mdx
deleted file mode 100644
index cdca3f8474ab..000000000000
--- a/website/src/supportedNetworks/customContent/kaia.mdx
+++ /dev/null
@@ -1,15 +0,0 @@
-import SubgraphStudio from './_subgraph-studio.mdx'
-
-### Indexing Data on Kaia
-
-Kaia is an EVM-compatible Layer 1 formed by the merger of Klaytn and Finschia, built for large-scale Web3 and mini-dApp adoption across Asia, with KAIA as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
-
-Kaia is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Kaia.
-
-<SubgraphStudio
-  chainName="Kaia"
-  networkId="kaia"
-  slug="kaia"
-  explorerUrl="https://kaiascan.io"
-  explorerName="KaiaScan"
-/>
diff --git a/website/src/supportedNetworks/customContent/linea-sepolia.mdx b/website/src/supportedNetworks/customContent/linea-sepolia.mdx
index cebda3d60888..18dfb9f843de 100644
--- a/website/src/supportedNetworks/customContent/linea-sepolia.mdx
+++ b/website/src/supportedNetworks/customContent/linea-sepolia.mdx
@@ -1,14 +1,14 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Linea Sepolia Testnet
+## Indexing Data on Linea Sepolia Testnet
 
 Linea Sepolia Testnet is the public test network for Linea, the Consensys zkEVM Ethereum Layer 2, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
 Linea Sepolia Testnet is supported by The Graph in two ways:
 
-- You can [develop and publish Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/) in Subgraph Studio — publishing is enabled, though guaranteed indexing via The Graph Network is not yet available.
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers develop, publish, and query their Subgraphs in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/), though guaranteed indexing via The Graph Network is not yet available for Linea Sepolia Testnet.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [Pinax Network](https://app.pinax.network/docs?from=nav).
 
 <SubgraphStudio
   chainName="Linea Sepolia Testnet"
diff --git a/website/src/supportedNetworks/customContent/linea.mdx b/website/src/supportedNetworks/customContent/linea.mdx
index 02947d756d13..3b94e581210a 100644
--- a/website/src/supportedNetworks/customContent/linea.mdx
+++ b/website/src/supportedNetworks/customContent/linea.mdx
@@ -1,14 +1,14 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on Linea
+## Indexing Data on Linea
 
 Linea is an Ethereum Layer 2 zkEVM rollup developed by Consensys, combining full EVM equivalence with the security of zero-knowledge proofs and a growing DeFi ecosystem. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
 Linea is supported by The Graph in two ways:
 
-- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/) while Indexers on The Graph Network sync and serve queries.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [Pinax Network](https://app.pinax.network/docs?from=nav).
 
 <SubgraphCommunity
   chainName="Linea"
diff --git a/website/src/supportedNetworks/customContent/litecoin.mdx b/website/src/supportedNetworks/customContent/litecoin.mdx
index 2ee04f1dd734..1c247f015cad 100644
--- a/website/src/supportedNetworks/customContent/litecoin.mdx
+++ b/website/src/supportedNetworks/customContent/litecoin.mdx
@@ -1,18 +1,26 @@
-### Indexing Data on Litecoin
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+## Indexing Data on Litecoin
 
 Litecoin is a long-running proof-of-work blockchain and one of the earliest peer-to-peer digital currencies, securing the LTC asset. The Graph can stream that onchain activity — blocks and transactions, inputs and outputs, and address activity — as real-time data with Substreams.
 
 Litecoin is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
 
-### Indexing Litecoin with Substreams
+---
+
+<ProductSectionHeading
+  product="substreams"
+  id="indexing-litecoin-with-substreams"
+  title="Indexing Litecoin with Substreams"
+/>
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Litecoin's blocks, transactions, and their inputs and outputs. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Litecoin; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
diff --git a/website/src/supportedNetworks/customContent/mainnet-cl.mdx b/website/src/supportedNetworks/customContent/mainnet-cl.mdx
index de0330debb4e..a43dc22c48cb 100644
--- a/website/src/supportedNetworks/customContent/mainnet-cl.mdx
+++ b/website/src/supportedNetworks/customContent/mainnet-cl.mdx
@@ -1,18 +1,26 @@
-### Indexing Data on Ethereum Beacon Chain
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+## Indexing Data on Ethereum Beacon Chain
 
 The Ethereum Beacon Chain is Ethereum's consensus layer, coordinating the proof-of-stake validators that secure the network. The Graph can stream that consensus-layer activity — blocks and epochs, validator activity, attestations, deposits, and slashings — as real-time data with Substreams.
 
 Ethereum Beacon Chain is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
 
-### Indexing Ethereum Beacon Chain with Substreams
+---
+
+<ProductSectionHeading
+  product="substreams"
+  id="indexing-ethereum-beacon-chain-with-substreams"
+  title="Indexing Ethereum Beacon Chain with Substreams"
+/>
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Ethereum Beacon Chain's consensus-layer blocks — validators, attestations, deposits, and slashings. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Ethereum Beacon Chain; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
diff --git a/website/src/supportedNetworks/customContent/mainnet.mdx b/website/src/supportedNetworks/customContent/mainnet.mdx
index e3571d1ffcbb..7ee4f85af84b 100644
--- a/website/src/supportedNetworks/customContent/mainnet.mdx
+++ b/website/src/supportedNetworks/customContent/mainnet.mdx
@@ -1,14 +1,14 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on Ethereum
+## Indexing Data on Ethereum
 
 Ethereum is the original programmable, EVM Layer 1 and the largest smart-contract network by developer activity, total value locked, and application diversity, secured by proof-of-stake with ETH as its native token. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
 Ethereum is supported by The Graph in two ways:
 
-- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/), [Pinax Network](https://app.pinax.network/docs?from=nav), and [Data Nexus](https://data.nexus/).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/) while Indexers on The Graph Network sync and serve queries.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [The Graph Market](https://thegraph.market/).
 
 <SubgraphCommunity
   chainName="Ethereum"
diff --git a/website/src/supportedNetworks/customContent/matic.mdx b/website/src/supportedNetworks/customContent/matic.mdx
index 2d80f2f807a0..dbe4adca780f 100644
--- a/website/src/supportedNetworks/customContent/matic.mdx
+++ b/website/src/supportedNetworks/customContent/matic.mdx
@@ -2,8 +2,9 @@ import SubstreamsExtended from './_substreams-extended.mdx'
 import { Card } from '@/components'
 import SubgraphCommunity from './_subgraph-community.mdx'
 import { Subgraph } from '@edgeandnode/gds/icons'
+import { ExploreSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
 
-### Indexing Data on Polygon
+## Indexing Data on Polygon
 
 Polygon PoS is an EVM-compatible, Ethereum-scaling network built for high throughput and near-zero fees. Following the 2025 Rio upgrade it targets thousands of transactions per second with roughly two-second finality and fees of a fraction of a cent, and it settles more stablecoin payment volume than almost any other chain — powering apps like Polymarket alongside a deep DeFi ecosystem (Aave, QuickSwap, Uniswap), gaming, and real-world-asset projects. Its native token is POL.
 
@@ -11,10 +12,12 @@ The Graph can index that onchain activity, including DEX swaps, pools, and liqui
 
 Polygon is supported by The Graph in two ways:
 
-- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/) and [Pinax Network](https://app.pinax.network/docs?from=nav).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/) while Indexers on The Graph Network sync and serve queries.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [The Graph Market](https://thegraph.market/).
 
-### Find Existing Subgraphs on Polygon
+---
+
+<ExploreSectionHeading id="find-existing-subgraphs-on-polygon" title="Find Existing Subgraphs on Polygon" />
 
 Before you build, check whether the data you need is already live. Many of the most-used protocols on Polygon publish Subgraphs on The Graph that you can query today:
 
@@ -66,6 +69,7 @@ Browse [Graph Explorer](https://thegraph.com/explorer/) to search all published
   explorerUrl="https://polygonscan.com"
   explorerName="PolygonScan"
   rpcUrl="https://polygon.rpc.service.pinax.network"
+  hideExplorerSearch
 />
 
 <SubstreamsExtended chainName="Polygon" />
diff --git a/website/src/supportedNetworks/customContent/megaeth.mdx b/website/src/supportedNetworks/customContent/megaeth.mdx
index 0f071e981fe0..1b890bc7aa26 100644
--- a/website/src/supportedNetworks/customContent/megaeth.mdx
+++ b/website/src/supportedNetworks/customContent/megaeth.mdx
@@ -1,6 +1,6 @@
 import SubstreamsBase from './_substreams-base.mdx'
 
-### Indexing Data on MegaETH
+## Indexing Data on MegaETH
 
 MegaETH is a high-performance, EVM-compatible Ethereum Layer 2 built for real-time applications with very high throughput and low latency. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
 
diff --git a/website/src/supportedNetworks/customContent/monad.mdx b/website/src/supportedNetworks/customContent/monad.mdx
index 4ab01cef2227..8fcd80a0483c 100644
--- a/website/src/supportedNetworks/customContent/monad.mdx
+++ b/website/src/supportedNetworks/customContent/monad.mdx
@@ -1,6 +1,6 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 
-### Indexing Data on Monad
+## Indexing Data on Monad
 
 Monad is a high-performance, EVM-compatible Layer 1 that uses parallel execution to reach high throughput while staying fully compatible with Ethereum tooling. Its native token is MON. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
 
diff --git a/website/src/supportedNetworks/customContent/near-mainnet.mdx b/website/src/supportedNetworks/customContent/near-mainnet.mdx
deleted file mode 100644
index 42588047148e..000000000000
--- a/website/src/supportedNetworks/customContent/near-mainnet.mdx
+++ /dev/null
@@ -1,22 +0,0 @@
-### Indexing Data on NEAR
-
-NEAR is a high-performance, sharded Layer 1 blockchain with a human-readable account model and Nightshade consensus, designed for scalable consumer and AI applications, with NEAR as its native token. The Graph can stream that onchain activity — blocks, transactions, and receipts; token transfers and balances; and smart-contract activity — as real-time data with Substreams.
-
-NEAR is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
-
-### Indexing NEAR with Substreams
-
-[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams NEAR's blocks, transactions, and receipts. Modules are written in Rust and composed into reusable packages.
-
-#### Find an Existing Module on Substreams.dev
-
-Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on NEAR; if a module fits, you can consume its output directly or import it as a dependency in your own project.
-
-#### Develop Your Own Substreams Module
-
-If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
-
-1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
-2. Scaffold a project with `substreams init` and follow the prompts for NEAR.
-3. Write your extraction and transformation logic in Rust, then run `substreams build`.
-4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/near-testnet.mdx b/website/src/supportedNetworks/customContent/near-testnet.mdx
deleted file mode 100644
index 62e72870d3c2..000000000000
--- a/website/src/supportedNetworks/customContent/near-testnet.mdx
+++ /dev/null
@@ -1,22 +0,0 @@
-### Indexing Data on NEAR Testnet
-
-NEAR Testnet is the public test network for NEAR, a sharded Layer 1 with a human-readable account model, where teams deploy and validate contracts before mainnet. The Graph can stream that onchain activity — blocks, transactions, and receipts; token transfers and balances; and smart-contract activity — as real-time data with Substreams.
-
-NEAR Testnet is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
-
-### Indexing NEAR Testnet with Substreams
-
-[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams NEAR Testnet's blocks, transactions, and receipts. Modules are written in Rust and composed into reusable packages.
-
-#### Find an Existing Module on Substreams.dev
-
-Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on NEAR Testnet; if a module fits, you can consume its output directly or import it as a dependency in your own project.
-
-#### Develop Your Own Substreams Module
-
-If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
-
-1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
-2. Scaffold a project with `substreams init` and follow the prompts for NEAR.
-3. Write your extraction and transformation logic in Rust, then run `substreams build`.
-4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/neox-testnet.mdx b/website/src/supportedNetworks/customContent/neox-testnet.mdx
index 8cd6ba6c2111..3d73e28a935a 100644
--- a/website/src/supportedNetworks/customContent/neox-testnet.mdx
+++ b/website/src/supportedNetworks/customContent/neox-testnet.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Neo X Testnet
+## Indexing Data on Neo X Testnet
 
 Neo X Testnet is the public test network for Neo X, the EVM-compatible sidechain of the Neo blockchain, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/neox.mdx b/website/src/supportedNetworks/customContent/neox.mdx
index 7a15ca627b14..509fd67a47d7 100644
--- a/website/src/supportedNetworks/customContent/neox.mdx
+++ b/website/src/supportedNetworks/customContent/neox.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Neo X
+## Indexing Data on Neo X
 
 Neo X is an EVM-compatible sidechain of the Neo blockchain secured by a dBFT consensus, extending Neo's Smart Economy to EVM developers, with GAS as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/optimism-sepolia.mdx b/website/src/supportedNetworks/customContent/optimism-sepolia.mdx
index 9580087005a4..efd06fc264da 100644
--- a/website/src/supportedNetworks/customContent/optimism-sepolia.mdx
+++ b/website/src/supportedNetworks/customContent/optimism-sepolia.mdx
@@ -1,14 +1,14 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on OP Sepolia Testnet
+## Indexing Data on OP Sepolia Testnet
 
 OP Sepolia Testnet is the public test network for Optimism (OP Mainnet), the OP Stack Ethereum Layer 2, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
 OP Sepolia Testnet is supported by The Graph in two ways:
 
-- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/) while Indexers on The Graph Network sync and serve queries.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [Pinax Network](https://app.pinax.network/docs?from=nav).
 
 <SubgraphCommunity
   chainName="OP Sepolia Testnet"
diff --git a/website/src/supportedNetworks/customContent/optimism.mdx b/website/src/supportedNetworks/customContent/optimism.mdx
index c37fde0ef3ff..d0e95e67785d 100644
--- a/website/src/supportedNetworks/customContent/optimism.mdx
+++ b/website/src/supportedNetworks/customContent/optimism.mdx
@@ -1,14 +1,14 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on Optimism
+## Indexing Data on Optimism
 
 Optimism (OP Mainnet) is an Ethereum Layer 2 built on the OP Stack and the flagship chain of the Optimism Superchain, with a large DeFi and infrastructure ecosystem and OP as its governance token. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
 Optimism is supported by The Graph in two ways:
 
-- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/), [Pinax Network](https://app.pinax.network/docs?from=nav), and [Data Nexus](https://data.nexus/).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/) while Indexers on The Graph Network sync and serve queries.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [The Graph Market](https://thegraph.market/).
 
 <SubgraphCommunity
   chainName="Optimism"
diff --git a/website/src/supportedNetworks/customContent/peaq.mdx b/website/src/supportedNetworks/customContent/peaq.mdx
index b14de73069b9..2879ab10d70e 100644
--- a/website/src/supportedNetworks/customContent/peaq.mdx
+++ b/website/src/supportedNetworks/customContent/peaq.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on peaq
+## Indexing Data on peaq
 
 peaq is an EVM-compatible Layer 1 built for DePIN — decentralized physical infrastructure networks and machine economies — with PEAQ as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/polygon-amoy.mdx b/website/src/supportedNetworks/customContent/polygon-amoy.mdx
index 67924ef5cc3e..b2e97e148ff7 100644
--- a/website/src/supportedNetworks/customContent/polygon-amoy.mdx
+++ b/website/src/supportedNetworks/customContent/polygon-amoy.mdx
@@ -1,14 +1,14 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Polygon Amoy Testnet
+## Indexing Data on Polygon Amoy Testnet
 
 Polygon Amoy Testnet is the public test network for Polygon PoS, the EVM-compatible Ethereum scaling network, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
 Polygon Amoy Testnet is supported by The Graph in two ways:
 
-- You can [develop and publish Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/) in Subgraph Studio — publishing is enabled, though guaranteed indexing via The Graph Network is not yet available.
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers develop, publish, and query their Subgraphs in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/), though guaranteed indexing via The Graph Network is not yet available for Polygon Amoy Testnet.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [Pinax Network](https://app.pinax.network/docs?from=nav).
 
 <SubgraphStudio
   chainName="Polygon Amoy Testnet"
diff --git a/website/src/supportedNetworks/customContent/robinhood-sepolia.mdx b/website/src/supportedNetworks/customContent/robinhood-sepolia.mdx
index 724225d2182a..e96c0080275c 100644
--- a/website/src/supportedNetworks/customContent/robinhood-sepolia.mdx
+++ b/website/src/supportedNetworks/customContent/robinhood-sepolia.mdx
@@ -1,6 +1,6 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 
-### Indexing Data on Robinhood Chain Testnet
+## Indexing Data on Robinhood Chain Testnet
 
 Robinhood Chain Testnet is the public test network for Robinhood Chain, an Arbitrum-based Ethereum Layer 2 for tokenized real-world assets, where teams deploy and validate contracts before mainnet. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
 
diff --git a/website/src/supportedNetworks/customContent/robinhood.mdx b/website/src/supportedNetworks/customContent/robinhood.mdx
index ecd1dd832c6d..e6a66e40df6f 100644
--- a/website/src/supportedNetworks/customContent/robinhood.mdx
+++ b/website/src/supportedNetworks/customContent/robinhood.mdx
@@ -1,6 +1,6 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 
-### Indexing Data on Robinhood Chain
+## Indexing Data on Robinhood Chain
 
 Robinhood Chain is an Ethereum Layer 2 built on Arbitrum technology, created by Robinhood to bring tokenized real-world assets — including tokenized stocks — onchain. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
 
diff --git a/website/src/supportedNetworks/customContent/rootstock-testnet.mdx b/website/src/supportedNetworks/customContent/rootstock-testnet.mdx
index 36a19ea0ec12..dfe478dfcab7 100644
--- a/website/src/supportedNetworks/customContent/rootstock-testnet.mdx
+++ b/website/src/supportedNetworks/customContent/rootstock-testnet.mdx
@@ -1,6 +1,6 @@
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on Rootstock Testnet
+## Indexing Data on Rootstock Testnet
 
 Rootstock Testnet is the public test network for Rootstock, the Bitcoin-secured EVM sidechain, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/rootstock.mdx b/website/src/supportedNetworks/customContent/rootstock.mdx
index 2755b0dcc2b4..336441ccb7d5 100644
--- a/website/src/supportedNetworks/customContent/rootstock.mdx
+++ b/website/src/supportedNetworks/customContent/rootstock.mdx
@@ -1,6 +1,6 @@
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on Rootstock
+## Indexing Data on Rootstock
 
 Rootstock (RSK) is a Bitcoin sidechain that brings EVM-compatible smart contracts to Bitcoin, secured by merge-mining with the Bitcoin network and using RBTC, a Bitcoin-pegged token, for gas. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/scroll-sepolia.mdx b/website/src/supportedNetworks/customContent/scroll-sepolia.mdx
index 4eac5f64194d..3ef352b19e7c 100644
--- a/website/src/supportedNetworks/customContent/scroll-sepolia.mdx
+++ b/website/src/supportedNetworks/customContent/scroll-sepolia.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Scroll Sepolia Testnet
+## Indexing Data on Scroll Sepolia Testnet
 
 Scroll Sepolia Testnet is the public test network for Scroll, the Ethereum Layer 2 zkEVM rollup, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/scroll.mdx b/website/src/supportedNetworks/customContent/scroll.mdx
index f67ba4f28d4f..100025b60723 100644
--- a/website/src/supportedNetworks/customContent/scroll.mdx
+++ b/website/src/supportedNetworks/customContent/scroll.mdx
@@ -1,6 +1,6 @@
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on Scroll
+## Indexing Data on Scroll
 
 Scroll is an Ethereum Layer 2 zkEVM rollup offering bytecode-level EVM equivalence backed by zero-knowledge proofs, focused on security and seamless developer compatibility. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/sei-atlantic.mdx b/website/src/supportedNetworks/customContent/sei-atlantic.mdx
index 7e255290e201..52e3474b5a49 100644
--- a/website/src/supportedNetworks/customContent/sei-atlantic.mdx
+++ b/website/src/supportedNetworks/customContent/sei-atlantic.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Sei Atlantic Testnet
+## Indexing Data on Sei Atlantic Testnet
 
 Sei Atlantic Testnet is the public test network for Sei, a high-performance EVM Layer 1 with parallelized execution, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/sei-mainnet.mdx b/website/src/supportedNetworks/customContent/sei-mainnet.mdx
index 3e93b4aafde8..320b4556b9f7 100644
--- a/website/src/supportedNetworks/customContent/sei-mainnet.mdx
+++ b/website/src/supportedNetworks/customContent/sei-mainnet.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Sei
+## Indexing Data on Sei
 
 Sei is a high-performance, EVM-compatible Layer 1 built for trading and DeFi, using parallelized execution for fast finality and high throughput, with SEI as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/sepolia-cl.mdx b/website/src/supportedNetworks/customContent/sepolia-cl.mdx
index 92e6be621d0e..f189ecdc323b 100644
--- a/website/src/supportedNetworks/customContent/sepolia-cl.mdx
+++ b/website/src/supportedNetworks/customContent/sepolia-cl.mdx
@@ -1,18 +1,26 @@
-### Indexing Data on Sepolia Beacon Chain
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+## Indexing Data on Sepolia Beacon Chain
 
 Sepolia is a widely used Ethereum testnet, and its Beacon Chain is the consensus layer that coordinates validators on the test network. The Graph can stream that consensus-layer activity — blocks and epochs, validator activity, attestations, deposits, and slashings — as real-time data with Substreams.
 
 Sepolia Beacon Chain is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
 
-### Indexing Sepolia Beacon Chain with Substreams
+---
+
+<ProductSectionHeading
+  product="substreams"
+  id="indexing-sepolia-beacon-chain-with-substreams"
+  title="Indexing Sepolia Beacon Chain with Substreams"
+/>
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Sepolia Beacon Chain's consensus-layer blocks — validators, attestations, deposits, and slashings. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Sepolia Beacon Chain; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
diff --git a/website/src/supportedNetworks/customContent/sepolia.mdx b/website/src/supportedNetworks/customContent/sepolia.mdx
index d7fd8778d7ca..b7f9f8271e4d 100644
--- a/website/src/supportedNetworks/customContent/sepolia.mdx
+++ b/website/src/supportedNetworks/customContent/sepolia.mdx
@@ -1,14 +1,14 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on Ethereum Sepolia Testnet
+## Indexing Data on Ethereum Sepolia Testnet
 
 Ethereum Sepolia Testnet is the primary Ethereum test network for application developers, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
 Ethereum Sepolia Testnet is supported by The Graph in two ways:
 
-- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/) and [Pinax Network](https://app.pinax.network/docs?from=nav).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/) while Indexers on The Graph Network sync and serve queries.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [The Graph Market](https://thegraph.market/).
 
 <SubgraphCommunity
   chainName="Ethereum Sepolia Testnet"
diff --git a/website/src/supportedNetworks/customContent/solana-accounts.mdx b/website/src/supportedNetworks/customContent/solana-accounts.mdx
index b96192b4c07c..09b16e9e1158 100644
--- a/website/src/supportedNetworks/customContent/solana-accounts.mdx
+++ b/website/src/supportedNetworks/customContent/solana-accounts.mdx
@@ -1,22 +1,30 @@
-### Indexing Data on Solana Accounts
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+## Indexing Data on Solana Accounts
 
 Solana Accounts is a Substreams data source for Solana that streams account state changes — how program, token, and other accounts are created and updated over time — rather than transactions or instructions. The Graph can stream that onchain activity — account creations and updates, token account and balance changes, and program-owned account state — as real-time data with Substreams.
 
 Solana Accounts is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
 
-### Indexing Solana Accounts with Substreams
+---
+
+<ProductSectionHeading
+  product="substreams"
+  id="indexing-solana-accounts-with-substreams"
+  title="Indexing Solana Accounts with Substreams"
+/>
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Solana Accounts streams Solana's account block model, so modules have access to full account snapshots and updates as they change. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Solana Accounts; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
-1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+1. Install the Substreams CLI and get a key at [The Graph Market](https://thegraph.market/).
 2. `substreams init`'s Solana templates stream Solana blocks, not account blocks, so set up the project by hand: write a [`substreams.yaml` manifest](https://docs.substreams.dev/reference-material/manifest-and-components/manifests) with `network: solana-accounts` and a Rust map module that takes `sf.solana.type.v1.AccountBlock` as its input (the protobuf definitions are published on [Buf](https://buf.build/streamingfast/firehose-solana)).
 3. Write your extraction and transformation logic in Rust, then run `substreams build`.
 4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/solana-devnet.mdx b/website/src/supportedNetworks/customContent/solana-devnet.mdx
index 81e99690935c..ae3dbe7bef91 100644
--- a/website/src/supportedNetworks/customContent/solana-devnet.mdx
+++ b/website/src/supportedNetworks/customContent/solana-devnet.mdx
@@ -1,22 +1,30 @@
-### Indexing Data on Solana Devnet
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+## Indexing Data on Solana Devnet
 
 Solana Devnet is the development network for Solana, a high-throughput Layer 1 known for fast, low-cost transactions. The Graph can stream that onchain activity — program interactions, DEX swaps, token transfers and balances, and account updates — as real-time data with Substreams.
 
 Solana Devnet is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/) and [Pinax Network](https://app.pinax.network/docs?from=nav).
 
-### Indexing Solana Devnet with Substreams
+---
+
+<ProductSectionHeading
+  product="substreams"
+  id="indexing-solana-devnet-with-substreams"
+  title="Indexing Solana Devnet with Substreams"
+/>
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Solana Devnet is available through Substreams' Solana block model, so modules have access to blocks, transactions, and instructions. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Solana Devnet; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
-1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+1. Install the Substreams CLI and get a key at [The Graph Market](https://thegraph.market/).
 2. Scaffold a project with `substreams init` and choose the Solana path.
 3. Write your extraction and transformation logic in Rust, then run `substreams build`.
 4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/solana-mainnet-beta.mdx b/website/src/supportedNetworks/customContent/solana-mainnet-beta.mdx
index 50bef70bc359..e94d58a9edb0 100644
--- a/website/src/supportedNetworks/customContent/solana-mainnet-beta.mdx
+++ b/website/src/supportedNetworks/customContent/solana-mainnet-beta.mdx
@@ -1,22 +1,30 @@
-### Indexing Data on Solana
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+## Indexing Data on Solana
 
 Solana is a high-throughput Layer 1 known for fast, low-cost transactions and a large DeFi, NFT, and payments ecosystem. The Graph can stream that onchain activity — program interactions, DEX swaps, token transfers and balances, and account updates — as real-time data with Substreams.
 
 Solana is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/) and [Pinax Network](https://app.pinax.network/docs?from=nav).
 
-### Indexing Solana with Substreams
+---
+
+<ProductSectionHeading
+  product="substreams"
+  id="indexing-solana-with-substreams"
+  title="Indexing Solana with Substreams"
+/>
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Solana is available through Substreams' Solana block model, so modules have access to blocks, transactions, and instructions. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Solana; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
-1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+1. Install the Substreams CLI and get a key at [The Graph Market](https://thegraph.market/).
 2. Scaffold a project with `substreams init` and choose the Solana path.
 3. Write your extraction and transformation logic in Rust, then run `substreams build`.
 4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/soneium-testnet.mdx b/website/src/supportedNetworks/customContent/soneium-testnet.mdx
index b317dc1b2f53..24df1a456d6e 100644
--- a/website/src/supportedNetworks/customContent/soneium-testnet.mdx
+++ b/website/src/supportedNetworks/customContent/soneium-testnet.mdx
@@ -1,6 +1,6 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 
-### Indexing Data on Soneium Minato Testnet
+## Indexing Data on Soneium Minato Testnet
 
 Soneium Minato Testnet is the public test network for Soneium, Sony's OP Stack Ethereum Layer 2, where teams deploy and validate contracts before mainnet. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
 
diff --git a/website/src/supportedNetworks/customContent/soneium.mdx b/website/src/supportedNetworks/customContent/soneium.mdx
index 8e3c865382bb..8cdc6ee5f747 100644
--- a/website/src/supportedNetworks/customContent/soneium.mdx
+++ b/website/src/supportedNetworks/customContent/soneium.mdx
@@ -1,6 +1,6 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 
-### Indexing Data on Soneium
+## Indexing Data on Soneium
 
 Soneium is an Ethereum Layer 2 built on the OP Stack and part of the Optimism Superchain, developed by Sony Block Solutions Labs to bring creators, entertainment, and consumer apps onchain. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
 
diff --git a/website/src/supportedNetworks/customContent/sonic-testnet.mdx b/website/src/supportedNetworks/customContent/sonic-testnet.mdx
index fb8ad7c8f277..8e9e65c46390 100644
--- a/website/src/supportedNetworks/customContent/sonic-testnet.mdx
+++ b/website/src/supportedNetworks/customContent/sonic-testnet.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Sonic Testnet
+## Indexing Data on Sonic Testnet
 
 Sonic Testnet is the public test network for Sonic, the high-performance EVM Layer 1 from the team behind Fantom, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/sonic.mdx b/website/src/supportedNetworks/customContent/sonic.mdx
index dcb805114322..3fa2a2f8bbf8 100644
--- a/website/src/supportedNetworks/customContent/sonic.mdx
+++ b/website/src/supportedNetworks/customContent/sonic.mdx
@@ -1,6 +1,6 @@
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on Sonic
+## Indexing Data on Sonic
 
 Sonic is a high-performance, EVM-compatible Layer 1 from the team behind Fantom, built for speed with sub-second finality and high throughput, with S as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/stable.mdx b/website/src/supportedNetworks/customContent/stable.mdx
index b8ee1264b98f..3e71edfc78a5 100644
--- a/website/src/supportedNetworks/customContent/stable.mdx
+++ b/website/src/supportedNetworks/customContent/stable.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Stable
+## Indexing Data on Stable
 
 Stable is an EVM-compatible Layer 1 built for stablecoin payments, using USDT as its native gas token for fast, low-cost transfers. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/starknet-mainnet.mdx b/website/src/supportedNetworks/customContent/starknet-mainnet.mdx
index df2bf7cb986f..3291a8a525cc 100644
--- a/website/src/supportedNetworks/customContent/starknet-mainnet.mdx
+++ b/website/src/supportedNetworks/customContent/starknet-mainnet.mdx
@@ -1,22 +1,30 @@
-### Indexing Data on Starknet
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+## Indexing Data on Starknet
 
 Starknet is an Ethereum Layer 2 validity rollup powered by STARK proofs, using the Cairo programming model for scalable, low-cost execution. The Graph can stream that onchain activity — transactions, DEX swaps, token transfers and balances, and contract events — as real-time data with Substreams.
 
 Starknet is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
 
-### Indexing Starknet with Substreams
+---
+
+<ProductSectionHeading
+  product="substreams"
+  id="indexing-starknet-with-substreams"
+  title="Indexing Starknet with Substreams"
+/>
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Starknet's blocks, transactions, and events. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Starknet; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
-1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+1. Install the Substreams CLI and get a key at [The Graph Market](https://thegraph.market/).
 2. Scaffold a project with `substreams init` and follow the prompts for Starknet.
 3. Write your extraction and transformation logic in Rust, then run `substreams build`.
 4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/starknet-testnet.mdx b/website/src/supportedNetworks/customContent/starknet-testnet.mdx
index 4e70d0b26c4d..1d8ae2680253 100644
--- a/website/src/supportedNetworks/customContent/starknet-testnet.mdx
+++ b/website/src/supportedNetworks/customContent/starknet-testnet.mdx
@@ -1,22 +1,30 @@
-### Indexing Data on Starknet Sepolia Testnet
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+## Indexing Data on Starknet Sepolia Testnet
 
 Starknet Sepolia Testnet is the public test network for Starknet, an Ethereum Layer 2 validity rollup powered by STARK proofs and the Cairo programming model, where teams deploy and validate contracts before mainnet. The Graph can stream that onchain activity — transactions, DEX swaps, token transfers and balances, and contract events — as real-time data with Substreams.
 
 Starknet Sepolia Testnet is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
 
-### Indexing Starknet Sepolia Testnet with Substreams
+---
+
+<ProductSectionHeading
+  product="substreams"
+  id="indexing-starknet-sepolia-testnet-with-substreams"
+  title="Indexing Starknet Sepolia Testnet with Substreams"
+/>
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Starknet Sepolia Testnet's blocks, transactions, and events. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Starknet Sepolia Testnet; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
-1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+1. Install the Substreams CLI and get a key at [The Graph Market](https://thegraph.market/).
 2. Scaffold a project with `substreams init` and follow the prompts for Starknet.
 3. Write your extraction and transformation logic in Rust, then run `substreams build`.
 4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/stellar-testnet.mdx b/website/src/supportedNetworks/customContent/stellar-testnet.mdx
index efc9317e1981..99f8b5bf6b03 100644
--- a/website/src/supportedNetworks/customContent/stellar-testnet.mdx
+++ b/website/src/supportedNetworks/customContent/stellar-testnet.mdx
@@ -1,22 +1,30 @@
-### Indexing Data on Stellar Testnet
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+## Indexing Data on Stellar Testnet
 
 Stellar Testnet is the public test network for Stellar, a Layer 1 built for payments and asset issuance, where teams deploy and validate contracts before mainnet. The Graph can stream that onchain activity — payments and transactions, asset transfers and balances, DEX trades, and ledger changes — as real-time data with Substreams.
 
 Stellar Testnet is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
 
-### Indexing Stellar Testnet with Substreams
+---
+
+<ProductSectionHeading
+  product="substreams"
+  id="indexing-stellar-testnet-with-substreams"
+  title="Indexing Stellar Testnet with Substreams"
+/>
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Stellar Testnet's ledgers, transactions, and operations. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Stellar Testnet; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
-1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+1. Install the Substreams CLI and get a key at [The Graph Market](https://thegraph.market/).
 2. Scaffold a project with `substreams init` and follow the prompts for Stellar.
 3. Write your extraction and transformation logic in Rust, then run `substreams build`.
 4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/stellar.mdx b/website/src/supportedNetworks/customContent/stellar.mdx
index 7bd9a684e68a..708ee8fd5e81 100644
--- a/website/src/supportedNetworks/customContent/stellar.mdx
+++ b/website/src/supportedNetworks/customContent/stellar.mdx
@@ -1,22 +1,30 @@
-### Indexing Data on Stellar
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+## Indexing Data on Stellar
 
 Stellar is a Layer 1 blockchain built for payments and asset issuance, with fast settlement and low fees. The Graph can stream that onchain activity — payments and transactions, asset transfers and balances, DEX trades, and ledger changes — as real-time data with Substreams.
 
 Stellar is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
 
-### Indexing Stellar with Substreams
+---
+
+<ProductSectionHeading
+  product="substreams"
+  id="indexing-stellar-with-substreams"
+  title="Indexing Stellar with Substreams"
+/>
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Stellar's ledgers, transactions, and operations. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Stellar; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
-1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+1. Install the Substreams CLI and get a key at [The Graph Market](https://thegraph.market/).
 2. Scaffold a project with `substreams init` and follow the prompts for Stellar.
 3. Write your extraction and transformation logic in Rust, then run `substreams build`.
 4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/tempo-moderato.mdx b/website/src/supportedNetworks/customContent/tempo-moderato.mdx
index ac2b7813c4be..1c6405dbb2e2 100644
--- a/website/src/supportedNetworks/customContent/tempo-moderato.mdx
+++ b/website/src/supportedNetworks/customContent/tempo-moderato.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Tempo Moderato Testnet
+## Indexing Data on Tempo Moderato Testnet
 
 Tempo Moderato Testnet is the public test network for Tempo, the Stripe- and Paradigm-built Layer 1 for stablecoin payments, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/tempo.mdx b/website/src/supportedNetworks/customContent/tempo.mdx
index e23a860fa542..0db84cce8a04 100644
--- a/website/src/supportedNetworks/customContent/tempo.mdx
+++ b/website/src/supportedNetworks/customContent/tempo.mdx
@@ -1,14 +1,14 @@
 import SubstreamsBase from './_substreams-base.mdx'
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Tempo
+## Indexing Data on Tempo
 
 Tempo is an EVM-compatible Layer 1 built by Stripe and Paradigm for stablecoin payments, designed for high-throughput, low-cost enterprise payment flows. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
 Tempo is supported by The Graph in two ways:
 
-- You can [develop and publish Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/) in Subgraph Studio — publishing is enabled, though guaranteed indexing via The Graph Network is not yet available.
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers develop, publish, and query their Subgraphs in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/), though guaranteed indexing via The Graph Network is not yet available for Tempo.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [Pinax Network](https://app.pinax.network/docs?from=nav).
 
 <SubgraphStudio
   chainName="Tempo"
diff --git a/website/src/supportedNetworks/customContent/tron-evm.mdx b/website/src/supportedNetworks/customContent/tron-evm.mdx
index 68b5c082187a..21bcc3ad35f0 100644
--- a/website/src/supportedNetworks/customContent/tron-evm.mdx
+++ b/website/src/supportedNetworks/customContent/tron-evm.mdx
@@ -1,6 +1,6 @@
 import SubstreamsBase from './_substreams-base.mdx'
 
-### Indexing Data on TRON EVM
+## Indexing Data on TRON EVM
 
 TRON EVM is the EVM-compatible environment on TRON, a high-throughput Layer 1 widely used for stablecoin transfers and payments. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
 
diff --git a/website/src/supportedNetworks/customContent/tron.mdx b/website/src/supportedNetworks/customContent/tron.mdx
index 5f63def8d71b..d502ffff69b0 100644
--- a/website/src/supportedNetworks/customContent/tron.mdx
+++ b/website/src/supportedNetworks/customContent/tron.mdx
@@ -1,22 +1,26 @@
-### Indexing Data on TRON
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+## Indexing Data on TRON
 
 TRON is a high-throughput Layer 1 widely used for stablecoin transfers and payments, with a large DeFi and token ecosystem. The Graph can stream that onchain activity — transactions, stablecoin and token transfers, DEX swaps, and contract events — as real-time data with Substreams.
 
 TRON is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
 
-### Indexing TRON with Substreams
+---
+
+<ProductSectionHeading product="substreams" id="indexing-tron-with-substreams" title="Indexing TRON with Substreams" />
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams TRON's blocks, transactions, and events. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on TRON; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
-1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+1. Install the Substreams CLI and get a key at [The Graph Market](https://thegraph.market/).
 2. Scaffold a project with `substreams init` and follow the prompts for TRON.
 3. Write your extraction and transformation logic in Rust, then run `substreams build`.
 4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/unichain-testnet.mdx b/website/src/supportedNetworks/customContent/unichain-testnet.mdx
index b06eac5c090c..2daae618bdc7 100644
--- a/website/src/supportedNetworks/customContent/unichain-testnet.mdx
+++ b/website/src/supportedNetworks/customContent/unichain-testnet.mdx
@@ -1,14 +1,14 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Unichain Sepolia Testnet
+## Indexing Data on Unichain Sepolia Testnet
 
 Unichain Sepolia Testnet is the public test network for Unichain, Uniswap's OP Stack Ethereum Layer 2, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
 Unichain Sepolia Testnet is supported by The Graph in two ways:
 
-- You can [develop and publish Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/) in Subgraph Studio — publishing is enabled, though guaranteed indexing via The Graph Network is not yet available.
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers develop, publish, and query their Subgraphs in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/), though guaranteed indexing via The Graph Network is not yet available for Unichain Sepolia Testnet.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [Pinax Network](https://app.pinax.network/docs?from=nav).
 
 <SubgraphStudio
   chainName="Unichain Sepolia Testnet"
diff --git a/website/src/supportedNetworks/customContent/unichain.mdx b/website/src/supportedNetworks/customContent/unichain.mdx
index 910071f5d856..89ac9c924a93 100644
--- a/website/src/supportedNetworks/customContent/unichain.mdx
+++ b/website/src/supportedNetworks/customContent/unichain.mdx
@@ -1,14 +1,14 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on Unichain
+## Indexing Data on Unichain
 
 Unichain is an Ethereum Layer 2 built on the OP Stack by Uniswap Labs, optimized for DeFi with fast, low-cost swaps and cross-chain liquidity. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
 Unichain is supported by The Graph in two ways:
 
-- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/), [Pinax Network](https://app.pinax.network/docs?from=nav), and [Data Nexus](https://data.nexus/).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/) while Indexers on The Graph Network sync and serve queries.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [The Graph Market](https://thegraph.market/).
 
 <SubgraphCommunity
   chainName="Unichain"
diff --git a/website/src/supportedNetworks/customContent/viction.mdx b/website/src/supportedNetworks/customContent/viction.mdx
deleted file mode 100644
index 65fe5b834989..000000000000
--- a/website/src/supportedNetworks/customContent/viction.mdx
+++ /dev/null
@@ -1,15 +0,0 @@
-import SubgraphStudio from './_subgraph-studio.mdx'
-
-### Indexing Data on Viction
-
-Viction (formerly TomoChain) is an EVM-compatible Layer 1 focused on zero-gas transactions and account abstraction for consumer-facing dApps, with VIC as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
-
-Viction is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Viction.
-
-<SubgraphStudio
-  chainName="Viction"
-  networkId="viction"
-  slug="viction"
-  explorerUrl="https://www.vicscan.xyz"
-  explorerName="VICScan"
-/>
diff --git a/website/src/supportedNetworks/customContent/wax-testnet.mdx b/website/src/supportedNetworks/customContent/wax-testnet.mdx
index b1f6ead95e2e..83d43fee86e1 100644
--- a/website/src/supportedNetworks/customContent/wax-testnet.mdx
+++ b/website/src/supportedNetworks/customContent/wax-testnet.mdx
@@ -1,18 +1,26 @@
-### Indexing Data on WAX Testnet
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+## Indexing Data on WAX Testnet
 
 WAX Testnet is the public test network for WAX, an Antelope-based Layer 1 for NFTs, gaming, and collectibles, where teams deploy and validate contracts before mainnet. The Graph can stream that onchain activity — transactions and actions, token transfers and balances, and smart-contract activity — as real-time data with Substreams.
 
 WAX Testnet is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
 
-### Indexing WAX Testnet with Substreams
+---
+
+<ProductSectionHeading
+  product="substreams"
+  id="indexing-wax-testnet-with-substreams"
+  title="Indexing WAX Testnet with Substreams"
+/>
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams WAX Testnet's blocks, transactions, and actions. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on WAX Testnet; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
diff --git a/website/src/supportedNetworks/customContent/wax.mdx b/website/src/supportedNetworks/customContent/wax.mdx
index 4bc5229805c7..155528035e22 100644
--- a/website/src/supportedNetworks/customContent/wax.mdx
+++ b/website/src/supportedNetworks/customContent/wax.mdx
@@ -1,18 +1,22 @@
-### Indexing Data on WAX
+import { ProductSectionHeading } from '@/supportedNetworks/GetApiKeyButton'
+
+## Indexing Data on WAX
 
 WAX is an Antelope-based Layer 1 purpose-built for NFTs, gaming, and digital collectibles. The Graph can stream that onchain activity — transactions and actions, token transfers and balances, and smart-contract activity — as real-time data with Substreams.
 
 WAX is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
 
-### Indexing WAX with Substreams
+---
+
+<ProductSectionHeading product="substreams" id="indexing-wax-with-substreams" title="Indexing WAX with Substreams" />
 
 [Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams WAX's blocks, transactions, and actions. Modules are written in Rust and composed into reusable packages.
 
-#### Find an Existing Module on Substreams.dev
+### Find an Existing Module on Substreams.dev
 
 Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on WAX; if a module fits, you can consume its output directly or import it as a dependency in your own project.
 
-#### Develop Your Own Substreams Module
+### Develop Your Own Substreams Module
 
 If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
 
diff --git a/website/src/supportedNetworks/customContent/worldchain.mdx b/website/src/supportedNetworks/customContent/worldchain.mdx
index 476fb3c23224..a191181225c5 100644
--- a/website/src/supportedNetworks/customContent/worldchain.mdx
+++ b/website/src/supportedNetworks/customContent/worldchain.mdx
@@ -1,6 +1,6 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 
-### Indexing Data on World Chain
+## Indexing Data on World Chain
 
 World Chain is an Ethereum Layer 2 built on the OP Stack and part of the Optimism Superchain, created by the team behind World ID to give verified humans priority access to blockspace. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
 
diff --git a/website/src/supportedNetworks/customContent/xlayer-mainnet.mdx b/website/src/supportedNetworks/customContent/xlayer-mainnet.mdx
index 2d7c861fb948..05d2e108db4a 100644
--- a/website/src/supportedNetworks/customContent/xlayer-mainnet.mdx
+++ b/website/src/supportedNetworks/customContent/xlayer-mainnet.mdx
@@ -1,14 +1,14 @@
 import SubstreamsBase from './_substreams-base.mdx'
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on X Layer
+## Indexing Data on X Layer
 
 X Layer is an Ethereum Layer 2 zkEVM built by OKX on the Polygon CDK, connecting the OKX ecosystem to onchain DeFi, with OKB as its gas token. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
 
 X Layer is supported by The Graph in two ways:
 
-- You can [develop and publish Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/) in Subgraph Studio — publishing is enabled, though guaranteed indexing via The Graph Network is not yet available.
-- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+- **[Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/)**: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers develop, publish, and query their Subgraphs in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/), though guaranteed indexing via The Graph Network is not yet available for X Layer.
+- **[Substreams](/substreams/quick-start/)**: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via [Pinax Network](https://app.pinax.network/docs?from=nav).
 
 <SubgraphStudio
   chainName="X Layer"
diff --git a/website/src/supportedNetworks/customContent/xlayer-sepolia.mdx b/website/src/supportedNetworks/customContent/xlayer-sepolia.mdx
index 6078cf355237..035a7e03297b 100644
--- a/website/src/supportedNetworks/customContent/xlayer-sepolia.mdx
+++ b/website/src/supportedNetworks/customContent/xlayer-sepolia.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on X Layer Sepolia Testnet
+## Indexing Data on X Layer Sepolia Testnet
 
 X Layer Sepolia Testnet is the public test network for X Layer, OKX's Ethereum Layer 2 zkEVM on the Polygon CDK, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/zetachain.mdx b/website/src/supportedNetworks/customContent/zetachain.mdx
index 57281072d82d..ba1d14fdf046 100644
--- a/website/src/supportedNetworks/customContent/zetachain.mdx
+++ b/website/src/supportedNetworks/customContent/zetachain.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on ZetaChain
+## Indexing Data on ZetaChain
 
 ZetaChain is an EVM-compatible Layer 1 built for omnichain applications, letting smart contracts read and write assets and data across connected blockchains, with ZETA as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/zilliqa-testnet.mdx b/website/src/supportedNetworks/customContent/zilliqa-testnet.mdx
index a4323c206081..abf6f2587352 100644
--- a/website/src/supportedNetworks/customContent/zilliqa-testnet.mdx
+++ b/website/src/supportedNetworks/customContent/zilliqa-testnet.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Zilliqa Testnet
+## Indexing Data on Zilliqa Testnet
 
 Zilliqa 2.0 Testnet is the public test network for Zilliqa 2.0, the EVM-compatible sharded Layer 1, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/zilliqa.mdx b/website/src/supportedNetworks/customContent/zilliqa.mdx
index 180e60127bdf..b25043ecb121 100644
--- a/website/src/supportedNetworks/customContent/zilliqa.mdx
+++ b/website/src/supportedNetworks/customContent/zilliqa.mdx
@@ -1,6 +1,6 @@
 import SubgraphStudio from './_subgraph-studio.mdx'
 
-### Indexing Data on Zilliqa
+## Indexing Data on Zilliqa
 
 Zilliqa 2.0 is an EVM-compatible, sharded Layer 1 designed for high throughput, with ZIL as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/zksync-era-sepolia.mdx b/website/src/supportedNetworks/customContent/zksync-era-sepolia.mdx
deleted file mode 100644
index 328ce8af6f27..000000000000
--- a/website/src/supportedNetworks/customContent/zksync-era-sepolia.mdx
+++ /dev/null
@@ -1,15 +0,0 @@
-import SubgraphStudio from './_subgraph-studio.mdx'
-
-### Indexing Data on zkSync Sepolia Testnet
-
-zkSync Sepolia Testnet is the public test network for zkSync Era, the Matter Labs Ethereum Layer 2 zkEVM, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
-
-zkSync Sepolia Testnet is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for zkSync Sepolia Testnet.
-
-<SubgraphStudio
-  chainName="zkSync Sepolia Testnet"
-  networkId="zksync-era-sepolia"
-  slug="zksync-sepolia"
-  explorerUrl="https://sepolia.explorer.zksync.io"
-  explorerName="zkSync Era Explorer"
-/>
diff --git a/website/src/supportedNetworks/customContent/zksync-era.mdx b/website/src/supportedNetworks/customContent/zksync-era.mdx
index a954957edc32..b69df78359a7 100644
--- a/website/src/supportedNetworks/customContent/zksync-era.mdx
+++ b/website/src/supportedNetworks/customContent/zksync-era.mdx
@@ -1,6 +1,6 @@
 import SubgraphCommunity from './_subgraph-community.mdx'
 
-### Indexing Data on zkSync Era
+## Indexing Data on zkSync Era
 
 zkSync Era is an Ethereum Layer 2 zkEVM rollup built by Matter Labs, using zero-knowledge proofs for scalable, low-cost execution with full EVM compatibility. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
 
diff --git a/website/src/supportedNetworks/customContent/zora.mdx b/website/src/supportedNetworks/customContent/zora.mdx
index 68e860654cfe..c6be053599f2 100644
--- a/website/src/supportedNetworks/customContent/zora.mdx
+++ b/website/src/supportedNetworks/customContent/zora.mdx
@@ -1,6 +1,6 @@
 import SubstreamsExtended from './_substreams-extended.mdx'
 
-### Indexing Data on Zora
+## Indexing Data on Zora
 
 Zora is an Ethereum Layer 2 built on the OP Stack and part of the Optimism Superchain, focused on the onchain creator economy — NFTs, creator coins, and media. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.