​
Overview

Starboards provide Twitter influence tracking systems featuring:
  • Real-time Twitter follower rankings
  • Influence score calculations
  • Social metrics with trend analysis
  • Competitive leaderboards with detailed metrics

​
Understanding Starboards

​
Basic Starboard Information

query GetStarboard($id: ID!) {
  starboard(id: $id) {
    basicInfo {
      id
      name
      projectName
      description
      tags
      type
      reward {
        name
        description
        startTime
        endTime
      }
    }
  }
}
Response: 
{
  "data": {
    "starboard": {
      "basicInfo": {
        "id": 1,
        "name": "Twitter Influence Tracker",
        "projectName": "Galxe Community",
        "description": "Track your Twitter influence and compete with others",
        "tags": ["social", "twitter", "influence"],
        "type": "TWITTER",
        "reward": {
          "name": "Influence Rewards",
          "description": "Rewards for top Twitter influencers",
          "startTime": 1699200000,
          "endTime": 1700000000
        }
      }
    }
  }
}

​
Starboard Types

  • TWITTER: Twitter-based influence tracking
  • ONCHAIN: Blockchain activity-based rankings

​
Leaderboard Queries

​
Get Starboard Rankings

query GetStarboardRankings($starboardId: ID!, $first: Int!, $after: String) {
  starboard(id: $starboardId) {
    basicInfo {
      id
      name
      type
    }
    leaderboard(
      pagination: { 
        forward: { 
          first: $first
          after: $after 
        } 
      }
    ) {
      pageInfo {
        hasNextPage
        endCursor
      }
      edges {
        node {
          xUserProfile {
            id
            name
            username
            profileImageUrl
            followersCount
            verifiedType
          }
          rank {
            value
            delta
            percentage
          }
          influenceScore {
            value
            delta
            deltaRate
          }
          change24H {
            value
            delta
          }
          change7D {
            value
            delta
          }
          change30D {
            value
            delta
          }
        }
      }
    }
  }
}

​
Search Specific User

query SearchUserInStarboard($starboardId: ID!, $twitterId: String!) {
  starboard(id: $starboardId) {
    leaderboard(
      twitterId: $twitterId
      pagination: { 
        forward: { first: 1 } 
      }
    ) {
      edges {
        node {
          xUserProfile {
            username
            followersCount
            verifiedType
          }
          rank {
            value
            delta
            percentage
          }
          influenceScore {
            value
            delta
            deltaRate
          }
        }
      }
    }
  }
}

​
Basic Implementation

​
Get Starboard Information

async function getStarboardInfo(starboardId, accessToken) {
  const response = await fetch('https://graphigo-business.prd.galaxy.eco/query', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'access-token': accessToken
    },
    body: JSON.stringify({
      query: `query GetStarboard($id: ID!) {
        starboard(id: $id) {
          basicInfo {
            id
            name
            projectName
            description
            tags
            type
            reward {
              name
              description
              startTime
              endTime
            }
          }
        }
      }`,
      variables: { id: starboardId }
    })
  });
  
  const data = await response.json();
  return data.data.starboard.basicInfo;
}

​
Get Leaderboard Rankings

async function getLeaderboard(starboardId, accessToken, options = {}) {
  const {
    limit = 20,
    cursor = null
  } = options;
  
  const response = await fetch('https://graphigo-business.prd.galaxy.eco/query', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'access-token': accessToken
    },
    body: JSON.stringify({
      query: `query GetStarboardRankings($starboardId: ID!, $first: Int!, $after: String) {
        starboard(id: $starboardId) {
          basicInfo { id name type }
          leaderboard(
            pagination: { 
              forward: { 
                first: $first
                after: $after 
              } 
            }
          ) {
            pageInfo {
              hasNextPage
              endCursor
            }
            edges {
              node {
                xUserProfile {
                  id
                  name
                  username
                  profileImageUrl
                  followersCount
                  verifiedType
                }
                rank {
                  value
                  delta
                  percentage
                }
                influenceScore {
                  value
                  delta
                  deltaRate
                }
                change24H { value delta }
                change7D { value delta }
                change30D { value delta }
              }
            }
          }
        }
      }`,
      variables: {
        starboardId,
        first: limit,
        after: cursor
      }
    })
  });
  
  const data = await response.json();
  const starboard = data.data.starboard;
  
  return {
    starboardId,
    name: starboard.basicInfo.name,
    type: starboard.basicInfo.type,
    rankings: starboard.leaderboard.edges.map(edge => ({
      rank: parseInt(edge.node.rank.value),
      rankDelta: edge.node.rank.delta,
      rankPercentage: edge.node.rank.percentage,
      score: parseFloat(edge.node.influenceScore.value),
      scoreDelta: edge.node.influenceScore.delta,
      scoreDeltaRate: edge.node.influenceScore.deltaRate,
      user: {
        id: edge.node.xUserProfile.id,
        name: edge.node.xUserProfile.name,
        username: edge.node.xUserProfile.username,
        avatar: edge.node.xUserProfile.profileImageUrl,
        followers: edge.node.xUserProfile.followersCount,
        verified: edge.node.xUserProfile.verifiedType
      },
      trends: {
        change24H: {
          value: edge.node.change24H.value,
          delta: edge.node.change24H.delta
        },
        change7D: {
          value: edge.node.change7D.value,
          delta: edge.node.change7D.delta
        },
        change30D: {
          value: edge.node.change30D.value,
          delta: edge.node.change30D.delta
        }
      }
    })),
    pageInfo: starboard.leaderboard.pageInfo
  };
}

​
Find User in Starboard

