GravixRPC

RPC · WSS · gRPC

Dependable endpoints for RPC, WSS and gRPC.

Choose a fixed monthly plan, create endpoints in the console, and authenticate with an API key. Three protocols, three plans, nothing else to configure first.

Explore endpoints

Endpoint format

RPC
https://{host}/v1/{id}
WSS
wss://{host}/v1/{id}
gRPC
{id}.{host}:443
Sample session
curl -s $GRAVIX_ENDPOINT -H "x-api-key: $GRAVIX_API_KEY" -d @call.json
HTTP/2 200
content-type: application/json
{"jsonrpc":"2.0","id":1,"result": …}

request / response

illustrative · not a live call

Request path · simplified

Diagram

  1. 01

    Your client

    any language

  2. 02

    TLS

    https · wss · h2

  3. 03

    Key check

    x-api-key

  4. 04

    Your endpoint

    RPC · WSS · gRPC

[01]Services

Three ways in. Use whichever the job needs.

RPC

spec

Request/response calls over HTTPS. The default choice for reads, writes and batch jobs.

transport
JSON-RPC over HTTPS
endpoint
https://{host}/v1/{id}
auth
x-api-key header
model
request / response

Good for

  • Reads and writes from backends and scripts
  • Batch jobs and indexers
  • Anything that fits request/response

POST JSON-RPC 2.0 over HTTPS to your endpoint URL.

WSS

spec

A persistent, bidirectional socket for subscriptions and push-style updates.

transport
WebSocket (TLS)
endpoint
wss://{host}/v1/{id}
auth
x-api-key header on the handshake
model
persistent socket

Good for

  • Subscriptions and live feeds
  • Dashboards and bots that react to events
  • Avoiding polling loops

Open a TLS WebSocket to your endpoint URL and send JSON-RPC messages.

gRPC

spec

Typed, streaming-capable calls over HTTP/2 for high-throughput backends.

transport
gRPC over HTTP/2 (TLS)
endpoint
{id}.{host}:443
auth
x-api-key request metadata
model
HTTP/2 stream

Good for

  • Typed service-to-service calls
  • Server-streaming workloads
  • High-throughput backends over HTTP/2

Dial your endpoint host on port 443 with TLS and call your generated client.

Supported networks aren’t listed yet — they’ll be published here once confirmed, rather than implied.

[02]Console

Everything you provision, in one place.

Create RPC, WSS and gRPC endpoints, issue and revoke API keys, see your plan’s req/s, connection and stream limits, and check billing. Usage charts appear when the metering feed is connected.

  • Endpoints per protocol, with copyable URLs
  • API keys shown once, stored hashed
  • Account activity log

Sample data for illustration. Your console shows only what you’ve created.

[03]Pricing

Fixed monthly plans. The difference is throughput, connections and streams.

All plans include RPC, WSS and gRPC. Prices are in US dollars, billed per month.

Pro

$50 /month

RPC throughput
10 req/s
WebSocket connections
1 connection
gRPC streams
1 stream

UltraMost chosen

$100 /month

RPC throughput
20 req/s
WebSocket connections
2 connections
gRPC streams
2 streams

Max

$200 /month

RPC throughput
50 req/s
WebSocket connections
5 connections
gRPC streams
5 streams
Not published yet

These aren’t stated on any plan until they’re confirmed, so we don’t imply them:

  • Monthly data / bandwidth allowances, if any
  • Per-method rate limits within the req/s budget
  • Overage rules
  • Supported networks and chains
  • Annual billing and any annual discount
  • Uptime SLA and support response terms
  • Production gateway hostname and final credential header names

[04]How to connect

From signup to first request in five steps.

  1. 1

    Create an account

    Sign up with your email and confirm the 6-digit code.

  2. 2

    Choose a plan

    Pick Pro, Ultra or Max and complete payment. Access starts once payment is confirmed.

  3. 3

    Create an endpoint and key

    In the console, add an RPC, WSS or gRPC endpoint and generate an API key.

  4. 4

    Connect

    Use the endpoint URL with your key in the x-api-key header.

  5. 5

    Test and monitor

    Send a request, then review your endpoints and account activity.

JSON-RPC over HTTPS · curl
curl https://rpc.gravixrpc.example/v1/YOUR_ENDPOINT_ID \
  -H "content-type: application/json" \
  -H "x-api-key: $GRAVIX_API_KEY" \
  -d '{"jsonrpc":"2.0","id":1,"method":"YOUR_METHOD","params":[]}'

Illustrative: replace YOUR_ENDPOINT_ID, the method name and the host with the values shown in your console. The host above is a placeholder. Keep keys in environment variables, never in client-side code.

[05]Security and operations

What we do today, stated plainly.

Passwordless sign-in
Email codes are stored hashed, expire after 10 minutes, are rate-limited and lock after repeated wrong attempts. Sessions use HttpOnly cookies.
API keys shown once
A new key’s secret is displayed a single time. We store only a hash, and you can revoke a key at any time.
Payment confirmed server-side
Access is granted only when the payment provider’s signed webhook reaches our server. Browser redirects never activate a plan.
Limits follow your plan
Your req/s, WebSocket connection and gRPC stream limits are defined by the plan you’ve paid for and shown in your console.
Account activity log
Key, endpoint, plan and payment changes are recorded and visible in your console.

We don’t publish uptime figures, an SLA, or compliance certifications here because none have been confirmed yet.

[06]FAQ & docs

Questions, answered.

Connection examples are in How to connect.

What’s the difference between RPC, WSS and gRPC?

RPC is request/response over HTTPS. WSS keeps a WebSocket open for subscriptions and pushed updates. gRPC uses HTTP/2 for typed calls and streaming. Every plan includes all three.

How do I authenticate?

Create an API key in the console and send it as the x-api-key header (request metadata for gRPC). The secret is shown once when created, so store it in an environment variable.

What does each plan include?

Pro: 10 req/s RPC, 1 WebSocket connection and 1 gRPC stream. Ultra: 20 req/s, 2 connections, 2 streams. Max: 50 req/s, 5 connections, 5 streams. Bandwidth and per-method limits aren’t published yet.

How does billing work?

Plans are billed monthly in US dollars. A plan activates once the payment provider confirms payment to our server; a redirect alone never grants access.

How do coupons work?

Enter a code during sign-up. Our server validates it and calculates the discount; the plan comparison then shows the original price, the discounted price and what it renews at. A coupon is single use and takes its value off the first month of any plan, up to that plan’s price; a coupon worth the plan’s price makes the first month free, with no card needed.

I didn’t get my verification code.

Check spam, make sure the address is right, then use Resend after the short cooldown. Codes expire after 10 minutes.

My request is rejected. What should I check?

Confirm the endpoint is active, the key hasn’t been revoked, the key is sent in x-api-key, and you’re using the URL shown in your console.

Which networks are supported?

That hasn’t been confirmed for this site yet, so we don’t list any. It will appear here and in the console when it is.