Midjourney API Quickstart

{
  "taskType": "mj_txt2img",
  "prompt": "A futuristic cityscape with flying cars and neon lights",
  "aspectRatio": "16:9",
  "version": "7"
}

class MidjourneyAPI {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://api.kie.ai/api/v1/mj';
  }
  
  async generateImage(options) {
    const response = await fetch(`${this.baseUrl}/generate`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(options)
    });
    
    const result = await response.json();
    if (!response.ok || result.code !== 200) {
      throw new Error(`Generation failed: ${result.msg || 'Unknown error'}`);
    }
    
    return result.data.taskId;
  }
  
  async waitForCompletion(taskId, maxWaitTime = 600000) { // Max wait 10 minutes
    const startTime = Date.now();
    
    while (Date.now() - startTime < maxWaitTime) {
      const status = await this.getTaskStatus(taskId);
      
      switch (status.successFlag) {
        case 0:
          console.log('Task is generating, continue waiting...');
          break;
          
        case 1:
          console.log('Generation completed successfully!');
          return status.resultInfoJson;
          
        case 2:
          const taskError = status.errorMessage || 'Task generation failed';
          console.error('Task generation failed:', taskError);
          if (status.errorCode) {
            console.error('Error code:', status.errorCode);
          }
          throw new Error(taskError);
          
        case 3:
          const generateError = status.errorMessage || 'Task created successfully but generation failed';
          console.error('Generation failed:', generateError);
          if (status.errorCode) {
            console.error('Error code:', status.errorCode);
          }
          throw new Error(generateError);
          
        default:
          console.log(`Unknown status: ${status.successFlag}`);
          if (status.errorMessage) {
            console.error('Error message:', status.errorMessage);
          }
          break;
      }
      
      // Wait 30 seconds before checking again
      await new Promise(resolve => setTimeout(resolve, 30000));
    }
    
    throw new Error('Generation timeout');
  }
  
  async getTaskStatus(taskId) {
    const response = await fetch(`${this.baseUrl}/record-info?taskId=${taskId}`, {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`
      }
    });
    
    const result = await response.json();
    if (!response.ok || result.code !== 200) {
      throw new Error(`Status check failed: ${result.msg || 'Unknown error'}`);
    }
    
    return result.data;
  }
  
  async upscaleImage(taskId, index) {
    const response = await fetch(`${this.baseUrl}/upscale`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        taskId,
        index
      })
    });
    
    const result = await response.json();
    if (!response.ok || result.code !== 200) {
      throw new Error(`Upscale failed: ${result.msg || 'Unknown error'}`);
    }
    
    return result.data.taskId;
  }
}

// Usage example
async function main() {
  const api = new MidjourneyAPI('YOUR_API_KEY');
  
  try {
    // Text-to-image generation
    console.log('Starting image generation...');
    const taskId = await api.generateImage({
      taskType: 'mj_txt2img',
      prompt: 'A majestic ancient castle perched on a misty mountain peak, golden sunset light illuminating the stone walls',
      speed: 'fast',
      aspectRatio: '16:9',
      version: '7',
      stylization: 500
    });
    
    // Wait for completion
    console.log(`Task ID: ${taskId}. Waiting for completion...`);
    const result = await api.waitForCompletion(taskId);
    
    console.log('Image generation successful!');
    console.log('Generated images count:', result.resultUrls.length);
    result.resultUrls.forEach((urlInfo, index) => {
      console.log(`Image ${index + 1}: ${urlInfo.resultUrl}`);
    });
    
    // Upscale the first image
    console.log('\nStarting upscale of first image...');
    const upscaleTaskId = await api.upscaleImage(taskId, 1);
    
    const upscaleResult = await api.waitForCompletion(upscaleTaskId);
    console.log('Image upscale successful!');
    console.log('Upscaled image:', upscaleResult.resultUrls[0].resultUrl);
    
  } catch (error) {
    console.error('Error:', error.message);
  }
}

main();