Skip to main content
This page contains practical examples for common use cases with the SolixDB GraphQL API. Use these examples to build trading bots, analytics dashboards, ML models, and more.

​
Common Use Cases

Trading Bot Backtesting

Test strategies against historical DEX trades with prices and volumes.

Analytics Dashboards

Monitor protocol performance, volumes, and trends in real-time.

ML Model Training

Export clean datasets for training price prediction and rug pull detection models.

Failed Transaction Analysis

Analyze failed transactions to identify patterns and errors.

​
Basic Queries

​
Get Recent Transactions

Query recent transactions from a specific protocol: 
query {
  transactions(
    filters: { protocols: ["jupiter_v6"] }
    pagination: { first: 10 }
  ) {
    edges {
      node {
        signature
        slot
        protocolName
        fee
        computeUnits
        blockTime
      }
      cursor
    }
    pageInfo {
      hasNextPage
    }
  }
}

​
Get Transactions for a Date Range

Filter transactions by date range for backtesting or analysis: 
query {
  transactions(
    filters: {
      protocols: ["pump_fun"]
      dateRange: { start: "2025-01-01", end: "2025-01-31" }
    }
    pagination: { first: 100 }
  ) {
    edges {
      node {
        signature
        slot
        protocolName
        fee
        computeUnits
        date
        hour
      }
    }
  }
}

​
Get Transaction by Signature

Look up a specific transaction: 
query {
  signature(signature: "5VERv8NMxzbPDohNpJhHopN2C9R4G5GaPevYf5hLJ8Z7") {
    signature
    slot
    blockTime
    protocolName
    instructionType
    fee
    computeUnits
    accountsCount
    date
    hour
  }
}

​
Aggregations and Analytics

​
Protocol Statistics

Get comprehensive statistics for a protocol: 
query {
  protocolStats(
    filters: {
      protocols: ["jupiter_v6"]
      dateRange: { start: "2025-01-01", end: "2025-01-31" }
    }
  ) {
    protocolName
    totalTransactions
    totalFees
    totalComputeUnits
    averageFee
    averageComputeUnits
    uniquePrograms
  }
}

​
Fee Analysis by Day of Week

Analyze fees by day of week to identify patterns: 
query {
  transactions(
    filters: {
      protocols: ["jupiter_v6"]
      dateRange: { start: "2025-01-01", end: "2025-01-31" }
    }
    groupBy: [DAY_OF_WEEK]
    metrics: [COUNT, AVG_FEE, P95_FEE, P99_FEE]
    sort: { field: AVG_FEE, direction: DESC }
  ) {
    edges {
      node {
        dayOfWeek
        count
        avgFee
        p95Fee
        p99Fee
      }
    }
  }
}

​
Hourly Protocol Comparison

Compare multiple protocols by hour: 
query {
  transactions(
    filters: {
      protocols: ["jupiter_v6", "raydium_amm_v3", "pump_fun"]
      dateRange: { start: "2025-01-01", end: "2025-01-31" }
    }
    groupBy: [PROTOCOL, HOUR]
    metrics: [COUNT, AVG_FEE]
    sort: { field: COUNT, direction: DESC }
    pagination: { first: 100 }
  ) {
    edges {
      node {
        protocol
        hour
        count
        avgFee
      }
    }
  }
}

​
Time Series Analysis

​
Daily Transaction Count

Get daily transaction counts: 
query {
  timeSeries(
    filters: {
      protocols: ["pump_fun"]
      dateRange: { start: "2025-01-01", end: "2025-01-31" }
    }
    bucketBy: DAY
    metrics: [COUNT, AVG_FEE]
  ) {
    timestamp
    value
    label
  }
}

​
Weekly Protocol Comparison

Compare protocols over weeks: 
query {
  transactions(
    filters: {
      dateRange: { start: "2025-01-01", end: "2025-01-31" }
    }
    groupBy: [PROTOCOL, WEEK]
    metrics: [COUNT, SUM_FEE]
    sort: { field: COUNT, direction: DESC }
  ) {
    edges {
      node {
        protocol
        week
        count
        sumFee
      }
    }
  }
}

​
Failed Transaction Analysis

​
Analyze Failed Jupiter Swaps

Find and analyze failed Jupiter swaps: 
query {
  failedTransactions(
    filters: {
      protocols: ["jupiter_v6"]
      dateRange: { start: "2025-01-01", end: "2025-01-31" }
      errorPattern: "insufficient funds"
    }
    groupBy: [PROTOCOL, INSTRUCTION_TYPE]
    metrics: [COUNT]
    pagination: { first: 100 }
  ) {
    edges {
      node {
        protocolName
        instructionType
        errorMessage
        count
      }
    }
  }
}

​
Failed Transaction Patterns

Identify common failure patterns: 
query {
  failedTransactions(
    filters: {
      protocols: ["pump_fun"]
      dateRange: { start: "2025-01-01", end: "2025-01-31" }
    }
    groupBy: [INSTRUCTION_TYPE]
    metrics: [COUNT]
    sort: { field: COUNT, direction: DESC }
    pagination: { first: 50 }
  ) {
    edges {
      node {
        instructionType
        count
      }
    }
  }
}

