Wallet Transfers

Real-time monitoring of wallet-to-wallet transfers on the Solana blockchain, providing insights into SOL and token movements between addresses.

Overview

The wallet transfers WebSocket stream captures:

• SOL transfers between wallets
• SPL token transfers between wallets
• Transfer amounts and token types
• Transaction signatures and block information
• Related wallet analysis for tracking connected addresses

Connection

WebSocket Endpoint:

wss://api.nolimitnodes.com/socket?apikey=YOUR_API_KEY

Subscription

Subscribe Request

{
    "method": "dataSubscribe",
    "params": {
        "referenceId": "WALLET_TRANSFERS",
        "streams": [
            {
                "stream": "walletTransfersSubscribe",
                "params": {
                    "token": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
                    "from_address": "optional_sender_address",
                    "to_address": "optional_recipient_address"
                }
            }
        ]
    },
    "id": 1
}

Filter Parameters

Parameter	Type	Required	Description
from_address	string	No	Filter by sender wallet address
to_address	string	No	Filter by recipient wallet address
token	string	No	Filter by token mint address or "Solana" for SOL
min_amount	number	No	Minimum transfer amount
max_amount	number	No	Maximum transfer amount

Response Messages

Subscription Confirmation

{
    "status": "Subscribed to wallet transfers",
    "subscription_id": "4db6df25-fa4f-4325-8652-ee3a9f9690b4",
    "stream": "walletTransfersSubscribe",
    "reference_id": "WALLET_TRANSFERS"
}

Transfer Event

{
    "method": "walletTransfersSubscribe",
    "subscription_id": "4db6df25-fa4f-4325-8652-ee3a9f9690b4",
    "result": {
        "from": "28fdboacCPayNxToWNfgNpkVpUuuhN9LyxfQKFt8vXjm",
        "to": "axmFmfqQwZGEUZeF3i3MqbRCDiGPfshtbdoBjk41k88",
        "amount": 1000000000,
        "token": "Solana",
        "transaction_signature": "4wBiX5Pw5QkJ7dmrZTSnqVP4axLsDNzB11f3vTHgbzcqLCKadBa48gCDoPe7CudLFHwwwnKDQMYXxCqmgFprVFAu",
        "block_num": "367222399",
        "block_time": "1758033052",
        "decimals": 9
    }
}

Field Descriptions

Transfer Information

• from: Sender wallet address
• to: Recipient wallet address
• amount: Transfer amount in smallest unit (lamports for SOL)
• token: Token type ("Solana" for SOL, mint address for SPL tokens)
• decimals: Token decimal places

Transaction Details

• transaction_signature: Solana transaction signature
• block_num: Block number where transfer occurred
• block_time: Unix timestamp of the block

Unsubscribe

To stop receiving transfer events, use the dataUnsubscribe method with the subscription ID:

Unsubscribe Request

{
    "method": "dataUnsubscribe",
    "params": {
        "subscriptionIds": ["your_subscription_id_here"],
        "referenceId": "UNSUB_REF"
    }
}

Unsubscribe Response

{
    "status": "Unsubscribed from wallet transfers",
    "subscription_id": "your_subscription_id_here",
    "stream": "walletTransfersSubscribe",
    "reference_id": "UNSUB_REF"
}

Code Examples

JavaScript/Node.js

const WebSocket = require('ws');

class WalletTransferMonitor {
    constructor(apiKey) {
        this.ws = new WebSocket(`wss://api.nolimitnodes.com/socket?apikey=${apiKey}`);
        this.walletConnections = new Map(); // Track related wallets
        this.setupHandlers();
    }

    setupHandlers() {
        this.ws.on('open', () => {
            console.log('Connected to wallet transfers stream');
            this.subscribe();
        });

        this.ws.on('message', (data) => {
            const message = JSON.parse(data);
            if (message.method === 'walletTransfersSubscribe') {
                this.processTransfer(message.result);
            }
        });
    }

    subscribe() {
        // Subscribe to all transfers
        this.ws.send(JSON.stringify({
            method: 'dataSubscribe',
            params: {
                referenceId: 'WALLET_TRANSFERS',
                streams: [{
                    stream: 'walletTransfersSubscribe',
                    params: {}
                }]
            }
        }));
    }

    processTransfer(transfer) {
        // Track wallet connections
        this.trackWalletConnection(transfer.from, transfer.to);

        // Convert amount based on decimals
        const amount = transfer.amount / Math.pow(10, transfer.decimals || 9);

        console.log('\n💸 Wallet Transfer Detected:');
        console.log(`  From: ${transfer.from.slice(0, 8)}...${transfer.from.slice(-4)}`);
        console.log(`  To: ${transfer.to.slice(0, 8)}...${transfer.to.slice(-4)}`);
        console.log(`  Amount: ${amount.toLocaleString()} ${transfer.token === 'Solana' ? 'SOL' : 'tokens'}`);
        console.log(`  Signature: ${transfer.transaction_signature.slice(0, 16)}...`);
        console.log(`  Block: ${transfer.block_num}`);

        // Check for related wallets
        this.analyzeRelatedWallets(transfer.from, transfer.to);
    }

