---
title: Quick Start
---

Create, deploy, and query a [Subgraph](/subgraphs/developing/developer-faq/#1-what-is-a-subgraph) on The Graph Network.

By the end, you'll have:

- Initialized a Subgraph from a smart contract
- Deployed it to Subgraph Studio for testing
- Published to The Graph Network for decentralized indexing using Studio or CLI

## Prerequisites

- A crypto wallet
- A deployed smart contract on a [supported network](/supported-networks/)
- [Node.js](https://nodejs.org/) & a package manager of your choice (`npm`, `yarn` or `pnpm`)

## How to Build a Subgraph

### 1. Create a Subgraph in Subgraph Studio

1. Go to [Subgraph Studio](https://thegraph.com/studio/)
2. Connect your wallet
3. Click "Create a Subgraph"
4. Name it in Title Case: "Subgraph Name Chain Name"

### 2. Install the Graph CLI

On your local machine, run one of the following commands:

Using [npm](https://www.npmjs.com/):

```sh
npm install -g @graphprotocol/graph-cli@latest
```

Using [yarn](https://yarnpkg.com/):

```sh
yarn global add @graphprotocol/graph-cli
```

Verify install:

```sh
graph --version
```

### 3. Initialize your Subgraph

> You can find commands for your specific Subgraph in [Subgraph Studio](https://thegraph.com/studio/).

Initialize your Subgraph from an existing contract:

```sh
graph init
```

When you initialize your Subgraph, the CLI will ask you for the following information:

- **Protocol**: Choose the protocol your Subgraph will be indexing data from.
- **Subgraph slug**: Create a name for your Subgraph. Your Subgraph slug is an identifier for your Subgraph.
- **Directory**: Choose a directory to create your Subgraph in.
- **Ethereum network** (optional): You may need to specify which EVM-compatible network your Subgraph will be indexing data from.
- **Contract address**: Locate the smart contract address you'd like to query data from.
- **ABI**: If the ABI is not auto-populated, you will need to input it manually as a JSON file.
- **Start Block**: You should input the start block where the contract was deployed to optimize Subgraph indexing of blockchain data.
- **Contract Name**: Input the name of your contract.
- **Index contract events as entities**: It is suggested that you set this to true, as it will automatically add mappings to your Subgraph for every emitted event.
- **Add another contract** (optional): You can add another contract.

See the following screenshot for an example of what to expect when initializing your Subgraph:

![Subgraph command](/img/CLI-Example.png)

### 4. Edit your Subgraph

When making changes to the Subgraph, you will primarily work with three files:

- Manifest (`subgraph.yaml`): Defines what data sources your Subgraph will index.
- Schema (`schema.graphql`): Defines what data you wish to retrieve from the Subgraph.
- AssemblyScript Mappings (`mapping.ts`): Translates data from your data sources to the entities defined in the schema.

For a detailed breakdown on how to write your Subgraph, refer to [Creating a Subgraph](/subgraphs/developing/creating/starting-your-subgraph/).

## Path 1: Studio Approach

### 5. Build your Subgraph

Run the following:

```sh
graph codegen && graph build
```

### 6. Deploy your Subgraph to Subgraph Studio

When you **deploy** a Subgraph, you push it to [Subgraph Studio](https://thegraph.com/studio/), where you can test, stage and review it. A deployed Subgraph's indexing is performed by the [Upgrade Indexer](https://thegraph.com/blog/upgrade-indexer/), which is a single Indexer owned and operated by Edge & Node. A **deployed** Subgraph is free to use, rate-limited, not visible to the public, and meant to be used for development, staging, and testing purposes.

> [!IMPORTANT] You do not need to use Subgraph Studio to publish your Subgraph to The Graph Network. Studio is only required for testing and staging your Subgraph prior to publishing.

1. Get your deploy key from the Subgraph page in Studio

![Deploy key](/img/subgraph-studio-deploy-key.jpg)

2. Authenticate:

```sh

graph auth <DEPLOY_KEY>
```

3. Deploy:

```sh
graph deploy <SUBGRAPH_SLUG>
```

### 7. Review in Studio

Use the Studio to:

- Run a sample query.
- Analyze your Subgraph in the dashboard to check information.
- Check the logs on the dashboard to see if there are any errors with your Subgraph. The logs of an operational Subgraph will look like this:

  ![Subgraph logs](/img/subgraph-logs-image.png)

### 8. Publish to The Graph Network

When your Subgraph is ready for a production environment, you can publish it to the decentralized network. Publishing is an onchain action that does the following:

- It makes your Subgraph available to be indexed by the decentralized [Indexers](/indexing/overview/) on The Graph Network.
- It removes rate limits and makes your Subgraph publicly searchable and queryable in [Graph Explorer](https://thegraph.com/explorer/).
- It makes your Subgraph available for [Curators](/resources/roles/curating/) to add curation signal.

1. Click **Publish** in Studio
2. Select network
3. (Recommended) Add curation during the same transaction to save on gas costs: ![Subgraph publish](/img/studio-publish-modal.png)

![Publish a Subgraph on Subgraph Studio](/img/publish-sub-transfer.png)

> Curation with 3,000+ GRT is recommended to incentivize indexing.

## Path 2: CLI Approach

1. Open the `graph-cli`.
2. Run the following commands to build and publish your Subgraph: `graph codegen && graph build` then `graph publish`.
3. A browser window will prompt you to connect your wallet, add metadata, and publish your Subgraph to the network of your choice.

![cli-ui](/img/cli-ui.png)

### Custom Options

You can customize the deployment by uploading to a specific IPFS node and using additional flags:

```
USAGE
  $ graph publish [SUBGRAPH-MANIFEST] [-h] [--protocol-network arbitrum-one|arbitrum-sepolia --subgraph-id <value>] [-i <value>] [--ipfs-hash <value>] [--webapp-url
    <value>]

FLAGS
  -h, --help                   Show CLI help.
  -i, --ipfs=<value>           [default: https://ipfs.thegraph.com/api/v0] Upload build results to an IPFS node.
  --ipfs-hash=<value>          IPFS hash of the subgraph manifest to deploy.
  --protocol-network=<option>  [default: arbitrum-one] The network to use for the subgraph deployment.
                               <options: arbitrum-one|arbitrum-sepolia>
  --subgraph-id=<value>        Subgraph ID to publish to.
  --webapp-url=<value>         [default: https://cli.thegraph.com/publish] URL of the web UI you want to use to deploy.

```

> [!NOTE] Add GRT signal to your Subgraph to incentivize Indexers to query your Subgraph. Refer to [Adding Signal](developing/publishing/publishing-a-subgraph/#adding-signal-to-your-subgraph) for specifics.

### Final Step: Query your Subgraph

After publishing, access your Subgraph's Query URL from [Graph Explorer](https://thegraph.com/explorer/). You can query your Subgraph by sending GraphQL queries to its Query URL, which you can find by clicking the Query button.

You get access to 100,000 free queries/month with your Subgraph on The Graph Network.

Refer to [Querying The Graph](/subgraphs/querying/introduction/) to structure GraphQL queries.
