Tools of the Trade - Data Sources and Platforms

URL: https://xrpscan.com" target="_blank" rel="noopener noreferrer" class="text-cyan-400 hover:text-cyan-300 underline hover:no-underline transition-colors inline-flex items-center gap-1">https://xrpscan.com">https://xrpscan.com

XRPSCAN is the most comprehensive XRPL block explorer, offering deep functionality beyond basic lookups.

Core Features:

• Search by hash, account, or ledger

• Full transaction details including metadata

• Payment pathway visualization

• Success/failure status and codes

• Balance and reserve breakdown

• Transaction history with filters

• Owned objects (offers, escrows, trust lines)

• Account settings and flags

• "Rich list" ranking position

• Network topology and validators

• Transaction volume statistics

• Ledger close times

• Fee distribution

• Known address tagging (exchanges, Ripple, etc.)

• Escrow tracker for Ripple releases

• Amendment status

• Token explorer for issued assets

Analytical Applications:

Use Case	XRPSCAN Feature	How to Access
Look up specific transaction	Search bar	Enter hash
View address balance/history	Account page	Enter address
Track known whales	Account with tags	Rich list or direct lookup
Monitor escrow releases	Escrow tracker	Menu → Escrow
Explore token ecosystem	Token explorer	Menu → Tokens
Check network health	Metrics dashboard	Menu → Network

• Comprehensive data coverage

• Clean, professional interface

• Excellent address tagging

• Free and accessible

• Regular updates

• No API (web interface only)

• Limited historical export options

• Can't perform custom aggregations

• No alerts or monitoring features

Analyst Tip: Use XRPSCAN as your primary exploration tool. Before building custom analysis, always check if XRPSCAN already shows what you need.

URL: https://bithomp.com" target="_blank" rel="noopener noreferrer" class="text-cyan-400 hover:text-cyan-300 underline hover:no-underline transition-colors inline-flex items-center gap-1">https://bithomp.com">https://bithomp.com

Bithomp offers complementary features with particular strength in address-focused analysis.

Core Features:

• Detailed address pages

• Username registration system (usernames for addresses)

• QR code generation

• Activity visualizations

• Top XRP holders ranked

• Filtering by various criteria

• Historical comparison (limited)

• Basic transaction details

• Payment tracking

• Less detailed than XRPSCAN

• XRPL username system

• Address alerts (paid feature)

• Portfolio tracking tools

• Mobile app

Analytical Applications:

Use Case	Bithomp Feature	Notes
Rich list browsing	Rich list page	Good for whale identification
Address deep dive	Account pages	Clear activity presentation
Portfolio tracking	Portfolio tools	For tracking your own holdings
Address alerts	Paid subscription	Get notified of movements

• Excellent rich list functionality

• Clean address presentation

• Username system aids identification

• Mobile accessibility

• Less comprehensive than XRPSCAN

• Some features require subscription

• Less detailed transaction analysis

URL: https://xrplorer.com" target="_blank" rel="noopener noreferrer" class="text-cyan-400 hover:text-cyan-300 underline hover:no-underline transition-colors inline-flex items-center gap-1">https://xrplorer.com">https://xrplorer.com

XRPLorer focuses on network-level analysis and forensic capabilities.

Core Features:

• Transaction path tracing

• Fund flow visualization

• Multi-hop payment analysis

• Validator monitoring

• Network topology

• Amendment tracking

• Issued asset tracking

• Gateway analysis

• Token holder distribution

• Tracing funds through multiple hops

• Investigating complex transaction paths

• Network-level research

• Token/IOU analysis

Feature	XRPSCAN	Bithomp	XRPLorer	Livenet
Transaction lookup	⭐⭐⭐	⭐⭐	⭐⭐	⭐⭐
Address analysis	⭐⭐⭐	⭐⭐⭐	⭐⭐	⭐
Rich list	⭐⭐⭐	⭐⭐⭐	⭐	—
Network metrics	⭐⭐⭐	⭐	⭐⭐⭐	⭐⭐
Known addresses	⭐⭐⭐	⭐⭐	⭐⭐	—
Token analysis	⭐⭐	⭐	⭐⭐⭐	⭐
Forensics	⭐⭐	⭐	⭐⭐⭐	⭐
API access	—	Limited	—	—

