http://tu-servidor:8080/api

curl -X GET "http://localhost:8080/api/servers?username=admin*" \
  -H "Authorization: Bearer YOUR_TOKEN"

{
  "servers": [
    {
      "id": 1,
      "uuid": "abc12345...",
      "name": "Survival Server",
      "ownerId": 1,
      "nodeId": 1,
      "image": "ghcr.io/pterodactyl/yolks:java_17",
      "startup": "java -Xms128M -Xmx1024M -jar server.jar"
    }
  ],
  "metadata": {
    "paging": {
      "page": 1,
      "size": 25,
      "maxSize": 100,
      "total": 1
    }
  }
}

{
  "id": 1,
  "uuid": "abc12345...",
  "name": "Survival Server",
  "ownerId": 1,
  "nodeId": 1,
  "status": "installing",
  "resources": {
    "memory": 1024,
    "disk": 5120,
    "cpu": 100
  },
  "deployment": {
    "port": 25565,
    "ip": "192.168.1.1"
  }
}

{
  "name": "New Server",
  "ownerId": 1,
  "eggId": 1,
  "dockerImage": "ghcr.io/pterodactyl/yolks:java_17",
  "startup": "java -Xms128M -Xmx{{SERVER_MEMORY}}M -jar {{SERVER_JARFILE}}",
  "environment": {
    "SERVER_JARFILE": "server.jar",
    "f": "v"
  },
  "limits": {
    "memory": 1024,
    "swap": 0,
    "disk": 5120,
    "io": 500,
    "cpu": 100
  },
  "featureLimits": {
    "databases": 1,
    "backups": 1
  }
}

{
  "id": 2,
  "uuid": "def67890...",
  "name": "New Server",
  "status": "installing"
}

{
  "name": "Nuevo Nombre",
  "type": {
    "type": "minecraft-java"
  },
  "icon": "nuevo-icono.png",
  "server": {
    "run": {
      "command": "java -Xmx4G -jar server.jar nogui"
    },
    "data": {
      "memory": 4096
    }
  },
  "variables": {
    "port": 25566
  }
}

{
  "running": true
}

{
  "cpu": 45.2,
  "memory": 1536000000,
  "memoryTotal": 2147483648
}

{
  "logs": [
    "[10:30:15] [Server thread/INFO]: Starting minecraft server version 1.20.1",
    "[10:30:16] [Server thread/INFO]: Loading properties"
  ]
}

{
  "command": "say Hello World!"
}

curl -X GET "https://aetherpanel.es/api/application/servers" \
-H "Authorization: Bearer <YOUR_API_KEY>" \
-H "Accept: Application/vnd.aether.v1+json"

pip install requests

import requests
import json

class SkyPanelAPI:
    def __init__(self, base_url, client_id, client_secret):
        self.base_url = base_url
        self.client_id = client_id
        self.client_secret = client_secret
        self.token = None
    
    def authenticate(self):
        """Obtener token de acceso"""
        url = f"{self.base_url}/oauth2/token"
        data = {
            'grant_type': 'client_credentials',
            'client_id': self.client_id,
            'client_secret': self.client_secret
        }
        response = requests.post(url, data=data)
        response.raise_for_status()
        self.token = response.json()['access_token']
        return self.token
    
    def get_headers(self):
        """Headers con autenticación"""
        if not self.token:
            self.authenticate()
        return {
            'Authorization': f'Bearer {self.token}',
            'Content-Type': 'application/json'
        }
    
    def list_servers(self, **filters):
        """Listar servidores"""
        url = f"{self.base_url}/api/servers"
        response = requests.get(url, headers=self.get_headers(), params=filters)
        response.raise_for_status()
        return response.json()
    
    def get_server(self, server_id):
        """Obtener servidor específico"""
        url = f"{self.base_url}/api/servers/{server_id}"
        response = requests.get(url, headers=self.get_headers())
        response.raise_for_status()
        return response.json()
    
    def start_server(self, server_id):
        """Iniciar servidor"""
        url = f"{self.base_url}/api/servers/{server_id}/start"
        response = requests.post(url, headers=self.get_headers())
        response.raise_for_status()
        return True
    
    def stop_server(self, server_id):
        """Detener servidor"""
        url = f"{self.base_url}/api/servers/{server_id}/stop"
        response = requests.post(url, headers=self.get_headers())
        response.raise_for_status()
        return True
    
    def send_command(self, server_id, command):
        """Enviar comando a consola"""
        url = f"{self.base_url}/api/servers/{server_id}/console"
        data = {'command': command}
        response = requests.post(url, headers=self.get_headers(), json=data)
        response.raise_for_status()
        return True
    
    def create_server(self, server_data):
        """Crear servidor"""
        server_id = server_data.get('identifier', '')
        url = f"{self.base_url}/api/servers/{server_id}"
        response = requests.put(url, headers=self.get_headers(), json=server_data)
        response.raise_for_status()
        return response.json()

