Coreline is a comprehensive workspace management platform designed for Roblox communities. This documentation covers both the web interface features and the complete API reference for building integrations.

What You'll Find Here

• Getting Started: Learn authentication, rate limits, and best practices
• How-To Guides: Step-by-step tutorials for common integration tasks
• Workspace Features: Complete guide to all dashboard features
• API Reference: Detailed documentation for all endpoints

To ensure fair usage and system stability, API requests are rate limited:

Rate Limit Headers

Every API response includes rate limit information in headers:

X-RateLimit-Limit: 60
X-RateLimit-Remaining: 45
X-RateLimit-Reset: 1640995200

Handling Rate Limits

If you exceed the rate limit, you'll receive a 429 Too Many Requests response:

{
  "error": "Rate limit exceeded",
  "retryAfter": 30
}

Get started with the Coreline API in under 5 minutes.

Step 1: Get Your API Key

Navigate to Workspace Admin → API Keys and generate a new key.

Step 2: Make Your First Request

// Node.js example
const API_KEY = process.env.CORELINE_API_KEY;
const BASE_URL = 'https://yoursite.com/api';

async function getStaffOverview() {
  const response = await fetch(`${BASE_URL}/staff/overview`, {
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'X-Source': 'my-integration'
    }
  });

  if (!response.ok) {
    throw new Error(`API error: ${response.status}`);
  }

  const data = await response.json();
  console.log('Top performers:', data.topPerformers);
  console.log('Total staff:', data.totalStaff);
}

getStaffOverview();

Step 3: Handle Errors

async function apiRequest(endpoint) {
  try {
    const response = await fetch(`${BASE_URL}${endpoint}`, {
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'X-Source': 'my-integration'
      }
    });

    if (response.status === 429) {
      const retryAfter = response.headers.get('Retry-After');
      console.log(`Rate limited. Retry after ${retryAfter}s`);
      return null;
    }

    if (!response.ok) {
      const error = await response.json();
      console.error('API Error:', error);
      return null;
    }

    return await response.json();
  } catch (error) {
    console.error('Network error:', error);
    return null;
  }
}

Learn how to integrate Coreline with your Discord bot to display staff data, sessions, and more.

Display Staff Leaderboard

// Discord.js example - Staff leaderboard command
client.on('interactionCreate', async (interaction) => {
  if (!interaction.isChatInputCommand()) return;

  if (interaction.commandName === 'leaderboard') {
    const response = await fetch('https://yoursite.com/api/staff/overview', {
      headers: {
        'Authorization': `Bearer ${process.env.CORELINE_API_KEY}`,
        'X-Source': 'discord-bot'
      }
    });

    const data = await response.json();

    const embed = {
      title: '🏆 Staff Leaderboard',
      description: 'Top performers this week',
      color: 0x5865F2,
      fields: data.topPerformers.slice(0, 10).map((staff, index) => ({
        name: `${index + 1}. ${staff.displayName}`,
        value: `**Minutes:** ${staff.totalMinutes} | **Sessions:** ${staff.totalSessions}`,
        inline: false
      })),
      footer: { text: `Total Staff: ${data.totalStaff}` },
      timestamp: new Date().toISOString()
    };

    await interaction.reply({ embeds: [embed] });
  }
});

Show User Activity

// Show activity for a specific user
async function showUserActivity(userId) {
  const response = await fetch(
    `https://yoursite.com/api/activity/overview?userId=${userId}&period=weekly`,
    {
      headers: {
        'Authorization': `Bearer ${process.env.CORELINE_API_KEY}`,
        'X-Source': 'discord-bot'
      }
    }
  );

  const data = await response.json();

  const embed = {
    title: '📊 Activity Overview',
    color: 0x5865F2,
    fields: [
      {
        name: 'Active Time',
        value: `${data.aggregate.activeMinutes} minutes`,
        inline: true
      },
      {
        name: 'Sessions Hosted',
        value: data.aggregate.sessionsHosted.toString(),
        inline: true
      },
      {
        name: 'Sessions Attended',
        value: data.aggregate.sessionsAttended.toString(),
        inline: true
      },
      {
        name: 'Weekly Quota',
        value: `${data.quotas.weekly.completed}/${data.quotas.weekly.required} minutes (${data.quotas.weekly.percentage}%)`,
        inline: false
      }
    ],
    timestamp: new Date().toISOString()
  };

  return embed;
}