---

The XRP Ledger is queried directly through rippled servers using WebSocket or JSON-RPC:

Public Endpoints:

MAINNET (Production):
wss://xrplcluster.com - Cluster of public servers
wss://s1.ripple.com - Ripple-operated
wss://s2.ripple.com - Ripple-operated
wss://xrpl.ws - Community operated

TESTNET (Testing):
wss://s.altnet.rippletest.net:51233

DEVNET (Development):
wss://s.devnet.rippletest.net:51233

Connection Methods:

// WebSocket (JavaScript example)
const WebSocket = require('ws');
const ws = new WebSocket('wss://xrplcluster.com');

ws.on('open', function() {
  const request = {
    command: 'account_info',
    account: 'rN7n3473SaZBCG4dFL83w7...',
    ledger_index: 'validated'
  };
  ws.send(JSON.stringify(request));
});

ws.on('message', function(data) {
  console.log(JSON.parse(data));
});

# Python example using xrpl-py library
from xrpl.clients import JsonRpcClient
from xrpl.models import AccountInfo

client = JsonRpcClient("https://s1.ripple.com:51234/") 
request = AccountInfo(account="rN7n3473SaZBCG4dFL83w7...")
response = client.request(request)
print(response.result)

Account Methods:

• Get current account state (balance, sequence, settings)

• Use: Balance queries, account existence checks

• Get trust lines for an account

• Use: Token holdings analysis

• Get open DEX orders for an account

• Use: Trading activity analysis

• Get all objects owned by account

• Use: Comprehensive account analysis

• Get transaction history

• Parameters: limit, marker (pagination), forward/backward

• Use: Historical transaction analysis

Ledger Methods:

• Get ledger header and optionally transactions/state

• Use: Block-level analysis, timing

• Get state tree (all objects)

• Warning: Very large response

• Use: Full state snapshots

• Get specific ledger object

• Use: Object lookup by ID

Transaction Methods:

• Get transaction by hash

• Use: Individual transaction lookup

• Get transaction from specific ledger

• Use: Historical transaction verification

Book Methods:

book_offers
- Get order book for currency pair
- Use: DEX analysis, liquidity assessment

Subscription Methods:

subscribe
- Real-time notifications
- Options: transactions, ledger, accounts
- Use: Live monitoring, alerts

Public server limits:

• Request frequency: ~10-20 requests/second typical limit

• account_tx pagination: 200-400 transactions per request

• ledger_data: May timeout for full dumps

• Connection limits: Varies by server

• Slow responses

• Connection drops

• Error responses

• Request queuing

Strategies for heavy use:

1. Implement request queuing: Space out requests to avoid limits
2. Cache responses: Don't re-query unchanged data
3. Use pagination efficiently: Fetch in batches, not one-by-one
4. Consider your own node: For unlimited access
5. Use multiple endpoints: Distribute load across servers

For serious analysis, running your own rippled node provides:

• No rate limits

• Full historical data (if configured)

• Guaranteed availability

• Custom configuration

• CPU: 4+ cores

• RAM: 16GB minimum, 32GB recommended

• Storage: 500GB+ SSD (full history: 10TB+)

• Network: 100Mbps+ connection

• Linux (Ubuntu recommended)

• rippled installed and configured

• Sync time: Hours to days depending on history

• Requires enormous storage (and growing)

• Consider: Do you need full history or just current state?

• Alternative: Download historical dumps, run node for current data

Use official or community libraries rather than raw API calls:

JavaScript/TypeScript:

// xrpl.js - Official library
const xrpl = require('xrpl');
const client = new xrpl.Client('wss://xrplcluster.com');
await client.connect();
const response = await client.request({
  command: 'account_info',
  account: 'rAddress...'
});

Python:

# xrpl-py - Official library
from xrpl.clients import JsonRpcClient
from xrpl.models.requests import AccountInfo

