rocket-net-api（rocket NET API 搜索）

Rocket.net API Integration

Build integrations with Rocket.net's managed WordPress hosting platform API. This skill covers authentication, site management, domain configuration, backups, plugins/themes, CDN cache control, and all 200+ API endpoints.

API Overview

Base URL: https://api.rocket.net/v1

Authentication: JWT token-based

• Obtain token via POST /login with email/password
• Token expires in 7 days
• Include in requests as Authorization: Bearer <token>

Content Type: JSON API

• Required header: Content-Type: application/json
• Recommended header: Accept: application/json

Documentation: https://rocketdotnet.readme.io/reference/introduction

Authentication

Get JWT Token

const response = await fetch('https://api.rocket.net/v1/login', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Accept': 'application/json'
  },
  body: JSON.stringify({
    username: 'your-email@example.com',
    password: 'your-password'
  })
});

const { token } = await response.json();
// Use token in subsequent requests

Authenticated Request Pattern

async function rocketApiRequest(
  endpoint: string,
  options: RequestInit = {}
): Promise<any> {
  const response = await fetch(`https://api.rocket.net/v1${endpoint}`, {
    ...options,
    headers: {
      'Content-Type': 'application/json',
      'Accept': 'application/json',
      'Authorization': `Bearer ${token}`,
      ...options.headers
    }
  });

  if (response.status === 401) {
    // Token expired, re-authenticate
    throw new Error('Token expired - request new token');
  }

  return response.json();
}

API Endpoints by Category

Sites Management

Staging Sites

Site Templates

Domains

CDN Cache

Plugins

Themes

Backups

Cloud Backups

Files

FTP Accounts

SSH Keys

WordPress

Reporting

Account Management

Account Users

Site Users

Billing

Additional Features

Common Patterns

List All Sites

const sites = await rocketApiRequest('/sites');
console.log(sites);
// Returns array of site objects with id, domain, status, etc.

Create a New Site

const newSite = await rocketApiRequest('/sites', {
  method: 'POST',
  body: JSON.stringify({
    name: 'my-new-site',
    location: 'us-east-1',
    // Additional options as needed
  })
});

Purge CDN Cache

// Purge specific URLs
await rocketApiRequest(`/sites/${siteId}/cache/purge`, {
  method: 'POST',
  body: JSON.stringify({
    files: [
      'https://example.com/style.css',
      'https://example.com/script.js'
    ]
  })
});

// Purge everything
await rocketApiRequest(`/sites/${siteId}/cache/purge_everything`, {
  method: 'POST'
});

Create and Restore Backup

// Create backup
const backup = await rocketApiRequest(`/sites/${siteId}/backup`, {
  method: 'POST'
});

// List backups
const backups = await rocketApiRequest(`/sites/${siteId}/backup`);

// Restore backup (background task)
await rocketApiRequest(`/sites/${siteId}/backup/${backupId}/restore`, {
  method: 'POST'
});

Manage Plugins

// List installed plugins
const plugins = await rocketApiRequest(`/sites/${siteId}/plugins`);

// Install plugin
await rocketApiRequest(`/sites/${siteId}/plugins`, {
  method: 'POST',
  body: JSON.stringify({
    plugins: ['wordfence', 'yoast-seo']
  })
});

// Update all plugins
await rocketApiRequest(`/sites/${siteId}/plugins`, {
  method: 'PUT',
  body: JSON.stringify({
    plugins: ['all']
  })
});

// Activate/deactivate plugin
await rocketApiRequest(`/sites/${siteId}/plugins`, {
  method: 'PATCH',
  body: JSON.stringify({
    plugins: ['wordfence'],
    action: 'activate' // or 'deactivate'
  })
});

Execute WP-CLI Commands

const result = await rocketApiRequest(`/sites/${siteId}/wpcli`, {
  method: 'POST',
  body: JSON.stringify({
    command: 'user list --format=json'
  })
});

WordPress SSO Login

// Get SSO link for WordPress admin
const { url } = await rocketApiRequest(`/sites/${siteId}/wp_login`);
// Redirect user to url for auto-login

TypeScript Types

interface RocketSite {
  id: number;
  name: string;
  domain: string;
  status: 'active' | 'suspended' | 'pending';
  location: string;
  created_at: string;
  updated_at: string;
}

interface RocketBackup {
  id: number;
  site_id: number;
  type: 'manual' | 'automated' | 'cloud';
  status: 'pending' | 'completed' | 'failed';
  size: number;
  created_at: string;
}

interface RocketPlugin {
  name: string;
  slug: string;
  version: string;
  status: 'active' | 'inactive';
  update_available: boolean;
}

interface RocketDomain {
  id: number;
  domain: string;
  is_main: boolean;
  ssl_status: 'pending' | 'active' | 'failed';
  validation_method: 'dns' | 'http';
}

interface RocketAuthResponse {
  token: string;
  expires_at: string;
}

Error Handling

interface RocketApiError {
  error: string;
  message: string;
  status: number;
}

async function handleRocketRequest(endpoint: string, options?: RequestInit) {
  try {
    const response = await rocketApiRequest(endpoint, options);
    return { data: response, error: null };
  } catch (error) {
    if (error.status === 401) {
      // Re-authenticate and retry
      await refreshToken();
      return handleRocketRequest(endpoint, options);
    }
    if (error.status === 404) {
      return { data: null, error: 'Resource not found' };
    }
    if (error.status === 429) {
      // Rate limited - wait and retry
      await sleep(1000);
      return handleRocketRequest(endpoint, options);
    }
    return { data: null, error: error.message };
  }
}

Background Tasks

Many operations (clone, backup restore, staging publish) run as background tasks. Monitor task status:

// Start a background task
const { task_id } = await rocketApiRequest(`/sites/${siteId}/clone`, {
  method: 'POST',
  body: JSON.stringify({ name: 'cloned-site' })
});

// Check task status
const tasks = await rocketApiRequest(`/sites/${siteId}/tasks`);
const task = tasks.find(t => t.id === task_id);
console.log(task.status); // 'pending', 'running', 'completed', 'failed'

// Cancel task if needed
await rocketApiRequest(`/sites/${siteId}/tasks/${task_id}/cancel`, {
  method: 'POST'
});

Rate Limits

The API has rate limits. Implement exponential backoff:

async function withRetry<T>(
  fn: () => Promise<T>,
  maxRetries = 3,
  delay = 1000
): Promise<T> {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (error.status === 429 && i < maxRetries - 1) {
        await new Promise(resolve => setTimeout(resolve, delay * Math.pow(2, i)));
        continue;
      }
      throw error;
    }
  }
  throw new Error('Max retries exceeded');
}

References

• Rocket.net API Documentation
• Rocket.net Control Panel
• Rocket.net WordPress Hosting