Upcoming Sessions

// Get and display upcoming sessions
async function getUpcomingSessions() {
  const now = new Date();
  const endOfDay = new Date();
  endOfDay.setHours(23, 59, 59, 999);

  const params = new URLSearchParams({
    startAfter: now.toISOString(),
    startBefore: endOfDay.toISOString()
  });

  const response = await fetch(
    `https://yoursite.com/api/sessions?${params}`,
    {
      headers: {
        'Authorization': `Bearer ${process.env.CORELINE_API_KEY}`,
        'X-Source': 'discord-bot'
      }
    }
  );

  const data = await response.json();

  if (data.sessions.length === 0) {
    return { content: 'No upcoming sessions today.' };
  }

  const embed = {
    title: '📅 Upcoming Sessions Today',
    color: 0x5865F2,
    fields: data.sessions.map(session => ({
      name: session.name,
      value: `**Host:** ${session.hostUsername || 'Unclaimed'}\n**Time:** <t:${Math.floor(new Date(session.startTimeUtc).getTime() / 1000)}:t>\n**Status:** ${session.status}`,
      inline: true
    })),
    footer: { text: `${data.sessions.length} session(s)` },
    timestamp: new Date().toISOString()
  };

  return { embeds: [embed] };
}

Learn how to track and monitor sessions programmatically.

Fetching Sessions

Use the sessions API to get scheduled sessions with optional time-based filtering:

// Get all sessions for today
const startOfDay = new Date();
startOfDay.setHours(0, 0, 0, 0);

const endOfDay = new Date();
endOfDay.setHours(23, 59, 59, 999);

const params = new URLSearchParams({
  startAfter: startOfDay.toISOString(),
  startBefore: endOfDay.toISOString()
});

const response = await fetch(`https://yoursite.com/api/sessions?${params}`, {
  headers: {
    'Authorization': `Bearer ${API_KEY}`,
    'X-Source': 'session-tracker'
  }
});

const data = await response.json();
console.log(`Found ${data.sessions.length} sessions today`);

Monitoring Active Sessions

// Poll for active sessions every minute
setInterval(async () => {
  const response = await fetch('https://yoursite.com/api/sessions', {
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'X-Source': 'session-monitor'
    }
  });

  const data = await response.json();
  const activeSessions = data.sessions.filter(s => s.status === 'active');

  if (activeSessions.length > 0) {
    console.log(`Active sessions: ${activeSessions.map(s => s.name).join(', ')}`);
  }
}, 60000); // Check every minute

Track user activity, quotas, and performance metrics.

Get User Activity

async function getUserActivity(userId, period = 'weekly') {
  const response = await fetch(
    `https://yoursite.com/api/activity/overview?userId=${userId}&period=${period}`,
    {
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'X-Source': 'activity-monitor'
      }
    }
  );

  const data = await response.json();

  return {
    activeMinutes: data.aggregate.activeMinutes,
    sessionsHosted: data.aggregate.sessionsHosted,
    sessionsAttended: data.aggregate.sessionsAttended,
    weeklyQuota: data.quotas.weekly,
    monthlyQuota: data.quotas.monthly,
    recentSessions: data.recentSessions
  };
}

Check Quota Compliance

async function checkQuotaCompliance(userId) {
  const activity = await getUserActivity(userId, 'weekly');

  const isCompliant = activity.weeklyQuota.percentage >= 100;
  const shortfall = isCompliant
    ? 0
    : activity.weeklyQuota.required - activity.weeklyQuota.completed;

  return {
    isCompliant,
    shortfall,
    percentage: activity.weeklyQuota.percentage,
    completed: activity.weeklyQuota.completed,
    required: activity.weeklyQuota.required
  };
}

Access and manage staff directory data programmatically.

Get Staff Overview

async function getStaffOverview() {
  const response = await fetch('https://yoursite.com/api/staff/overview', {
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'X-Source': 'staff-manager'
    }
  });

  const data = await response.json();

  return {
    totalStaff: data.totalStaff,
    activeToday: data.activeToday,
    topPerformers: data.topPerformers,
    recentActivity: data.recentActivity,
    departmentBreakdown: data.departmentBreakdown
  };
}

Search Staff Directory

