Nnodevera
API Documentation

nodevera RPC API integration guide

Use nodevera as a managed blockchain access layer for TRON, Ethereum and Solana payment systems. This guide covers onboarding, API key authentication, account endpoints, chain RPC forwarding, signed transaction broadcasting, error handling and production integration practices.

Integration path Copy API Base URL and API Key -> send authenticated backend requests -> monitor usage and errors.
Quick start Access model Account API TRON API Ethereum API Solana API Errors Production checklist
Quick Start

Five minute backend integration

1. Prepare credentialsCopy the API Base URL and API Key from API Access after your account is active.
2. Store secretsKeep the API Key in your backend secret manager or environment variables.
3. Check accountCall /api/me to confirm authentication, plan status, quota and current usage.
4. Test chain RPCSend one TRON, Ethereum or Solana request and verify your application handles the response shape.
# Example smoke test from your backend server
export NODEVERA_BASE_URL="<api_base_url>"
export NODEVERA_API_KEY="<your_api_key>"

curl -sS "$NODEVERA_BASE_URL/api/me" \
  -H "X-API-Key: $NODEVERA_API_KEY"

curl -sS -X POST "$NODEVERA_BASE_URL/eth" \
  -H "content-type: application/json" \
  -H "X-API-Key: $NODEVERA_API_KEY" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'

Authentication

Copy the API Base URL and API Key from the authenticated customer console. Requests are accepted when the API Key is valid, the client is active and the subscription has not expired. Keep the API Key in backend secrets or environment variables only.

X-API-Key: <your_api_key>
Content-Type: application/json
Authorization: Bearer <your_api_key>

Do not expose keys in browsers Calls should come from your backend, queue worker, payment service or wallet service. Browser code and mobile apps can leak API keys.

Security boundary

nodevera forwards signed transaction payloads and chain query requests. Private key management, transaction signing, business risk controls and fund policies stay inside your own backend. Never send private keys, seed phrases or unsigned custody instructions to any nodevera endpoint.

Base URL

Replace <api_base_url> in examples with the private API domain displayed in your API Access page.