# Uso
api = SkyPanelAPI(
    base_url='http://localhost:8080',
    client_id='YOUR_CLIENT_ID',
    client_secret='YOUR_CLIENT_SECRET'
)

# Listar servidores
servers = api.list_servers(name='minecraft*')
print(f"Encontrados {len(servers['servers'])} servidores")

# Iniciar servidor
api.start_server('ABC12345')
print("Servidor iniciado")

# Enviar comando
api.send_command('ABC12345', 'say Hello from Python!')
print("Comando enviado")

npm install axios

const axios = require('axios');

class SkyPanelAPI {
  constructor(baseURL, clientId, clientSecret) {
    this.baseURL = baseURL;
    this.clientId = clientId;
    this.clientSecret = clientSecret;
    this.token = null;
    
    this.client = axios.create({
      baseURL: this.baseURL
    });
  }
  
  async authenticate() {
    const response = await this.client.post('/oauth2/token', 
      new URLSearchParams({
        grant_type: 'client_credentials',
        client_id: this.clientId,
        client_secret: this.clientSecret
      }),
      {
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded'
        }
      }
    );
    
    this.token = response.data.access_token;
    return this.token;
  }
  
  getHeaders() {
    if (!this.token) {
      throw new Error('Not authenticated. Call authenticate() first.');
    }
    
    return {
      'Authorization': `Bearer ${this.token}`,
      'Content-Type': 'application/json'
    };
  }
  
  async listServers(filters = {}) {
    const response = await this.client.get('/api/servers', {
      headers: this.getHeaders(),
      params: filters
    });
    return response.data;
  }
  
  async getServer(serverId) {
    const response = await this.client.get(`/api/servers/${serverId}`, {
      headers: this.getHeaders()
    });
    return response.data;
  }
  
  async startServer(serverId) {
    await this.client.post(`/api/servers/${serverId}/start`, {}, {
      headers: this.getHeaders()
    });
    return true;
  }
  
  async stopServer(serverId) {
    await this.client.post(`/api/servers/${serverId}/stop`, {}, {
      headers: this.getHeaders()
    });
    return true;
  }
  
  async sendCommand(serverId, command) {
    await this.client.post(`/api/servers/${serverId}/console`, 
      { command },
      { headers: this.getHeaders() }
    );
    return true;
  }
  
  async createServer(serverData) {
    const serverId = serverData.identifier || '';
    const response = await this.client.put(`/api/servers/${serverId}`, 
      serverData,
      { headers: this.getHeaders() }
    );
    return response.data;
  }
}

// Uso
(async () => {
  const api = new SkyPanelAPI(
    'http://localhost:8080',
    'YOUR_CLIENT_ID',
    'YOUR_CLIENT_SECRET'
  );
  
  // Autenticar
  await api.authenticate();
  console.log('Autenticado');
  
  // Listar servidores
  const servers = await api.listServers({ name: 'minecraft*' });
  console.log(`Encontrados ${servers.servers.length} servidores`);
  
  // Iniciar servidor
  await api.startServer('ABC12345');
  console.log('Servidor iniciado');
  
  // Enviar comando
  await api.sendCommand('ABC12345', 'say Hello from Node.js!');
  console.log('Comando enviado');
})();