async function searchStaff(searchTerm, department = null) {
  const params = new URLSearchParams({
    search: searchTerm,
    sortBy: 'name',
    sortOrder: 'asc'
  });

  if (department) {
    params.append('department', department);
  }

  const response = await fetch(
    `https://yoursite.com/api/staff/directory?${params}`,
    {
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'X-Source': 'staff-search'
      }
    }
  );

  const data = await response.json();
  return data.directory;
}

Get Staff Profile

async function getStaffProfile(userId) {
  const response = await fetch(
    `https://yoursite.com/api/staff/profile?userId=${userId}`,
    {
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'X-Source': 'profile-viewer'
      }
    }
  );

  const data = await response.json();

  return {
    user: data.user,
    metrics: data.metrics,
    quotas: data.quotas,
    recentSessions: data.recentSessions,
    rank: data.rank
  };
}

Create custom dashboards and analytics using the Coreline API.

Real-Time Activity Dashboard

// React example - Real-time activity dashboard
import { useEffect, useState } from 'react';

function ActivityDashboard() {
  const [overview, setOverview] = useState(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    async function fetchData() {
      const response = await fetch('/api/staff/overview', {
        headers: {
          'Authorization': `Bearer ${API_KEY}`,
          'X-Source': 'web-dashboard'
        }
      });

      const data = await response.json();
      setOverview(data);
      setLoading(false);
    }

    fetchData();
    const interval = setInterval(fetchData, 60000); // Refresh every minute

    return () => clearInterval(interval);
  }, []);

  if (loading) return <div>Loading...</div>;

  return (
    <div className="dashboard">
      <div className="stat-card">
        <h3>Total Staff</h3>
        <p>{overview.totalStaff}</p>
      </div>
      <div className="stat-card">
        <h3>Active Today</h3>
        <p>{overview.activeToday}</p>
      </div>
      {/* More stats... */}
    </div>
  );
}

Performance Analytics

// Analyze performance trends
async function analyzePerformanceTrends(userId) {
  const periods = ['daily', 'weekly', 'monthly'];
  const trends = {};

  for (const period of periods) {
    const response = await fetch(
      `https://yoursite.com/api/activity/overview?userId=${userId}&period=${period}`,
      {
        headers: {
          'Authorization': `Bearer ${API_KEY}`,
          'X-Source': 'analytics'
        }
      }
    );

    const data = await response.json();
    trends[period] = {
      activeMinutes: data.aggregate.activeMinutes,
      quotaPercentage: data.quotas[period]?.percentage || 0,
      sessions: data.aggregate.sessionsHosted + data.aggregate.sessionsAttended
    };
  }

  return trends;
}

The Dashboard is your central hub for monitoring workspace activity and performance. It provides real-time insights into staff performance, upcoming sessions, and key metrics.

Key Performance Indicators (KPIs)

• Total Staff: Number of staff members in your workspace
• Active Today: Staff members who have logged activity today
• Total Sessions: All scheduled sessions across all time
• Active Sessions: Currently ongoing sessions

Widgets

Sessions are scheduled events where staff members participate in various activities. The Sessions page allows you to view, create, and manage all workspace sessions.

Features

• 24-Hour View: See all sessions scheduled for the selected day across all 24 hours
• Session Status: Track whether sessions are upcoming, active, completed, or cancelled
• Host Management: Claim or assign sessions to specific hosts
• Server Assignment: Link sessions to specific Roblox server instances
• Attendance Tracking: Monitor who attends each session

Session Types

Sessions can be customized using presets that define the type of event:

• • Training Sessions
• • Shift Coverage
• • Special Events
• • Team Meetings
• • Custom Presets

Activity Tracking monitors all staff actions and participation across your workspace. This includes session attendance, active time, idle time, and various engagement metrics.

Metrics Tracked

• Active Minutes: Time spent actively participating
• Idle Minutes: Time spent idle but present
• Sessions Hosted: Number of sessions led by the user
• Sessions Attended: Number of sessions participated in
• Messages: Chat messages and interactions

Time Periods

View activity data across different time periods:

• • Daily - Last 24 hours
• • Weekly - Last 7 days
• • Monthly - Last 30 days

Quotas will define minimum activity requirements for staff members. This feature is under active development; the API and UI are not yet available in production.

Quota Types

Quota Management

Planned capabilities (not live yet):

• Rank-Based: Different quotas for different ranks
• Auto-Tracking: Automatically calculated from activity data
• Progress Indicators: Visual feedback on quota completion
• Exemptions: LOA and special exemptions supported

