X-Pilot API Reference

# Sign in and capture the access token
TOKEN=$(curl -s -X POST https://api.x-pilot.ai/auth/sign_in \
  -H "Content-Type: application/json" \
  -d '{"email":"[email protected]","password":"yourpassword"}' \
  | jq -r '.access_token')

# Use in subsequent requests
curl -X GET https://api.x-pilot.ai/users/me \
  -H "Authorization: Bearer $TOKEN"

const res = await fetch('https://api.x-pilot.ai/auth/sign_in', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ email: '[email protected]', password: 'yourpassword' })
});
const { access_token, refresh_token, expires_in } = await res.json();

// Store tokens securely
localStorage.setItem('xpilot_token', access_token);

// Helper for authenticated requests
const api = (path, opts = {}) =>
  fetch(`https://api.x-pilot.ai${path}`, {
    ...opts,
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${localStorage.getItem('xpilot_token')}`,
      ...opts.headers
    }
  }).then(r => r.json());

import requests

BASE = 'https://api.x-pilot.ai'

resp = requests.post(f'{BASE}/auth/sign_in', json={
    'email': '[email protected]',
    'password': 'yourpassword'
})
data = resp.json()
access_token = data['access_token']
refresh_token = data['refresh_token']

# Session helper
session = requests.Session()
session.headers.update({
    'Authorization': f'Bearer {access_token}',
    'Content-Type': 'application/json'
})

curl -X POST https://api.x-pilot.ai/auth/sign_up \
  -H "Content-Type: application/json" \
  -d '{"email":"[email protected]","password":"securepass","name":"Jane Dev"}'

const { access_token } = await api('/auth/sign_up', {
  method: 'POST',
  body: JSON.stringify({
    email: '[email protected]',
    password: 'securepass',
    name: 'Jane Dev'
  })
});

resp = requests.post(f'{BASE}/auth/sign_up', json={
    'email': '[email protected]',
    'password': 'securepass',
    'name': 'Jane Dev'
})

// In Google Sign-In callback handler
function handleCredentialResponse(response) {
  const googleToken = response.credential;
  fetch('https://api.x-pilot.ai/api/auth/google', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ token: googleToken })
  })
  .then(r => r.json())
  .then(({ access_token }) => {
    localStorage.setItem('xpilot_token', access_token);
  });
}

resp = session.post(f'{BASE}/api/auth/google', json={
    'token': google_id_token
})
access_token = resp.json()['access_token']

curl https://api.x-pilot.ai/users/me \
  -H "Authorization: Bearer $TOKEN"

const user = await api('/users/me');
console.log(`Plan: ${user.plan}, Credits: ${user.credits}`);

user = session.get(f'{BASE}/users/me').json()
print(f'Plan: {user["plan"]}, Credits: {user["credits"]}')

curl "https://api.x-pilot.ai/api/video/projects?page=1&limit=20" \
  -H "Authorization: Bearer $TOKEN"

const { data, total, page } = await api('/api/video/projects?page=1&limit=20');

projects = session.get(f'{BASE}/api/video/projects', params={'page': 1, 'limit': 20}).json()

curl -X POST https://api.x-pilot.ai/api/video/projects \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"title":"Python Async Course","language":"en"}'

const project = await api('/api/video/projects', {
  method: 'POST',
  body: JSON.stringify({
    title: 'Python Async Course',
    language: 'en'
  })
});
const projectId = project.id;

project = session.post(f'{BASE}/api/video/projects', json={
    'title': 'Python Async Course',
    'language': 'en'
}).json()
project_id = project['id']

curl https://api.x-pilot.ai/api/video/projects/proj_abc123 \
  -H "Authorization: Bearer $TOKEN"

const project = await api(`/api/video/projects/${projectId}`);

curl -X POST https://api.x-pilot.ai/api/video/projects/proj_abc123/chat-message \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"message":"Create a 5-slide explainer on Python async/await with code examples and animations"}'

const { task_id, message_id } = await api(
  `/api/video/projects/${projectId}/chat-message`,
  {
    method: 'POST',
    body: JSON.stringify({
      message: 'Create a 5-slide explainer on Python async/await with code examples and animations',
      mode: 'generate'
    })
  }
);

resp = session.post(
    f'{BASE}/api/video/projects/{project_id}/chat-message',
    json={
        'message': 'Create a 5-slide explainer on Python async/await',
        'mode': 'generate'
    }
).json()
task_id = resp['task_id']

curl "https://api.x-pilot.ai/api/video/projects/proj_abc123/messages?limit=50" \
  -H "Authorization: Bearer $TOKEN"

const { messages } = await api(`/api/video/projects/${projectId}/messages?limit=50`);

# Trigger
curl -X POST https://api.x-pilot.ai/api/video/projects/proj_abc123/generate-audio \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"speed":1.1}'

# Poll
curl https://api.x-pilot.ai/api/video/projects/proj_abc123/generate-audio \
  -H "Authorization: Bearer $TOKEN"

// Trigger
await api(`/api/video/projects/${projectId}/generate-audio`, {
  method: 'POST', body: JSON.stringify({ speed: 1.1 })
});

// Poll helper
async function pollAudio(projectId, interval = 3000) {
  while (true) {
    const status = await api(`/api/video/projects/${projectId}/generate-audio`);
    if (status.state === 'completed') return status;
    if (status.state === 'failed') throw new Error(status.error);
    await new Promise(r => setTimeout(r, interval));
  }
}

# 1. Trigger export
JOB=$(curl -s -X POST https://api.x-pilot.ai/api/video/projects/proj_abc123/export-video \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"resolution":"1080p","fps":30}' | jq -r '.job_id')

# 2. Poll until done
while true; do
  RESULT=$(curl -s https://api.x-pilot.ai/api/video/projects/proj_abc123/export-video \
    -H "Authorization: Bearer $TOKEN")
  STATE=$(echo $RESULT | jq -r '.state')
  [ "$STATE" = "completed" ] && echo $RESULT | jq -r '.download_url' && break
  sleep 5
done

async function exportAndDownload(projectId) {
  // Trigger
  await api(`/api/video/projects/${projectId}/export-video`, {
    method: 'POST',
    body: JSON.stringify({ resolution: '1080p', fps: 30, include_captions: false })
  });

  // Poll with exponential backoff
  let delay = 3000;
  while (true) {
    const job = await api(`/api/video/projects/${projectId}/export-video`);
    if (job.state === 'completed') return job.download_url;
    if (job.state === 'failed') throw new Error(`Export failed: ${job.error}`);
    await new Promise(r => setTimeout(r, delay));
    delay = Math.min(delay * 1.5, 15000); // max 15s
  }
}

import time

def export_video(project_id, resolution='1080p'):
    url = f'{BASE}/api/video/projects/{project_id}/export-video'
    # Trigger
    session.post(url, json={'resolution': resolution, 'fps': 30})
    # Poll
    delay = 3
    while True:
        job = session.get(url).json()
        if job['state'] == 'completed':
            return job['download_url']
        if job['state'] == 'failed':
            raise RuntimeError(job.get('error'))
        time.sleep(delay)
        delay = min(delay * 1.5, 15)

curl -X POST https://api.x-pilot.ai/api/v1/user_case/share-simple \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"project_id":"proj_abc123","expires_hours":72}'

const { share_url } = await api('/api/v1/user_case/share-simple', {
  method: 'POST',
  body: JSON.stringify({ project_id: projectId, expires_hours: 72 })
});

curl -X POST https://api.x-pilot.ai/api/tasks/create \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"project_id":"proj_abc123","type":"full_pipeline","priority":8}'

const task = await api('/api/tasks/create', {
  method: 'POST',
  body: JSON.stringify({
    project_id: projectId,
    type: 'full_pipeline',
    priority: 8
  })
});

task = session.post(f'{BASE}/api/tasks/create', json={
    'project_id': project_id,
    'type': 'full_pipeline',
    'priority': 8
}).json()

curl https://api.x-pilot.ai/api/tasks/task_xyz789 \
  -H "Authorization: Bearer $TOKEN"

// Polling with exponential backoff
async function waitForTask(taskId, onProgress) {
  let delay = 3000, maxDelay = 20000;
  while (true) {
    const task = await api(`/api/tasks/${taskId}`);
    onProgress?.(task.progress, task.status);
    if (task.status === 'completed') return task.result;
    if (task.status === 'failed') throw new Error(task.error);
    await new Promise(r => setTimeout(r, delay));
    delay = Math.min(delay * 1.4, maxDelay);
  }
}

def wait_for_task(task_id, poll_interval=3):
    delay = poll_interval
    while True:
        task = session.get(f'{BASE}/api/tasks/{task_id}').json()
        print(f'Task {task["status"]}: {task.get("progress", 0)}%')
        if task['status'] == 'completed':
            return task['result']
        if task['status'] == 'failed':
            raise RuntimeError(task.get('error'))
        time.sleep(delay)
        delay = min(delay * 1.4, 20)

curl -X POST https://api.x-pilot.ai/api/tasks/regenerate \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"task_id":"task_xyz789"}'

const newTask = await api('/api/tasks/regenerate', {
  method: 'POST', body: JSON.stringify({ task_id: taskId })
});

curl -X POST https://api.x-pilot.ai/knowledgeBase/create \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name":"Python Fundamentals","description":"Core Python language concepts","tags":["python","programming"]}'

const kb = await api('/knowledgeBase/create', {
  method: 'POST',
  body: JSON.stringify({ name: 'Python Fundamentals', tags: ['python'] })
});

curl -X POST https://api.x-pilot.ai/knowledgeBase/file/upload/single \
  -H "Authorization: Bearer $TOKEN" \
  -F "file=@/path/to/course-notes.pdf" \
  -F "knowledge_base_id=kb_abc123"

const form = new FormData();
form.append('file', fileBlob, 'course-notes.pdf');
form.append('knowledge_base_id', kbId);

const result = await fetch('https://api.x-pilot.ai/knowledgeBase/file/upload/single', {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${token}` },
  body: form
}).then(r => r.json());