client = JsonRpcClient("https://s1.ripple.com:51234/") 
req = AccountInfo(account="rAddress...")
response = client.request(req)

• Java: xrpl4j
• Go: xrpl-go (community)
• Rust: xrpl-rust (community)

---

Several commercial platforms provide processed blockchain analytics. XRP coverage varies significantly:

Major Platforms:

Platform	XRP Coverage	Strength	Cost
Glassnode	Limited	BTC/ETH metrics	$$$
Santiment	Moderate	Social + on-chain	$$
Messari	Moderate	Research + data	$$
IntoTheBlock	Some	ML indicators	$$
Nansen	Minimal	ETH focus	$$$$
Dune Analytics	Minimal	SQL queries	Free-$$

XRP Coverage Reality:

• Basic metrics only (price, volume)
• Limited or no on-chain metrics
• Delayed relative to BTC/ETH features
• No XRPL-specific features (ODL, escrow)

Implication: For serious XRP analysis, you'll likely need to supplement commercial platforms with direct data access or XRP-specific tools.

COST: $29-$799/month depending on tier

VERDICT: Good for cross-crypto comparison,
limited for XRP-specific deep analysis
```

COST: $49-$349/month

VERDICT: Good for social+on-chain combination,
unique social data valuable
```

COST: Free tier + $24.99/month Pro

VERDICT: Good for research context,
limited for deep on-chain
```

Given limited commercial coverage, XRP-specific tools matter:

XRP Community Resources:

• Account analytics

• Token tracking

• Free tier available

• DEX focused

• Sologenic token ecosystem

• XRPL DEX data

• Real-time DEX data

• Order book visualization

• Trading pair analysis

• Community-built analysis tools

• Forensic tracing

• Often free

---

Design your toolkit around your use cases:

CASUAL INVESTOR TOOLKIT:

- Daily balance checks
- Whale watching via rich list
- Transaction verification

- Portfolio tracking
- Address alerts (if subscribed)

- Social sentiment context
- Cross-crypto comparison

SERIOUS ANALYST TOOLKIT:

- Custom queries for specific analysis
- Automated data collection
- Historical data management

- Quick lookups and verification
- Visual exploration
- Known address reference

- Processed metrics comparison
- Social sentiment data
- Professional reports

INSTITUTIONAL/PROFESSIONAL TOOLKIT:

- Full historical data
- No rate limits
- Custom metrics

- Cross-validation
- Coverage of gaps
- Client reporting

- Automated pipelines
- Alert systems
- Dashboard/visualization

For anything beyond casual analysis, you need data management:

Strategy 1: Query-Based (No Storage)

Approach: Query APIs when you need data

- No infrastructure
- Always current
- Simple

- Rate limits constrain analysis
- Can't do heavy historical analysis
- Repeated queries for same data

Best for: Casual use, quick lookups

Strategy 2: Periodic Snapshots

Approach: Export/save data periodically

- Weekly: Export rich list balances
- Daily: Save key whale balances
- Real-time: Nothing stored

- Historical comparison possible
- Moderate effort
- Free/cheap

- Manual or semi-manual
- Incomplete history
- May miss events between snapshots

Best for: Part-time analysts, specific tracking

Strategy 3: Streaming Database

Approach: Subscribe to transactions, store everything

- WebSocket subscription to transactions
- Filter to relevant types
- Store in database (PostgreSQL, etc.)
- Query local database for analysis

- Complete data within scope
- Fast queries on local data
- Custom aggregations possible

- Requires infrastructure
- Database management overhead
- Storage grows continuously

Best for: Systematic analysts, quantitative strategies

Strategy 4: Full Archive

Approach: Store entire XRPL history

- Run full history node
- Export to data warehouse
- Build comprehensive analytics

- Complete historical coverage
- Maximum flexibility
- Independence from external services

- Massive storage requirements (10TB+)
- Significant infrastructure cost
- Complex to maintain

Best for: Institutions, analytics businesses

Questions to ask:

1. WHAT ARE MY ANALYSIS GOALS?

2. WHAT'S MY TECHNICAL CAPABILITY?

3. WHAT'S MY BUDGET?

4. HOW OFTEN DO I NEED DATA?

5. WHAT'S MY TIME HORIZON?

Decision tree:

Casual investor + free budget:
→ XRPSCAN + Bithomp

Serious analyst + technical skills:
→ API access + XRPSCAN + periodic snapshots

Active trader + moderate budget:
→ Santiment + direct API + local database

Institutional + full budget:
→ Own node + multiple platforms + custom infrastructure

---

Basic Python setup:

# Install library
# pip install xrpl-py

from xrpl.clients import JsonRpcClient
from xrpl.models.requests import AccountInfo, AccountTx

# Create client
client = JsonRpcClient("https://s1.ripple.com:51234/") 

# Get account balance
def get_balance(address):
    request = AccountInfo(account=address)
    response = client.request(request)
    if response.is_successful():
        drops = int(response.result['account_data']['Balance'])
        return drops / 1_000_000  # Convert to XRP
    return None

# Get recent transactions
def get_transactions(address, limit=100):
    request = AccountTx(account=address, limit=limit)
    response = client.request(request)
    if response.is_successful():
        return response.result['transactions']
    return []

Basic JavaScript setup:

// npm install xrpl

const xrpl = require('xrpl');

async function getAccountInfo(address) {
  const client = new xrpl.Client('wss://xrplcluster.com');
  await client.connect();

const response = await client.request({
    command: 'account_info',
    account: address,
    ledger_index: 'validated'
  });

await client.disconnect();
  return response.result;
}

Whale balance monitor (Python):

import time
from datetime import datetime

WHALE_ADDRESSES = [
    'rWhaleAddress1...',
    'rWhaleAddress2...',
    # Add more
]

def monitor_whales():
    results = []
    for address in WHALE_ADDRESSES:
        balance = get_balance(address)
        results.append({
            'address': address[:8] + '...',
            'balance': balance,
            'timestamp': datetime.now().isoformat()
        })
    return results

# Run every hour
while True:
    data = monitor_whales()
    # Save to file or database
    with open('whale_balances.json', 'a') as f:
        f.write(json.dumps(data) + '\n')
    time.sleep(3600)  # 1 hour

Pitfall 1: Ignoring rate limits

Problem: Scripts get blocked or slow
Solution: Add delays between requests

import time
for address in addresses:
result = get_balance(address)
time.sleep(0.1) # 100ms between requests
```

