Documentation

Everything you need to integrate with ARGUS infrastructure.

ARGUS is a high-performance Solana RPC and WebSocket node optimized for ultra-low latency. It is fully compatible with the standard Solana JSON-RPC specification, so you can use it as a drop-in replacement for any existing RPC provider.

This documentation covers connection setup, authentication, available methods, WebSocket subscriptions, token staking for access tiers, and the full API reference.

NOTE

ARGUS endpoints are fully compatible with @solana/web3.js, anchor, and any Solana tooling that accepts an RPC URL.

Quickstart

Get connected in under a minute. Replace your existing RPC URL with the ARGUS endpoint.

1. Install dependencies

                            
bash
npm install @solana/web3.js

2. Connect to ARGUS

                            
                            
                            
                        
typescript
import { Connection } from '@solana/web3.js';

// Public endpoint (Observer tier)
const connection = new Connection(
  'https://rpc.argus.network',
  'confirmed'
);

// Authenticated endpoint (Watcher+ tiers)
const authConnection = new Connection(
  'https://rpc.argus.network',
  {
    commitment: 'confirmed',
    httpHeaders: {
      'Authorization': 'Bearer YOUR_API_KEY'
    }
  }
);

3. Make your first request

                            
typescript
const slot = await connection.getSlot();
console.log('Current slot:', slot);

const balance = await connection.getBalance(publicKey);
console.log('Balance:', balance / 1e9, 'SOL');

Authentication

Public endpoints (Observer tier) do not require authentication. For staked access tiers, ARGUS uses API key-based authentication.

Obtaining an API key

Stake ARGUS tokens to your desired tier
Connect your wallet to the ARGUS dashboard
Generate an API key linked to your stake
Include the key in your request headers

Using your API key

Pass your API key in the Authorization header on every request:

                            
                            
                            
                        
http
POST https://rpc.argus.network HTTP/1.1
Content-Type: application/json
Authorization: Bearer argus_sk_1a2b3c4d5e6f...

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getSlot"
}

WARNING

Never expose your API key in client-side code. Use environment variables and server-side proxies for browser applications.

RPC Endpoints

ARGUS provides separate endpoints for mainnet and devnet.

Network	Endpoint	Status
Mainnet	`https://rpc.argus.network`	Live
Devnet	`https://devnet.rpc.argus.network`	Live

All endpoints support both HTTP POST and WebSocket connections. The RPC interface follows the Solana JSON-RPC specification.

RPC Methods

ARGUS supports all standard Solana RPC methods. Below are the most commonly used methods with examples.

getSlot

Returns the slot that has reached the given or default commitment level.

POST https://rpc.argus.network

                            
                            
                            
                        
json // request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getSlot"
}

                            
                            
                            
                        
json // response
{
  "jsonrpc": "2.0",
  "result": 285462871,
  "id": 1
}

getBalance

Returns the lamport balance of the account at the provided public key.

POST https://rpc.argus.network

pubkey string required Base-58 encoded public key of the account to query.
commitment string Commitment level: processed, confirmed, or finalized.

                            
                            
                            
                        
json // request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getBalance",
  "params": [
    "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin"
  ]
}

getTransaction

Returns transaction details for a confirmed transaction signature.

signature string required Transaction signature as a base-58 encoded string.
encoding string Encoding for returned transaction data: json, jsonParsed, base58, base64.
maxSupportedTransactionVersion number Maximum transaction version to return. Set to 0 for versioned transactions.

sendTransaction

Submits a signed transaction to the cluster for processing. ARGUS optimizes transaction forwarding for minimal propagation latency.

transaction string required Fully signed transaction as a base-64 encoded string.
skipPreflight boolean Skip preflight transaction checks. Default: false.
maxRetries number Maximum number of times the node retries sending the transaction to the leader.

TIP

For time-sensitive transactions (MEV, arbitrage), use skipPreflight: true combined with a higher access tier for optimal landing rates.

Rate Limits

Rate limits are determined by your access tier. Exceeding your limit returns HTTP 429 Too Many Requests.

Tier	Requests / sec	WebSocket streams	Burst
Observer	10	2	--
Watcher	100	10	200
Oracle	500	50	1,000
Titan	Unlimited	Unlimited	Unlimited

Rate limit headers are included in every response:

                            
http // response headers
X-RateLimit-Limit: 100
X-RateLimit-Remaining: 87
X-RateLimit-Reset: 1706832000

WebSocket Connection

ARGUS provides dedicated WebSocket endpoints for real-time data streaming with minimal latency.

WSS wss://ws.argus.network

                            
                            
                            
                        
typescript
import { Connection } from '@solana/web3.js';

const connection = new Connection(
  'https://rpc.argus.network',
  {
    commitment: 'confirmed',
    wsEndpoint: 'wss://ws.argus.network',
    httpHeaders: {
      'Authorization': 'Bearer YOUR_API_KEY'
    }
  }
);

For raw WebSocket connections without the Solana SDK:

                            
                            
                            
                        
javascript
const ws = new WebSocket('wss://ws.argus.network');