    trackWalletConnection(from, to) {
        // Track connections between wallets
        if (!this.walletConnections.has(from)) {
            this.walletConnections.set(from, new Set());
        }
        if (!this.walletConnections.has(to)) {
            this.walletConnections.set(to, new Set());
        }

        this.walletConnections.get(from).add(to);
        this.walletConnections.get(to).add(from);
    }

    analyzeRelatedWallets(wallet1, wallet2) {
        const connections1 = this.walletConnections.get(wallet1) || new Set();
        const connections2 = this.walletConnections.get(wallet2) || new Set();

        // Find common connections
        const commonConnections = [...connections1].filter(w => connections2.has(w));

        if (commonConnections.length > 0) {
            console.log(`  🔗 Common connections found: ${commonConnections.length} wallet(s)`);
        }

        // Alert if wallets have interacted multiple times
        if (connections1.has(wallet2)) {
            console.log('  ⚠️ These wallets have transferred before!');
        }
    }
}

// Usage
const monitor = new WalletTransferMonitor('YOUR_API_KEY');

Python

import json
import asyncio
import websockets
from collections import defaultdict
from datetime import datetime

class WalletTransferAnalyzer:
    def __init__(self, api_key):
        self.api_key = api_key
        self.uri = f"wss://api.nolimitnodes.com/socket?apikey={api_key}"
        self.transfer_history = []
        self.wallet_graph = defaultdict(set)  # Track wallet relationships
        self.wallet_stats = defaultdict(lambda: {
            'sent': 0, 'received': 0, 'total_volume': 0, 'tx_count': 0
        })

    async def connect(self):
        self.websocket = await websockets.connect(self.uri)
        print("Connected to wallet transfers stream")

    async def subscribe(self, from_address=None, to_address=None):
        params = {}
        if from_address:
            params["from_address"] = from_address
        if to_address:
            params["to_address"] = to_address

        subscription = {
            "method": "dataSubscribe",
            "params": {
                "referenceId": "WALLET_ANALYSIS",
                "streams": [{
                    "stream": "walletTransfersSubscribe",
                    "params": params
                }]
            }
        }
        await self.websocket.send(json.dumps(subscription))

    async def listen(self):
        async for message in self.websocket:
            data = json.loads(message)
            if data.get('method') == 'walletTransfersSubscribe':
                await self.process_transfer(data['result'])

    async def process_transfer(self, transfer):
        # Store transfer
        self.transfer_history.append({
            'timestamp': datetime.now(),
            'data': transfer
        })

        # Update wallet graph
        self.wallet_graph[transfer['from']].add(transfer['to'])
        self.wallet_graph[transfer['to']].add(transfer['from'])

        # Update statistics
        amount = float(transfer['amount']) / (10 ** transfer.get('decimals', 9))

        self.wallet_stats[transfer['from']]['sent'] += amount
        self.wallet_stats[transfer['from']]['tx_count'] += 1
        self.wallet_stats[transfer['from']]['total_volume'] += amount

        self.wallet_stats[transfer['to']]['received'] += amount
        self.wallet_stats[transfer['to']]['tx_count'] += 1
        self.wallet_stats[transfer['to']]['total_volume'] += amount

        # Display transfer
        await self.display_transfer(transfer)

        # Analyze for patterns
        await self.detect_patterns(transfer)

    async def display_transfer(self, transfer):
        amount = float(transfer['amount']) / (10 ** transfer.get('decimals', 9))
        token_name = "SOL" if transfer['token'] == "Solana" else "tokens"

        print(f"\n💸 Transfer Detected:")
        print(f"  From: {transfer['from'][:8]}...{transfer['from'][-4:]}")
        print(f"  To: {transfer['to'][:8]}...{transfer['to'][-4:]}")
        print(f"  Amount: {amount:,.4f} {token_name}")
        print(f"  Block: {transfer['block_num']}")

    async def detect_patterns(self, transfer):
        alerts = []

        # Check for wallet clusters
        from_connections = len(self.wallet_graph[transfer['from']])
        to_connections = len(self.wallet_graph[transfer['to']])

        if from_connections > 10:
            alerts.append(f"🕸️ Sender connected to {from_connections} wallets")

        if to_connections > 10:
            alerts.append(f"🕸️ Receiver connected to {to_connections} wallets")

        # Check for common connections
        common_wallets = self.wallet_graph[transfer['from']] & self.wallet_graph[transfer['to']]
        if len(common_wallets) > 1:
            alerts.append(f"🔗 {len(common_wallets)} common connections between wallets")

        # Check volume patterns
        sender_stats = self.wallet_stats[transfer['from']]
        if sender_stats['tx_count'] > 50:
            alerts.append(f"📊 High activity sender: {sender_stats['tx_count']} transfers")

        # Display alerts
        if alerts:
            print("  🚨 Patterns Detected:")
            for alert in alerts:
                print(f"    • {alert}")

    async def analyze_wallet_cluster(self, wallet_address, depth=2):
        """Analyze wallet connections up to specified depth"""
        print(f"\n🔍 Analyzing wallet cluster for: {wallet_address[:8]}...")

        visited = set()
        to_visit = [(wallet_address, 0)]
        cluster = defaultdict(set)

        while to_visit:
            current, level = to_visit.pop(0)

            if current in visited or level >= depth:
                continue

            visited.add(current)
            connections = self.wallet_graph.get(current, set())
            cluster[level].update(connections)

            for connected in connections:
                if connected not in visited:
                    to_visit.append((connected, level + 1))

        # Display cluster analysis
        total_wallets = sum(len(wallets) for wallets in cluster.values())
        print(f"\n📊 Cluster Analysis Results:")
        print(f"  Total related wallets: {total_wallets}")

        for level, wallets in cluster.items():
            if wallets:
                print(f"  Level {level + 1}: {len(wallets)} wallet(s)")

        return cluster

    async def show_statistics(self):
        """Display accumulated statistics"""
        print("\n" + "="*60)
        print("📊 WALLET TRANSFER STATISTICS")
        print("="*60)

        # Top senders
        top_senders = sorted(
            self.wallet_stats.items(),
            key=lambda x: x[1]['sent'],
            reverse=True
        )[:5]

        print("\n💸 Top Senders:")
        for wallet, stats in top_senders:
            if stats['sent'] > 0:
                print(f"  {wallet[:8]}...{wallet[-4:]}")
                print(f"    Sent: {stats['sent']:,.2f} SOL")
                print(f"    Transactions: {stats['tx_count']}")

        # Top receivers
        top_receivers = sorted(
            self.wallet_stats.items(),
            key=lambda x: x[1]['received'],
            reverse=True
        )[:5]

        print("\n📥 Top Receivers:")
        for wallet, stats in top_receivers:
            if stats['received'] > 0:
                print(f"  {wallet[:8]}...{wallet[-4:]}")
                print(f"    Received: {stats['received']:,.2f} SOL")
                print(f"    Transactions: {stats['tx_count']}")

        # Most connected wallets
        most_connected = sorted(
            self.wallet_graph.items(),
            key=lambda x: len(x[1]),
            reverse=True
        )[:5]

        print("\n🔗 Most Connected Wallets:")
        for wallet, connections in most_connected:
            if connections:
                print(f"  {wallet[:8]}...{wallet[-4:]}: {len(connections)} connections")