The Staff Directory provides a comprehensive view of all workspace members with their profiles, roles, performance metrics, and contact information.

Features

• Search & Filter: Find staff by name, department, or role
• Performance Metrics: See total minutes, sessions, and quota completion
• Department Organization: Browse by department hierarchy
• Profile Links: Direct links to Roblox profiles
• Avatar Headshots: Visual identification with Roblox avatars

Departments

• • Executive (Rank 254+)
• • Management (Rank 200-253)
• • Operations (Rank 100-199)
• • Department Leads (Rank 50-99)
• • Staff (Rank 17-49)

The Wall is a communication hub where staff can post updates, announcements, and engage in discussions. Think of it as an internal social feed for your workspace.

Features

• Post Updates: Share announcements and news with all staff
• Comments: Discuss and reply to posts
• Rich Content: Support for text formatting and links
• Pinned Posts: Keep important announcements at the top
• Moderation: Edit or remove posts as needed

Notices are official announcements and alerts that appear at the top of the dashboard. Use them for important workspace-wide communications.

Notice Types

Leave of Absence (LOA) management allows staff to formally request time off with automatic quota exemptions during their absence.

Features

• Request Management: Submit and track leave requests
• Approval Workflow: Managers can approve or deny requests
• Quota Exemption: Automatic exemption from quotas during leave
• Leave History: View past and current leave periods
• Duration Tracking: Specify start and end dates

Leave Types

• • Vacation
• • Medical
• • Personal
• • Emergency
• • Extended Leave

Manage partnerships and alliances with other Roblox groups. Track alliance members, permissions, and collaborative activities.

Features

• Alliance Registry: List of all partner groups
• Member Access: Grant permissions to alliance members
• Activity Tracking: Monitor alliance participation
• Contact Management: Store alliance leadership contacts

The Policies section contains all workspace rules, guidelines, and standard operating procedures that staff members need to follow.

Features

• Document Library: Organized collection of all policies
• Version Control: Track policy updates and changes
• Search: Quickly find relevant policies
• Categories: Organize by department or topic
• Required Reading: Mark policies as mandatory

Workspace Admin is the control center for managing your workspace settings, API keys, permissions, and advanced configurations.

Features

• API Key Management: Generate, rotate, and revoke API keys
• Permission Settings: Configure rank-based permissions
• Quota Configuration: Set minimum activity requirements
• Integration Settings: Configure external integrations
• Audit Logs: Review system and admin actions
• Workspace Settings: General configuration and branding

API authentication uses Bearer tokens. All endpoints require a valid API key in the Authorization header.

Header Format

Authorization: Bearer your_api_key_here
X-Source: your-integration-name

Response Codes

All staff endpoints automatically include avatar headshot URLs for visual identification. These are direct links to Roblox's thumbnail service.

URL Format

https://thumbnails.roblox.com/v1/users/avatar-headshot?userIds={userId}&size=150x150&format=Png&isCircular=false

Available Sizes

Usage in Responses

The headshot URL is included in all staff-related API responses:

{
  "userId": "44223311",
  "displayName": "Ashxr_11",
  "headshot": "https://thumbnails.roblox.com/v1/users/avatar-headshot?userIds=44223311&size=150x150&format=Png&isCircular=false"
}

All API errors follow a consistent format with meaningful error messages and appropriate HTTP status codes.

Error Response Format

{
  "error": "Error message description",
  "message": "Additional context or guidance (optional)"
}

Common Errors

{ "error": "Unauthorized" }

{
  "error": "userId parameter required",
  "message": "When using API key authentication, you must provide userId as a query parameter"
}

{
  "error": "Rate limit exceeded",
  "retryAfter": 30
}

{ "error": "Internal server error" }

Error Handling Example

async function makeApiRequest(endpoint) {
  try {
    const response = await fetch(`https://yoursite.com/api${endpoint}`, {
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'X-Source': 'my-app'
      }
    });

    if (!response.ok) {
      const error = await response.json();

      if (response.status === 429) {
        console.log(`Rate limited. Retry after ${error.retryAfter}s`);
        // Implement retry logic
      } else if (response.status === 401) {
        console.error('Invalid API key');
        // Handle authentication error
      } else {
        console.error(`API Error: ${error.error}`);
        if (error.message) {
          console.error(`Details: ${error.message}`);
        }
      }

      return null;
    }

    return await response.json();
  } catch (error) {
    console.error('Network error:', error);
    return null;
  }
}