Pitfall 2: Not handling pagination

Problem: Only getting first page of results
Solution: Use marker to paginate

def get_all_transactions(address):
all_txs = []
marker = None
while True:
request = AccountTx(
account=address,
limit=400,
marker=marker
)
response = client.request(request)
all_txs.extend(response.result['transactions'])
marker = response.result.get('marker')
if not marker:
break
return all_txs
```

Pitfall 3: Not handling errors

Problem: Scripts crash on network issues
Solution: Add error handling

def safe_get_balance(address):
try:
return get_balance(address)
except Exception as e:
print(f"Error for {address}: {e}")
return None
```

---

The XRP analysis toolkit is less developed than Bitcoin or Ethereum but adequate for serious analysis. Block explorers provide strong free capabilities. API access enables custom analysis. Commercial platforms help for cross-crypto context but have limited XRP-specific depth. For now, XRP analysts must be more self-sufficient than BTC/ETH analysts—building more themselves rather than relying on commercial solutions. This is both a challenge and an opportunity for differentiation.

---

Assignment: Design and document your personal toolkit for XRPL on-chain analysis.

Requirements:

• Your specific analysis goals
• Technical capabilities
• Budget constraints
• Data frequency needs
• Time horizon

Part 2: Tool Selection (1-2 pages)
For each tool category, document your choice:

• Primary explorer and why

• Secondary explorer and use case

• Specific features you'll use regularly

• Whether you'll use APIs (and why/why not)

• If yes: endpoint choice, library choice

• If no: what limits you accept

• Whether any are worth it for you

• If yes: which and what for

• If no: what you're giving up