ws.onopen = () => {
  ws.send(JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'slotSubscribe'
  }));
};

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  console.log('Slot update:', data);
};

WebSocket Subscriptions

Available subscription methods for real-time streaming:

Method	Description	Min Tier
`accountSubscribe`	Subscribe to account data changes	Observer
`logsSubscribe`	Subscribe to transaction logs	Observer
`programSubscribe`	Subscribe to program-owned account changes	Watcher
`signatureSubscribe`	Subscribe to transaction signature status	Observer
`slotSubscribe`	Subscribe to slot updates	Observer
`rootSubscribe`	Subscribe to root slot changes	Watcher
`blockSubscribe`	Subscribe to new blocks (full block data)	Oracle

accountSubscribe example

                            
                            
                            
                        
typescript
const subId = connection.onAccountChange(
  publicKey,
  (accountInfo, context) => {
    console.log('Account changed at slot', context.slot);
    console.log('Data:', accountInfo.data);
  },
  'confirmed'
);

// Unsubscribe when done
await connection.removeAccountChangeListener(subId);

Staking

Staking ARGUS tokens is the primary mechanism for unlocking higher access tiers. Your stake determines your API key's capabilities.

How staking works

Acquire ARGUS tokens on a supported DEX
Connect your wallet to the ARGUS staking dashboard
Select your target tier and stake the required amount
Generate an API key linked to your stake position
Use the API key in your application's RPC configuration

Your tier is determined by the amount staked. Unstaking initiates a cooldown period during which your tier remains active.

NOTE

Staking is non-custodial. Your tokens remain in a smart contract that you control. You can unstake at any time (subject to the cooldown period).

Access Tiers

Each tier provides progressively better infrastructure access. Tiers are named after the mythology of ARGUS.

Tier	Stake Required	Latency	Features
Observer	None	Standard	Public RPC, basic WebSocket, community support
Watcher	Tier 1	Reduced	Private endpoints, higher limits, priority queue
Oracle	Tier 2	Low	Priority routing, dedicated support, advanced subscriptions
Titan	Tier 3	Lowest	Unlimited throughput, custom routing, SLA, direct node access

Pay-per-Request

For applications that need occasional burst capacity without maintaining a permanent stake, ARGUS offers a pay-per-request model.

Deposit ARGUS tokens into a prepaid balance
Each request above your tier's free limit deducts from the balance
Burst pricing is tiered: the more you use, the lower the per-request cost
Balance can be topped up at any time

This is useful for event-driven workloads, periodic batch processing, or testing higher throughput before committing to a higher staking tier.

API Reference

Complete list of supported Solana JSON-RPC methods. All methods follow the standard Solana specification.

Account methods

Method	Description
`getAccountInfo`	Returns all account data for the specified public key
`getBalance`	Returns lamport balance
`getMultipleAccounts`	Returns account data for a list of public keys
`getProgramAccounts`	Returns all accounts owned by a program
`getTokenAccountBalance`	Returns SPL token balance
`getTokenAccountsByOwner`	Returns all SPL token accounts owned by an address

Block and slot methods

Method	Description
`getBlock`	Returns complete block information
`getBlockHeight`	Returns current block height
`getBlockTime`	Returns estimated production time of a block
`getSlot`	Returns current slot
`getSlotLeader`	Returns the current slot leader

Transaction methods

Method	Description
`getTransaction`	Returns transaction details for a confirmed signature
`getSignaturesForAddress`	Returns confirmed signatures for an address
`getSignatureStatuses`	Returns statuses for a list of signatures
`sendTransaction`	Submits a signed transaction
`simulateTransaction`	Simulates a transaction without submitting
`getRecentBlockhash`	Returns a recent blockhash
`getLatestBlockhash`	Returns the latest blockhash

Network methods

Method	Description
`getHealth`	Returns node health status
`getVersion`	Returns Solana version running on the node
`getEpochInfo`	Returns information about the current epoch
`getSupply`	Returns current supply information
`getMinimumBalanceForRentExemption`	Returns minimum lamports for rent exemption

Error Codes

ARGUS returns standard JSON-RPC error codes along with additional HTTP status codes for access control.

Code	HTTP Status	Description
`-32600`	400	Invalid request. Malformed JSON or missing required fields.
`-32601`	400	Method not found. The requested method does not exist.
`-32602`	400	Invalid params. Incorrect parameter types or values.
`-32603`	500	Internal error. Unexpected server-side failure.
--	401	Unauthorized. Missing or invalid API key.
--	403	Forbidden. Your tier does not have access to this resource.
--	429	Rate limited. You have exceeded your tier's request limit.

Changelog

v1.0.0 — Node Launch

Core RPC endpoint live on mainnet
WebSocket endpoint for real-time subscriptions
Public (Observer) tier available
Full Solana JSON-RPC spec compatibility

v1.1.0 — Token Integration

ARGUS token deployed
Staking contract live
API key generation linked to stake
Watcher and Oracle tiers activated

v1.2.0 — Coming Soon

Titan tier with custom routing
Pay-per-request billing
Governance portal
Archival node support