async def main():
    analyzer = WalletTransferAnalyzer("YOUR_API_KEY")
    await analyzer.connect()

    # Subscribe to all transfers
    await analyzer.subscribe()

    # Show statistics every 60 seconds
    async def periodic_stats():
        while True:
            await asyncio.sleep(60)
            await analyzer.show_statistics()

    # Run both tasks concurrently
    await asyncio.gather(
        analyzer.listen(),
        periodic_stats()
    )

if __name__ == "__main__":
    asyncio.run(main())

Use Cases

1. Wallet Analysis

• Related Wallet Discovery: Track connections between wallets to identify clusters
• Wallet Behavior Profiling: Analyze transfer patterns and frequencies
• Fund Flow Tracking: Follow the movement of funds across multiple wallets

2. Security Monitoring

• Suspicious Activity Detection: Identify unusual transfer patterns or volumes
• Wallet Cluster Analysis: Detect potential wallet farms or related accounts
• Large Transfer Alerts: Monitor high-value transfers in real-time

3. Portfolio Tracking

• Balance Monitoring: Track incoming and outgoing transfers for specific wallets
• Token Movement Analysis: Monitor specific token transfers
• Transaction History: Build comprehensive transfer histories for wallets

Best Practices

1. Efficient Filtering

• Use address filters to focus on specific wallets of interest
• Set amount thresholds to filter out dust transactions
• Filter by token type when tracking specific assets

2. Data Management

• Implement data retention policies for historical transfers
• Use batch processing for analyzing large volumes of transfers
• Consider using a database for long-term storage and analysis

3. Pattern Recognition

• Build wallet relationship graphs for cluster analysis
• Track transfer frequencies to identify automated wallets
• Monitor for circular transfers that might indicate wash trading

Related Documentation

• Solana RPC Methods
• Liquidity Pool Creations
• Token Creations
• Jupiter Aggregator V6 Swaps