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
Copy
Ask AI
query GetStarboard($id: ID!) {
starboard(id: $id) {
basicInfo {
id
name
projectName
description
tags
type
reward {
name
description
startTime
endTime
}
}
}
}
Copy
Ask AI
{
"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 trackingONCHAIN
: Blockchain activity-based rankings
Leaderboard Queries
Get Starboard Rankings
Copy
Ask AI
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
Copy
Ask AI
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
Copy
Ask AI
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
Copy
Ask AI
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
Copy
Ask AI
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
Copy
Ask AI
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
Copy
Ask AI
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
Copy
Ask AI
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
Copy
Ask AI
// 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
Copy
Ask AI
// 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 positiondelta
: Change in position since last updatepercentage
: Percentile ranking (higher = better)
Influence Score
value
: Current influence scoredelta
: Absolute change in scoredeltaRate
: Percentage growth rate
Trend Data
change24H
: 24-hour performance metricschange7D
: 7-day performance metricschange30D
: 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