​
ML Dataset Export

​
Export Training Dataset

Export a dataset for ML model training: 
mutation {
  exportDataset(
    config: {
      format: PARQUET
      filters: {
        protocols: ["pump_fun"]
        dateRange: { start: "2025-01-01", end: "2025-01-31" }
      }
      columns: [
        "protocol_name"
        "fee"
        "compute_units"
        "success"
        "instruction_type"
        "hour"
        "day_of_week"
        "accounts_count"
      ]
      sampling: { strategy: RANDOM, rate: 0.1 }
      splits: { train: 0.7, test: 0.2, val: 0.1 }
    }
  ) {
    id
    status
    progress
  }
}

​
Query Complexity Management

​
Check Complexity Before Execution

Always check query complexity before executing expensive queries: 
query {
  queryComplexity(
    filters: {
      dateRange: { start: "2025-01-01", end: "2025-01-31" }
      protocols: ["pump_fun"]
    }
    groupBy: [PROTOCOL, HOUR, INSTRUCTION_TYPE]
    metrics: [COUNT, AVG_FEE, P95_FEE, P99_FEE]
  ) {
    score
    estimatedRows
    baseCost
    recommendations
  }
}

​
Pagination Examples

​
Fetch All Results

Fetch all results using cursor-based pagination: 
async function fetchAllTransactions(filters) {
  let allTransactions = [];
  let hasNextPage = true;
  let cursor = null;
  
  while (hasNextPage) {
    const query = `
      query GetTransactions($first: Int, $after: String) {
        transactions(
          filters: $filters
          pagination: { first: $first, after: $after }
        ) {
          edges {
            node {
              signature
              slot
              protocolName
              fee
              computeUnits
            }
            cursor
          }
          pageInfo {
            hasNextPage
            endCursor
          }
        }
      }
    `;
    
    const response = await fetch('https://api.solixdb.xyz/graphql', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        query,
        variables: {
          filters,
          first: 1000,
          after: cursor
        }
      }),
    });
    
    const data = await response.json();
    const connection = data.data.transactions;
    
    allTransactions.push(...connection.edges.map(e => e.node));
    hasNextPage = connection.pageInfo.hasNextPage;
    cursor = connection.pageInfo.endCursor;
    
    console.log(`Fetched ${allTransactions.length} transactions...`);
  }
  
  return allTransactions;
}

// Usage
const filters = {
  protocols: ["pump_fun"],
  dateRange: { start: "2025-01-01", end: "2025-01-31" }
};

const allTransactions = await fetchAllTransactions(filters);
console.log(`Total: ${allTransactions.length} transactions`);

​
Real-World Scenarios

​
Building a Trading Bot

Use historical data to test your trading strategy:
import requests
import pandas as pd

def backtest_strategy(protocol, start_date, end_date):
    query = """
      query {
        transactions(
          filters: {
            protocols: ["%s"]
            dateRange: { start: "%s", end: "%s" }
          }
          pagination: { first: 10000 }
        ) {
          edges {
            node {
              signature
              slot
              protocolName
              fee
              computeUnits
              date
              hour
            }
          }
        }
      }
    """ % (protocol, start_date, end_date)
    
    response = requests.post(
        'https://api.solixdb.xyz/graphql',
        json={'query': query}
    )
    
    data = response.json()
    transactions = [edge['node'] for edge in data['data']['transactions']['edges']]
    df = pd.DataFrame(transactions)
    
    # Your backtesting logic here
    # Analyze price movements, volumes, fees, etc.
    
    return df

# Backtest on Pump.fun data
df = backtest_strategy('pump_fun', '2025-01-01', '2025-01-31')
print(df.describe())

​
Creating an Analytics Dashboard

Build real-time dashboards showing protocol metrics:
async function getProtocolMetrics(protocols, dateRange) {
  const query = `
    query {
      ${protocols.map((p, i) => `
        protocol${i}: protocolStats(
          filters: {
            protocols: ["${p}"]
            dateRange: { start: "${dateRange.start}", end: "${dateRange.end}" }
          }
        ) {
          protocolName
          totalTransactions
          totalFees
          averageFee
          averageComputeUnits
        }
      `).join('\n')}
    }
  `;
  
  const response = await fetch('https://api.solixdb.xyz/graphql', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ query }),
  });
  
  const data = await response.json();
  return Object.values(data.data);
}

// Get metrics for multiple protocols
const protocols = ['jupiter_v6', 'raydium_amm_v3', 'pump_fun'];
const metrics = await getProtocolMetrics(protocols, {
  start: '2025-01-01',
  end: '2025-01-31'
});

// Display in your dashboard
console.log(metrics);

​
Next Steps

GraphQL API Reference

Explore all available queries, mutations, and types.

Migration Guide

Migrate from REST API to GraphQL.

Error Handling

Learn how to handle errors gracefully.

Rate Limiting

Understand complexity-based rate limits.