Skip to main content
This page provides a comprehensive reference for all types, queries, mutations, and subscriptions available in the MCMP GraphQL API.

Core Types

Server

The main server entity representing a Minecraft server instance.
type Server {
  id: ID!
  name: String!
  status: ServerStatus!
  players: ServerPlayers!
  version: String
  configuration: ServerConfiguration
  createdAt: DateTime!
  updatedAt: DateTime!
}

ServerStatus

Enumeration of possible server states.
enum ServerStatus {
  RUNNING
  STOPPED
  STARTING
  STOPPING
  ERROR
}

ServerPlayers

Information about server players.
type ServerPlayers {
  online: Int!
  max: Int!
  list: [Player!]!
}

Player

Individual player information.
type Player {
  uuid: ID!
  name: String!
  online: Boolean!
  lastSeen: DateTime
  joinTime: DateTime
  location: PlayerLocation
  totalPlayTime: Int
}

PlayerLocation

Player’s current or last known location.
type PlayerLocation {
  world: String!
  x: Float!
  y: Float!
  z: Float!
}

ServerConfiguration

Server configuration settings.
type ServerConfiguration {
  server: ServerSettings!
  world: WorldSettings!
}

ServerSettings

Server-specific configuration.
type ServerSettings {
  name: String!
  maxPlayers: Int!
  version: String!
  motd: String!
  difficulty: Difficulty!
}

WorldSettings

World configuration settings.
type WorldSettings {
  name: String!
  seed: String!
  generator: String!
}

Difficulty

Minecraft difficulty levels.
enum Difficulty {
  PEACEFUL
  EASY
  NORMAL
  HARD
}

Queries

servers

Get a list of all servers.
servers: [Server!]!

server

Get a specific server by ID.
server(id: ID!): Server

playerHistory

Get play history for a specific player.
playerHistory(serverId: ID!, playerId: ID!): PlayerHistory

serverAnalytics

Get analytics data for a server.
serverAnalytics(serverId: ID!, timeRange: TimeRange!): ServerAnalytics

Mutations

startServer

Start a stopped server.
startServer(serverId: ID!): ServerOperationResult!

stopServer

Stop a running server.
stopServer(serverId: ID!): ServerOperationResult!

restartServer

Restart a server.
restartServer(serverId: ID!): ServerOperationResult!

updateServerConfig

Update server configuration.
updateServerConfig(serverId: ID!, config: ServerConfigInput!): ServerOperationResult!

batchServerOperations

Execute multiple server operations in a single request.
batchServerOperations(operations: [ServerOperation!]!): BatchOperationResult!

Subscriptions

serverStatusChanged

Subscribe to server status changes.
serverStatusChanged(serverId: ID!): ServerStatusEvent!

playerEvents

Subscribe to player join/leave events.
playerEvents(serverId: ID!): PlayerEvent!

serverMetrics

Subscribe to real-time server performance metrics.
serverMetrics(serverId: ID!): ServerMetrics!

Input Types

ServerConfigInput

Input for updating server configuration.
input ServerConfigInput {
  maxPlayers: Int
  motd: String
  difficulty: Difficulty
}

ServerOperation

Input for batch server operations.
input ServerOperation {
  operationId: ID!
  type: ServerOperationType!
  serverId: ID!
  parameters: JSON
}

TimeRange

Time range for analytics queries.
input TimeRange {
  start: DateTime!
  end: DateTime!
}

Event Types

ServerStatusEvent

Event emitted when server status changes.
type ServerStatusEvent {
  serverId: ID!
  status: ServerStatus!
  timestamp: DateTime!
  previousStatus: ServerStatus
}

PlayerEvent

Event emitted for player activities.
type PlayerEvent {
  type: PlayerEventType!
  serverId: ID!
  player: Player!
  timestamp: DateTime!
  data: PlayerEventData
}

ServerMetrics

Real-time server performance metrics.
type ServerMetrics {
  serverId: ID!
  timestamp: DateTime!
  cpu: CpuMetrics!
  memory: MemoryMetrics!
  disk: DiskMetrics!
  network: NetworkMetrics!
}

Analytics Types

ServerAnalytics

Server analytics data.
type ServerAnalytics {
  timeRange: TimeRange!
  playerActivity: PlayerActivityAnalytics!
  performance: PerformanceAnalytics!
  uptime: UptimeAnalytics!
}

PlayerActivityAnalytics

Player activity statistics.
type PlayerActivityAnalytics {
  totalSessions: Int!
  averageSessionDuration: Int!
  peakPlayers: Int!
  uniquePlayers: Int!
  playerRetention: Float!
}

PerformanceAnalytics

Server performance statistics.
type PerformanceAnalytics {
  averageCpuUsage: Float!
  averageMemoryUsage: Float!
  peakCpuUsage: Float!
  peakMemoryUsage: Float!
  averageTps: Float!
}

Utility Types

ServerOperationResult

Result of a server operation.
type ServerOperationResult {
  success: Boolean!
  message: String!
  server: Server
  error: String
}

BatchOperationResult

Result of batch operations.
type BatchOperationResult {
  results: [OperationResult!]!
  errors: [OperationError!]!
}

OperationResult

Individual operation result.
type OperationResult {
  operationId: ID!
  success: Boolean!
  message: String!
  data: JSON
}

OperationError

Individual operation error.
type OperationError {
  operationId: ID!
  error: String!
  message: String!
}

Scalar Types

DateTime

ISO 8601 formatted date and time.
scalar DateTime

JSON

Arbitrary JSON data.
scalar JSON

Enums

ServerOperationType

Types of server operations.
enum ServerOperationType {
  START
  STOP
  RESTART
  UPDATE_CONFIG
}

PlayerEventType

Types of player events.
enum PlayerEventType {
  JOIN
  LEAVE
  KICK
  BAN
  UNBAN
}

Introspection

The GraphQL API supports full introspection, allowing you to query the schema itself:
query IntrospectionQuery {
  __schema {
    types {
      name
      kind
      description
    }
    queryType {
      name
    }
    mutationType {
      name
    }
    subscriptionType {
      name
    }
  }
}

Schema Validation

All queries, mutations, and subscriptions are validated against the schema before execution. Invalid operations will return detailed error messages indicating what needs to be corrected.
The GraphQL schema is versioned and backward compatible. New fields and types may be added, but existing fields will not be removed or have their types changed in breaking ways.