async function findUser(starboardId, twitterId, accessToken) {
  const response = await fetch('https://graphigo-business.prd.galaxy.eco/query', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'access-token': accessToken
    },
    body: JSON.stringify({
      query: `query SearchUserInStarboard($starboardId: ID!, $twitterId: String!) {
        starboard(id: $starboardId) {
          leaderboard(
            twitterId: $twitterId
            pagination: { forward: { first: 1 } }
          ) {
            edges {
              node {
                xUserProfile {
                  username
                  followersCount
                  verifiedType
                }
                rank {
                  value
                  delta
                  percentage
                }
                influenceScore {
                  value
                  delta
                  deltaRate
                }
              }
            }
          }
        }
      }`,
      variables: { starboardId, twitterId }
    })
  });
  
  const data = await response.json();
  const edges = data.data.starboard.leaderboard.edges;
  
  if (edges.length === 0) {
    return null;
  }
  
  const node = edges[0].node;
  return {
    username: node.xUserProfile.username,
    followers: node.xUserProfile.followersCount,
    verified: node.xUserProfile.verifiedType,
    rank: parseInt(node.rank.value),
    rankDelta: node.rank.delta,
    rankPercentage: node.rank.percentage,
    score: parseFloat(node.influenceScore.value),
    scoreDelta: node.influenceScore.delta,
    scoreDeltaRate: node.influenceScore.deltaRate
  };
}

​
Analytics Functions

​
User Trend Analysis

async function analyzeUserTrends(starboardId, twitterId, accessToken) {
  const user = await findUser(starboardId, twitterId, accessToken);
  
  if (!user) {
    return { message: 'User not found in starboard' };
  }
  
  return {
    user: {
      username: user.username,
      followers: user.followers,
      verified: user.verified
    },
    ranking: {
      current: user.rank,
      delta: user.rankDelta,
      percentile: user.rankPercentage
    },
    influence: {
      score: user.score,
      delta: user.scoreDelta,
      growthRate: user.scoreDeltaRate
    },
    performance: {
      trending: user.scoreDelta > 0 ? 'up' : user.scoreDelta < 0 ? 'down' : 'stable',
      momentum: Math.abs(user.scoreDeltaRate) > 0.1 ? 'high' : 'low'
    }
  };
}

​
Top Performers Analysis

async function getTopPerformers(starboardId, accessToken, limit = 10) {
  const leaderboard = await getLeaderboard(starboardId, accessToken, { limit });
  
  return {
    topInfluencers: leaderboard.rankings
      .sort((a, b) => b.score - a.score)
      .slice(0, 5),
    fastestGrowing: leaderboard.rankings
      .filter(user => user.scoreDeltaRate > 0)
      .sort((a, b) => b.scoreDeltaRate - a.scoreDeltaRate)
      .slice(0, 5),
    biggestMovers: leaderboard.rankings
      .filter(user => Math.abs(user.rankDelta) > 0)
      .sort((a, b) => Math.abs(b.rankDelta) - Math.abs(a.rankDelta))
      .slice(0, 5)
  };
}

​
Usage Examples

​
Basic Starboard Setup

const accessToken = process.env.GALXE_ACCESS_TOKEN;

// Get starboard information
const starboard = await getStarboardInfo('1', accessToken);
console.log(`Starboard: ${starboard.name} (${starboard.type})`);

// Get top 10 rankings
const leaderboard = await getLeaderboard('1', accessToken, { limit: 10 });
console.log('Top 10 Twitter influencers:');
leaderboard.rankings.forEach(user => {
  console.log(`${user.rank}. @${user.user.username} - ${user.score} points (${user.user.followers} followers)`);
});

​
User Lookup and Analysis

// Find specific user
const userAnalysis = await analyzeUserTrends('1', 'elonmusk', accessToken);
if (userAnalysis.message) {
  console.log(userAnalysis.message);
} else {
  console.log(`@${userAnalysis.user.username}`);
  console.log(`Rank: #${userAnalysis.ranking.current} (${userAnalysis.ranking.delta > 0 ? '+' : ''}${userAnalysis.ranking.delta})`);
  console.log(`Score: ${userAnalysis.influence.score} (${userAnalysis.performance.trending})`);
}

​
Top Performers Dashboard

// Get top performers analysis
const performers = await getTopPerformers('1', accessToken);

console.log('Top Influencers:');
performers.topInfluencers.forEach(user => {
  console.log(`@${user.user.username}: ${user.score} points`);
});

console.log('\nFastest Growing:');
performers.fastestGrowing.forEach(user => {
  console.log(`@${user.user.username}: +${user.scoreDeltaRate}% growth`);
});

console.log('\nBiggest Rank Changes:');
performers.biggestMovers.forEach(user => {
  console.log(`@${user.user.username}: ${user.rankDelta > 0 ? '+' : ''}${user.rankDelta} positions`);
});

​
Understanding Metrics

​
Rank Metrics

  • value: Current ranking position
  • delta: Change in position since last update
  • percentage: Percentile ranking (higher = better)

​
Influence Score

  • value: Current influence score
  • delta: Absolute change in score
  • deltaRate: Percentage growth rate

​
Trend Data

  • change24H: 24-hour performance metrics
  • change7D: 7-day performance metrics
  • change30D: 30-day performance metrics

​
Best Practices

  1. Caching: Cache leaderboard data for 1-2 minutes to reduce API calls
  2. Rate Limiting: Limit updates to reasonable frequencies
  3. Error Handling: Handle cases where users are not found in rankings
  4. Trend Analysis: Focus on delta values and percentages for meaningful insights
  5. User Context: Always display Twitter usernames for clarity

​
Common Integration Patterns

  • Influencer Discovery: Find top performers and trending users
  • Competition Tracking: Monitor rank changes and performance
  • User Verification: Check Twitter verification status
  • Trend Analysis: Identify growth patterns and momentum
  • Performance Comparison: Compare multiple users or time periods

​
Next Steps