with open('course-notes.pdf', 'rb') as f:
    resp = session.post(
        f'{BASE}/knowledgeBase/file/upload/single',
        files={'file': ('course-notes.pdf', f, 'application/pdf')},
        data={'knowledge_base_id': kb_id}
    ).json()

curl -X POST https://api.x-pilot.ai/file/upload \
  -H "Authorization: Bearer $TOKEN" \
  -F "file=@/path/to/slides.pptx"

const form = new FormData();
form.append('file', file);
const { file_id, url } = await fetch('https://api.x-pilot.ai/file/upload', {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${token}` },
  body: form
}).then(r => r.json());

curl -X POST https://api.x-pilot.ai/api/document/parse/multiple \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"file_ids":["file_abc","file_def"],"output_format":"markdown"}'

const { documents } = await api('/api/document/parse/multiple', {
  method: 'POST',
  body: JSON.stringify({ file_ids: [fileId], output_format: 'markdown' })
});

curl https://api.x-pilot.ai/api/audio/model/list \
  -H "Authorization: Bearer $TOKEN"

const { models } = await api('/api/audio/model/list');
// model: { id, name, language, gender, type: "builtin"|"custom" }

curl -X POST https://api.x-pilot.ai/api/audio/model \
  -H "Authorization: Bearer $TOKEN" \
  -F "name=My Lecturer Voice" \
  -F "reference_audio=@/path/to/sample.wav" \
  -F "language=en"

const form = new FormData();
form.append('name', 'My Lecturer Voice');
form.append('reference_audio', audioFile);
form.append('language', 'en');

const model = await fetch('https://api.x-pilot.ai/api/audio/model', {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${token}` },
  body: form
}).then(r => r.json());