<api_base_url>/tron/*
<api_base_url>/eth
<api_base_url>/solana

Request model

nodevera forwards chain requests to configured upstream RPC providers and adds customer-level access control, usage metering and upstream failover behavior. Request bodies are JSON for the common payment workflows; signed transaction payloads must be created by your own system before broadcast.

AreaPathMethodAuthenticationUsage countNotes
Gateway health/healthzGETNoneNoReturns upstream pool metadata and basic service status.
Account status/api/meGETAPI KeyNo chain usageReturns plan, quota, usage and docs URLs.
TRON/tron/<tron_http_path>POST or upstream-compatible methodAPI KeyYesForwards TronGrid-compatible HTTP API paths.
Ethereum/ethPOSTAPI KeyYesStandard Ethereum JSON-RPC over HTTP.
Solana/solanaPOSTAPI KeyYesStandard Solana JSON-RPC over HTTP.

Customer account API

Account endpoints are useful for deployment checks and usage dashboards. They require the same API Key as chain endpoints.

GET /api/me 
curl <api_base_url>/api/me \
  -H 'X-API-Key: <your_api_key>'
{
  "client": {
    "id": "client_1",
    "name": "merchant-a",
    "status": "ACTIVE",
    "plan_id": "growth",
    "monthly_quota": 100000000,
    "qps_limit": 500,
    "usage": {
      "month": "2026-05",
      "requests": 1250,
      "tron_requests": 900,
      "eth_requests": 200,
      "solana_requests": 150
    }
  }
}

TRON HTTP API

TRON uses TronGrid-compatible paths. Append the TronGrid path after /tron. The gateway injects the configured upstream TRON API key when needed, while your customer API Key remains separate.

POST /tron/wallet/getnowblock 
curl -X POST <api_base_url>/tron/wallet/getnowblock \
  -H 'content-type: application/json' \
  -H 'X-API-Key: <your_api_key>' \
  -d '{}'
POST /tron/wallet/gettransactioninfobyid 
curl -X POST <api_base_url>/tron/wallet/gettransactioninfobyid \
  -H 'content-type: application/json' \
  -H 'X-API-Key: <your_api_key>' \
  -d '{"value":"<txid>"}'
POST /tron/wallet/gettransactionbyid 
curl -X POST <api_base_url>/tron/wallet/gettransactionbyid \
  -H 'content-type: application/json' \
  -H 'X-API-Key: <your_api_key>' \
  -d '{"value":"<txid>"}'
POST /tron/wallet/triggersmartcontract 
curl -X POST <api_base_url>/tron/wallet/triggersmartcontract \
  -H 'content-type: application/json' \
  -H 'X-API-Key: <your_api_key>' \
  -d '{
    "owner_address":"<hex_owner_address>",
    "contract_address":"<hex_contract_address>",
    "function_selector":"balanceOf(address)",
    "parameter":"<abi_encoded_parameter>"
  }'
POST /tron/wallet/broadcasttransaction 
curl -X POST <api_base_url>/tron/wallet/broadcasttransaction \
  -H 'content-type: application/json' \
  -H 'X-API-Key: <your_api_key>' \
  -d '<signed_tron_transaction_json>'

Broadcast boundary The gateway broadcasts signed transaction JSON. It does not sign transactions and must never receive private keys.

Ethereum JSON-RPC

Ethereum uses standard JSON-RPC. Send all Ethereum requests to /eth. Standard JSON-RPC request IDs are preserved. Batch requests are forwarded when the upstream provider supports them.

Latest block number 
curl -X POST <api_base_url>/eth \
  -H 'content-type: application/json' \
  -H 'X-API-Key: <your_api_key>' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'
Transaction receipt 
curl -X POST <api_base_url>/eth \
  -H 'content-type: application/json' \
  -H 'X-API-Key: <your_api_key>' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_getTransactionReceipt","params":["0x<tx_hash>"]}'
USDT-ERC20 balance 
curl -X POST <api_base_url>/eth \
  -H 'content-type: application/json' \
  -H 'X-API-Key: <your_api_key>' \
  -d '{
    "jsonrpc":"2.0",
    "id":1,
    "method":"eth_call",
    "params":[
      {
        "to":"0xdAC17F958D2ee523a2206206994597C13D831ec7",
        "data":"0x70a08231000000000000000000000000<20_byte_wallet_without_0x>"
      },
      "latest"
    ]
  }'
Get logs for ERC20 Transfer 
curl -X POST <api_base_url>/eth \
  -H 'content-type: application/json' \
  -H 'X-API-Key: <your_api_key>' \
  -d '{
    "jsonrpc":"2.0",
    "id":1,
    "method":"eth_getLogs",
    "params":[{
      "fromBlock":"0x<from_block>",
      "toBlock":"latest",
      "address":"0xdAC17F958D2ee523a2206206994597C13D831ec7",
      "topics":["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"]
    }]
  }'
Broadcast signed transaction 
curl -X POST <api_base_url>/eth \
  -H 'content-type: application/json' \
  -H 'X-API-Key: <your_api_key>' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_sendRawTransaction","params":["0x<signed_raw_tx>"]}'

Solana JSON-RPC

Solana uses standard JSON-RPC. Send all Solana requests to /solana. For transaction lookup, use jsonParsed encoding when your application needs SPL Token transfer details.

Latest blockhash 
curl -X POST <api_base_url>/solana \
  -H 'content-type: application/json' \
  -H 'X-API-Key: <your_api_key>' \
  -d '{"jsonrpc":"2.0","id":1,"method":"getLatestBlockhash","params":[]}'
Transaction query 
curl -X POST <api_base_url>/solana \
  -H 'content-type: application/json' \
  -H 'X-API-Key: <your_api_key>' \
  -d '{"jsonrpc":"2.0","id":1,"method":"getTransaction","params":["<signature>",{"encoding":"jsonParsed","maxSupportedTransactionVersion":0}]}'
Token account balance 
curl -X POST <api_base_url>/solana \
  -H 'content-type: application/json' \
  -H 'X-API-Key: <your_api_key>' \
  -d '{"jsonrpc":"2.0","id":1,"method":"getTokenAccountBalance","params":["<token_account>"]}'
Signature status 
curl -X POST <api_base_url>/solana \
  -H 'content-type: application/json' \
  -H 'X-API-Key: <your_api_key>' \
  -d '{"jsonrpc":"2.0","id":1,"method":"getSignatureStatuses","params":[["<signature>"],{"searchTransactionHistory":true}]}'
Broadcast signed transaction 
curl -X POST <api_base_url>/solana \
  -H 'content-type: application/json' \
  -H 'X-API-Key: <your_api_key>' \
  -d '{"jsonrpc":"2.0","id":1,"method":"sendTransaction","params":["<base64_or_base58_signed_tx>"]}'

Language examples

Any HTTP client works. Keep credentials in backend configuration and retry only idempotent read requests unless your business logic explicitly permits retry.

// Node.js 18+
const res = await fetch(`${process.env.NODEVERA_BASE_URL}/eth`, {
  method: "POST",
  headers: {
    "content-type": "application/json",
    "X-API-Key": process.env.NODEVERA_API_KEY
  },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "eth_blockNumber",
    params: []
  })
});
console.log(await res.json());
// Go
req, _ := http.NewRequest("POST", os.Getenv("NODEVERA_BASE_URL")+"/solana", bytes.NewReader(body))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-API-Key", os.Getenv("NODEVERA_API_KEY"))
resp, err := http.DefaultClient.Do(req)

Retry and idempotency

Read requestsRetry temporary network failures with short backoff, but keep total timeout bounded.
Broadcast requestsDo not retry blindly. Query by transaction hash or signature first when the previous broadcast result is unknown.
Duplicate txidsYour business system should treat txid or signature processing as idempotent.

Usage and quota

Every TRON, Ethereum and Solana request is counted per customer. Account endpoints do not consume chain quota. Exceeding the monthly plan quota returns 429.

Monthly quotaUsage resets by calendar month as tracked by the gateway.
API keyThe same customer API Key authenticates TRON, Ethereum, Solana and account endpoints.
Upstream limitsWhen an upstream provider rate-limits a route, the gateway can try another configured upstream before returning an error.

Common errors

400Request body is invalid, unreadable or exceeds the configured gateway body limit.
401API key is missing, invalid or sent through the wrong header.
403API key is disabled or the subscription has expired.
405Ethereum and Solana JSON-RPC require POST.
408Request was canceled while waiting for upstream quota.
429Monthly request quota is exhausted or an upstream route is throttled.
502All configured upstream RPC providers failed or returned retryable errors.

Production checklist

  • Call nodevera from backend services, queue workers or payment services instead of browser code.
  • Store API Keys in secret managers or environment variables, not source code.
  • Use HTTPS API Base URL in production and set HTTP client timeouts.
  • Build idempotency around txid or signature processing to avoid double crediting.
  • Do not retry broadcast blindly. Confirm whether the signed transaction already reached the chain.
  • Track 401, 403, 429 and 502 separately in your monitoring.
  • Review traffic growth before increasing concurrency, batch size or polling frequency.