# Choose a data service

Source: https://docs.graphops.xyz/choose-a-service

Pick the service that returns the data your application needs in the shape it can use, with the
least state for you to maintain. Start from the job, check what each service leaves to you, then
run that service's quickstart.

## Match your need to a service

| If you need to… | Start with | Why |
| --- | --- | --- |
| Read contract state or balances now | [RPC](/rpc) | It exposes native EVM node methods without an indexing layer. |
| Submit transactions | [RPC](/rpc) | Transaction submission is part of the JSON-RPC interface. |
| Query an existing entity schema through GraphQL | [Subgraphs](/subgraphs) | Query indexed entities without building the indexing pipeline yourself. |
| Process every block or event in order | [Substreams](/substreams) | It streams deterministic package output with cursors and undo signals. |
| Backfill a stream into your own database | [Substreams](/substreams) | Your consumer can replay ranges and materialize the result it needs. |

## What GraphOps runs and what you own

_Every service shares organization API keys, metering and credits. The difference is how much state you keep: RPC leaves composition and history to you, Subgraphs keeps an indexed view for you, and Substreams hands you an ordered stream to store yourself._

| Service | GraphOps runs | You own |
| --- | --- | --- |
| RPC | Nodes behind authenticated endpoints; HTTPS and WebSocket transports | Call composition and retries; Block references for related reads; Any history you index |
| Subgraphs | GraphQL endpoints and indexing; Managed Subgraphs and Endpoint Aliases | The Subgraph you select; Queries and page sizes; Upgrade timing |
| Substreams | gRPC stream endpoints; Package execution, including history | Package choice and version; Cursor persistence and undo handling; Your destination database |

## How the services differ

| Concern            | RPC                                        | Subgraphs                                      | Substreams                                               |
| ------------------ | ------------------------------------------ | ---------------------------------------------- | -------------------------------------------------------- |
| Interface          | EVM JSON-RPC over HTTPS and WebSocket.     | GraphQL over HTTPS.                            | gRPC streams with cursors.                               |
| Data shape         | Node request and response objects.         | GraphQL entities defined by a Subgraph schema. | Block-scoped module output.                              |
| Freshness          | Chain head and explicit block references.  | Subgraph indexing progress.                    | Selected start and stop blocks and finality mode.        |
| Long-running state | Your application polls or subscribes.      | GraphOps keeps the indexed Subgraph view.      | Your consumer materializes state.                        |
| Recovery           | Retry against an explicit block reference. | Inspect `_meta` and indexing status.           | Resume from a committed cursor and process undo signals. |

## Subgraphs or Substreams

Both give you indexed onchain data, but they leave different work to you. Choose
Subgraphs when your application queries entities over GraphQL and you want
GraphOps to keep the indexed view; you check its freshness with `_meta`. Choose
Substreams when your consumer must process every relevant block in order and
store the result in your own database; you persist the cursor and handle undo signals.

## Combine services

One product often uses more than one service. One API key can include every service your
application uses, and all of them draw from your organization's credit balance.

* **Wallet or dapp:** Subgraphs for read-heavy views such as balances and history, and RPC to
submit transactions and read the latest contract state.
* **Analytics backend:** Substreams to backfill and stream events into your database, and RPC for
occasional point reads at a specific block.
* **Trading or monitoring bot:** RPC WebSocket subscriptions for new blocks and logs, with a
Subgraph for indexed context.

When a workload could fit more than one service, start with the smallest interface that completes
the job: RPC for direct node calls, Subgraphs for an existing GraphQL entity model, and Substreams
when you need an ordered data pipeline. If you are still unsure,
[ask GraphOps support](https://platform.graphops.xyz/organizations/current/overview?support=open)
with a short description of the workload.

## Discover the APIs from code

Tools and agents can read the [API catalog](https://graphops.xyz/.well-known/api-catalog), a
standard [RFC 9727](https://www.rfc-editor.org/rfc/rfc9727) list of each service's endpoint,
machine-readable description, and documentation. RPC and Subgraphs each serve an OpenAPI document
at `/openapi.json` on their endpoint origin, such as `https://rpc.graphops.xyz/openapi.json`.
Substreams links the gRPC service definitions of the
[API versions](/substreams/api#api-versions) it serves.

## Next steps

* [Start building](/get-started): Create your account and API key before running a quickstart.
* [Make an RPC request](/rpc/getting-started): Read the latest Ethereum block number.
* [Query a Subgraph](/subgraphs/getting-started): Read indexed entities from an existing Subgraph.
* [Stream five blocks](/substreams/getting-started): Run a standard package through the Substreams CLI.