with open('sample.wav', 'rb') as f:
    model = session.post(
        f'{BASE}/api/audio/model',
        files={'reference_audio': ('sample.wav', f, 'audio/wav')},
        data={'name': 'My Lecturer Voice', 'language': 'en'}
    ).json()

# Update name
curl -X PUT https://api.x-pilot.ai/api/audio/model/vm_abc123 \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name":"Updated Voice Name"}'

# Delete
curl -X DELETE https://api.x-pilot.ai/api/audio/model/vm_abc123 \
  -H "Authorization: Bearer $TOKEN"

// Update
await api(`/api/audio/model/${modelId}`, {
  method: 'PUT', body: JSON.stringify({ name: 'Updated Voice' })
});
// Delete
await api(`/api/audio/model/${modelId}`, { method: 'DELETE' });

curl -X POST https://api.x-pilot.ai/api/payments/create-checkout-session \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"price_id":"price_pro_monthly","success_url":"https://yourapp.com/success","cancel_url":"https://yourapp.com/cancel"}'

const { checkout_url } = await api('/api/payments/create-checkout-session', {
  method: 'POST',
  body: JSON.stringify({
    price_id: 'price_pro_monthly',
    success_url: `${location.origin}/success`,
    cancel_url: `${location.origin}/price`
  })
});
window.location.href = checkout_url;

curl -X POST https://api.x-pilot.ai/api/payments/billing-portal \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"return_url":"https://yourapp.com/settings"}'

const { portal_url } = await api('/api/payments/billing-portal', {
  method: 'POST',
  body: JSON.stringify({ return_url: `${location.origin}/settings` })
});
window.location.href = portal_url;