Starboard Integration Guide

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
  };
}

### Get Twitter Handle by EVM Address

```javascript
async function getTwitterHandleByEvmAddress(starboardId, evmAddress, 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 GetTwitterHandleByEvmAddress($starboardId: ID!, $evmAddress: String!) {
        starboard(id: $starboardId) {
          twitterHandleByEvmAddress(evmAddress: $evmAddress) {
            evmAddress
            mainAddress
            twitterHandle
            isPublic
          }
        }
      }`,
      variables: { starboardId, evmAddress }
    })
  });

  const data = await response.json();
  const result = data.data.starboard.twitterHandleByEvmAddress;

  if (!result) {
    return null;
  }

  return {
    evmAddress: result.evmAddress,
    mainAddress: result.mainAddress,
    twitterHandle: result.twitterHandle,
    isPublic: result.isPublic
  };
}

### Get User Detail by EVM Address

```javascript
async function getUserDetailByEvmAddress(starboardId, evmAddress, 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 GetUserDetail($starboardId: ID!, $evmAddress: String!) {
        starboard(id: $starboardId) {
          userDetail(evmAddress: $evmAddress) {
            starboardId
            twitterHandle
            individual
            aura
            isPublic
          }
        }
      }`,
      variables: { starboardId, evmAddress }
    })
  });

  const data = await response.json();
  const result = data.data.starboard.userDetail;

  if (!result) {
    return null;
  }

  return {
    starboardId: result.starboardId,
    twitterHandle: result.twitterHandle,
    individual: result.individual,
    aura: result.aura,
    isPublic: result.isPublic
  };
}

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 by Twitter ID
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})`);
}

// Get Twitter handle by EVM address
const twitterInfo = await getTwitterHandleByEvmAddress('1', '0x1234567890abcdef', accessToken);
if (twitterInfo) {
  console.log(`Address ${twitterInfo.evmAddress} is linked to @${twitterInfo.twitterHandle}`);
  console.log(`Main address: ${twitterInfo.mainAddress}`);
  console.log(`Public profile: ${twitterInfo.isPublic}`);
}

// Get detailed user metrics by EVM address
const userDetail = await getUserDetailByEvmAddress('1', '0x1234567890abcdef', accessToken);
if (userDetail) {
  console.log(`@${userDetail.twitterHandle} metrics:`);
  console.log(`Individual score: ${userDetail.individual}`);
  console.log(`Aura score: ${userDetail.aura}`);
  console.log(`Public profile: ${userDetail.isPublic}`);
}

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

Caching: Cache leaderboard data for 1-2 minutes to reduce API calls
Rate Limiting: Limit updates to reasonable frequencies
Error Handling: Handle cases where users are not found in rankings
Trend Analysis: Focus on delta values and percentages for meaningful insights
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
Address-to-Twitter Mapping: Link EVM addresses to Twitter profiles using twitterHandleByEvmAddress
User Metrics by Address: Get detailed user scores (individual, aura) using userDetail
Cross-Platform Identity: Connect on-chain addresses with social media presence

Next Steps

Starboard API Reference - Complete API documentation
Leaderboard Guide - General ranking patterns
Authentication - Access token setup

Getting Started

Integration Guides

API Reference

Resources

Starboard Integration Guide

Overview

Understanding Starboards

Basic Starboard Information

Starboard Types

Leaderboard Queries

Get Starboard Rankings

Search Specific User

Basic Implementation

Get Starboard Information

Get Leaderboard Rankings

Find User in Starboard

Analytics Functions

User Trend Analysis

Top Performers Analysis

Usage Examples

Basic Starboard Setup

User Lookup and Analysis

Top Performers Dashboard

Understanding Metrics

Rank Metrics

Influence Score

Trend Data

Best Practices

Common Integration Patterns

Next Steps

​Overview

​Understanding Starboards

​Basic Starboard Information

​Starboard Types

​Leaderboard Queries

​Get Starboard Rankings

​Search Specific User

​Basic Implementation

​Get Starboard Information

​Get Leaderboard Rankings

​Find User in Starboard

​Analytics Functions

​User Trend Analysis

​Top Performers Analysis

​Usage Examples

​Basic Starboard Setup

​User Lookup and Analysis

​Top Performers Dashboard

​Understanding Metrics

​Rank Metrics

​Influence Score

​Trend Data

​Best Practices

​Common Integration Patterns

​Next Steps

Overview

Understanding Starboards

Basic Starboard Information

Starboard Types

Leaderboard Queries

Get Starboard Rankings

Search Specific User

Basic Implementation

Get Starboard Information

Get Leaderboard Rankings

Find User in Starboard

Analytics Functions

User Trend Analysis

Top Performers Analysis

Usage Examples

Basic Starboard Setup

User Lookup and Analysis

Top Performers Dashboard

Understanding Metrics

Rank Metrics

Influence Score

Trend Data

Best Practices

Common Integration Patterns

Next Steps