# Quickstart

> Create an App, call its Gateway, and add an Endpoint for full RPC coverage.

Canonical page: https://rpc.aurpay.net/docs

RPC Gateway gives applications a stable entry point to blockchain networks. Create an App to receive an API Key and Gateway Access Points, then add an Endpoint for full RPC coverage when your application needs it.

## In brief

- Creating an App gives you an API Key and a Gateway for each selected network.
- Every Gateway checks the shared cache by default for supported Endpoint-free RPC reads.
- An Endpoint-backed Route extends the same Access Point to writes, additional methods, and upstream data.

## Before you start

- You have an RPC Gateway account and can sign in to the dashboard.
- Your target chain and network appear under [Networks and hosts](https://rpc.aurpay.net/docs/supported-networks.md).

## Set up access

## Use the Gateway

Create an App and call its Gateway with a supported Endpoint-free RPC read. Every Gateway checks the shared cache by default.

1. **Create an App**

   Open **Apps** in the dashboard, create an App, and select the networks you need. The system creates an API Key and the corresponding Gateways.

   Store the API Key in a secret manager or protected runtime environment. You can view it again, rotate it, or revoke it under **App Settings → Access keys**.

2. **Copy the Access Point**

   Open the App Overview, select the target Gateway, and copy its complete Access Point. For server-side applications, use the Host-only Access Point with the API Key in the `Authorization` header:

   ```bash
   export RPC_URL='https://ether-jsonrpc.<gateway-domain>'
   export APP_API_KEY='<app_api_key>'
   ```

   SDKs that accept a complete RPC URL can use the Access Point that carries the API Key in its first path segment:

   ```text
   https://ether-jsonrpc.<gateway-domain>/<app_api_key>
   ```

3. **Make an Endpoint-free RPC read**

   This Ethereum Mainnet example uses the eligible `eth_blockNumber` method:

   ```bash
   curl "$RPC_URL" \
     -H "Authorization: Bearer $APP_API_KEY" \
     -H 'Content-Type: application/json' \
     --data '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'
   ```

   Example success response:

   ```json
   {"jsonrpc":"2.0","id":1,"result":"0x13a4f20"}
   ```

   Use the exact method and parameter forms listed in [Endpoint-free RPC](https://rpc.aurpay.net/docs/endpoint-free-rpc.md).

## Use with an Endpoint

Use an Endpoint-backed Route for stable upstream coverage, writes, and additional methods. Have a supported Provider credential or a working upstream RPC URL for the target chain, network, and protocol.

1. **Create an App with upstream access**

   Open **Apps** in the dashboard, create an App, and select the networks you need. Associate a Provider during creation to publish its matching synchronized Endpoints to the App's default Gateway Routes.

   You can also open **Endpoints**, add a manual upstream or synchronize a Provider, run its health check, then select the matching Endpoint in the Gateway's default Route.

   The App, Gateway, Endpoint, and Route use the same chain, network, and protocol. Choose priority failover for ordered primary and backup Endpoints, or weighted load balancing for equivalent upstreams.

2. **Copy the Endpoint-backed Access Point**

   Open the App Overview, select the target Gateway, and copy its complete Access Point. Set the Host-only Access Point and API Key for a server-side application:

   ```bash
   export RPC_URL='https://ether-jsonrpc.<gateway-domain>'
   export APP_API_KEY='<app_api_key>'
   ```

3. **Verify the network**

   Use the verification method from the target [chain guide](https://rpc.aurpay.net/docs/chains.md). This Ethereum Mainnet example calls `eth_chainId` through the configured Endpoint:

   ```bash
   curl "$RPC_URL" \
     -H "Authorization: Bearer $APP_API_KEY" \
     -H 'Content-Type: application/json' \
     --data '{"jsonrpc":"2.0","id":2,"method":"eth_chainId","params":[]}'
   ```

   Ethereum Mainnet returns:

   ```json
   {"jsonrpc":"2.0","id":2,"result":"0x1"}
   ```

## Production checklist

- Confirm the network with the target chain guide's verification method.
- For ID-bearing requests, inspect the JSON-RPC Response and branch on `result` or `error` independently of the HTTP status.
- Configure an Endpoint for upstream methods, writes, uncached data, and stable fallback coverage.
- Apply `Retry-After`, exponential backoff, random jitter, and a bounded attempt count to rate-limited requests.
- Use [Retries](https://rpc.aurpay.net/docs/failsafe/retries.md) to understand which failures and operations can move to another Endpoint.
- Keep API Keys in secret storage and use redacted identifiers in logs and support requests.

## Next steps

- [Understand Endpoint-free RPC](https://rpc.aurpay.net/docs/endpoint-free-rpc.md)
- [Choose a chain](https://rpc.aurpay.net/docs/chains.md)
- [Configure Endpoints](https://rpc.aurpay.net/docs/endpoints.md)
- [Protect API Keys](https://rpc.aurpay.net/docs/authentication.md)
- [Handle JSON-RPC](https://rpc.aurpay.net/docs/json-rpc.md)
- [Use the TRON HTTP API](https://rpc.aurpay.net/docs/chains/tron.md#native-http-api)