• Storage strategy (query-based, snapshots, streaming, or archive)

• Specific data you'll store

• Backup and versioning approach

• Tool or method for storage

• Actually set up accounts/access for your chosen tools

• Test one API call or export one data file

• Document any issues encountered

• Alignment between needs and tools (25%)

• Realistic assessment of capabilities/constraints (25%)

• Practical usability of the plan (25%)

• Evidence of actual setup/testing (15%)

• Clarity of documentation (10%)

Time Investment: 3-4 hours
Value: Creates the infrastructure you'll use throughout this course and your ongoing XRP analysis.

---

1. Tool Selection Question:

For an analyst who wants to track whale wallet balances daily and store historical data for trend analysis, which toolkit approach is most appropriate?

A) XRPSCAN only—it provides all needed functionality
B) API access with periodic snapshot storage
C) Full archive node with data warehouse
D) Commercial platform subscription only

Correct Answer: B
Explanation: Daily balance tracking with historical trend analysis requires: (1) ability to query current balances (API or explorer), (2) storage for historical comparison (periodic snapshots). XRPSCAN alone (A) doesn't provide historical storage. Full archive (C) is overkill for daily balance tracking. Commercial platforms (D) have limited XRP whale tracking. API access with periodic snapshots (B) matches the requirements efficiently.

---

2. API Knowledge Question:

Which API method would you use to get all transactions for a specific XRPL address?

A) ledger_data
B) account_info
C) account_tx
D) transaction_entry

Correct Answer: C
Explanation: account_tx retrieves transaction history for a specific account, with pagination support for complete history. ledger_data (A) gets all ledger objects, not address-specific transactions. account_info (B) gets current account state, not transaction history. transaction_entry (D) gets a specific transaction by hash, not account history.

---

3. Rate Limit Question:

When querying public XRPL servers for thousands of addresses, what is the recommended approach?

A) Send all requests as fast as possible to finish quickly
B) Add small delays between requests and implement error handling
C) Use only commercial platforms to avoid rate limits
D) Run all queries in parallel using multiple threads

Correct Answer: B
Explanation: Public servers have rate limits; sending requests too quickly results in throttling or blocking. Adding delays (100-500ms) between requests and implementing error handling ensures reliable completion. Option A will trigger rate limits. Option C avoids the issue but at unnecessary cost. Option D (parallel requests) actually increases rate limit problems.

---

4. Commercial Platform Question:

Why might a serious XRP analyst need direct API access even if they have a commercial analytics platform subscription?

A) Commercial platforms are always wrong
B) XRP-specific features like ODL tracking and escrow monitoring often aren't available in commercial platforms
C) API access is always cheaper than platform subscriptions
D) Commercial platforms don't have any XRP data

Correct Answer: B
Explanation: Commercial platforms prioritize BTC/ETH and often lack XRPL-specific features: ODL transaction detection, escrow tracking, native DEX analysis, Ripple corporate wallet monitoring, etc. These XRP-unique analyses require direct data access. Answer A is false—platforms aren't always wrong. Answer C isn't always true—some platforms are cheaper than infrastructure. Answer D is false—platforms have basic XRP data.

---

5. Data Management Question:

An analyst is deciding between "query-based" (no storage) and "periodic snapshots" data strategies. What is the key limitation of the query-based approach?

A) Query-based is more expensive
B) Query-based can't access current data
C) Query-based doesn't allow historical comparison or trend analysis
D) Query-based requires running your own node

Correct Answer: C
Explanation: Query-based approaches access current state on-demand but don't store history. Without historical data, you can't analyze trends, compare periods, or track changes over time. This is the key limitation. Answer A is false—query-based is often cheaper (no storage costs). Answer B is false—query-based accesses current data fine. Answer D is false—query-based uses public servers.

---

For Next Lesson:
Explore each tool hands-on before proceeding. Set up your basic toolkit as described in the deliverable. We'll build on this foundation in Lesson 4 as we learn the core metrics every analyst should track.

---

End of Lesson 3

Total words: ~6,300
Estimated completion time: 60 minutes reading + 3-4 hours for deliverable