v0 Platform API: Automate AI App Generation with REST API

import { v0 } from 'v0-sdk';

async function promptToDeployment(userPrompt: string) {
  try {
    // Step 1: Create project
    console.log('Creating project...');
    const project = await v0.projects.create({
      name: 'AI Generated App'
    });

    // Step 2: Generate code from prompt
    console.log('Generating code from prompt...');
    const chat = await v0.chats.create({
      message: userPrompt,
      system: 'You are an expert React/Next.js developer. Generate production-ready code.',
      projectId: project.id,
      modelConfiguration: {
        modelId: 'v0-auto'
      }
    });

    // Step 3: Parse generated code
    console.log('Parsing generated files...');
    const files = chat.latestVersion?.files ?? [];
    console.log(`Generated ${files.length} files`);

    if (files.length === 0 || !chat.latestVersion?.id) {
      throw new Error('v0 did not return deployable files yet.');
    }

    // Step 4: Create deployment from the latest chat version
    console.log('Deploying to Vercel...');
    const deployment = await v0.deployments.create({
      chatId: chat.id,
      projectId: project.id,
      versionId: chat.latestVersion.id
    });

    console.log('Deployment created.');
    return {
      success: true,
      webUrl: deployment.webUrl,
      inspectorUrl: deployment.inspectorUrl,
      chatId: chat.id,
      projectId: project.id,
      deploymentId: deployment.id,
      files: files.map((file) => file.name)
    };

  } catch (error) {
    console.error('Workflow failed:', error);
    throw error;
  }
}

// Usage
const result = await promptToDeployment(
  'Build a modern landing page with hero section, features grid, testimonials, and contact form. Use Tailwind CSS and shadcn/ui components.'
);

console.log('Live URL:', result.webUrl);
console.log('Inspector:', result.inspectorUrl);
console.log('Generated files:', result.files);

#!/usr/bin/env node
import { Command } from 'commander';
	import { v0 } from 'v0-sdk';
import ora from 'ora';
import chalk from 'chalk';

const program = new Command();

program
  .name('v0-cli')
  .description('CLI tool for v0 Platform API')
  .version('1.0.0');

program
  .command('generate <prompt>')
  .description('Generate code from a prompt')
  .option('-d, --deploy', 'Deploy after generation')
  .option('-o, --output <dir>', 'Output directory for files')
  .action(async (prompt, options) => {
    const spinner = ora('Generating code...').start();
	    try {
	      const chat = await v0.chats.create({
	        message: prompt,
	        modelConfiguration: { modelId: 'v0-auto' }
	      });

      spinner.succeed('Code generated!');

	      // Save files locally
	      if (options.output) {
	        const fs = await import('fs/promises');
	        const path = await import('path');
	        for (const file of chat.latestVersion?.files ?? []) {
	          const filePath = `${options.output}/${file.name}`;
	          await fs.mkdir(path.dirname(filePath), { recursive: true });
	          await fs.writeFile(filePath, file.content);
	        }
        console.log(chalk.green(`✓ Files saved to ${options.output}`));
      }

      // Deploy if requested
	      if (options.deploy) {
	        const deploySpinner = ora('Deploying...').start();
	        if (!chat.projectId || !chat.latestVersion?.id) {
	          throw new Error('Missing project or version for deployment');
	        }
	        const deployment = await v0.deployments.create({
	          chatId: chat.id,
	          projectId: chat.projectId,
	          versionId: chat.latestVersion.id
	        });

	        deploySpinner.succeed('Deployed!');
	        console.log(chalk.blue('🌐 Live URL:', deployment.webUrl));
	        console.log(chalk.gray('📝 Edit:', `https://v0.dev/chat/${chat.id}`));
	      }

    } catch (error) {
      spinner.fail('Generation failed');
      console.error(chalk.red(error.message));
      process.exit(1);
    }
  });

program
  .command('deploy <chatId>')
  .description('Deploy an existing chat')
  .action(async (chatId) => {
    const spinner = ora('Deploying...').start();
	    try {
	      throw new Error('Deploy requires projectId and versionId from a chat version');
	    } catch (error) {
	      spinner.fail('Deployment failed');
	      console.error(chalk.red(error.message));
    }
  });

program.parse();

// Usage:
// v0-cli generate "Build a blog with posts list and detail pages" --deploy
// v0-cli deploy chat_123abc --output ./my-app

# .github/workflows/v0-deploy.yml
name: V0 Auto Deploy

on:
  issues:
    types: [labeled]

jobs:
  generate-and-deploy:
    if: github.event.label.name == 'v0-generate'
    runs-on: ubuntu-latest

    steps:
	      - uses: actions/checkout@v4

	      - name: Setup Node.js
	        uses: actions/setup-node@v4
	        with:
	          node-version: '22'

      - name: Install dependencies
        run: npm install v0-sdk

      - name: Generate and Deploy
        env:
          V0_API_KEY: ${{ secrets.V0_API_KEY }}
        run: |
          node <<'EOF'
	          const { v0 } = require('v0-sdk');

          async function deploy() {
            const issueBody = process.env.GITHUB_EVENT_ISSUE_BODY;

            const result = await promptToDeployment(issueBody);

            // Comment on issue with results
            await fetch(
              `https://api.github.com/repos/${process.env.GITHUB_REPOSITORY}/issues/${process.env.GITHUB_EVENT_ISSUE_NUMBER}/comments`,
              {
                method: 'POST',
                headers: {
                  'Authorization': `token ${process.env.GITHUB_TOKEN}`,
                  'Content-Type': 'application/json'
                },
                body: JSON.stringify({
                  body: `## ✅ Deployed!\n\n🌐 Live: ${result.webUrl}\n📝 Edit: https://v0.dev/chat/${result.chatId}`
                })
              }
            );
          }

          deploy().catch(console.error);
          EOF

import { createClient } from 'v0-sdk';

class V0ApiService {
  private client = createClient({
    apiKey: process.env.V0_API_KEY,
    baseUrl: 'https://api.v0.dev/v1'
  });
  private maxRetries = 3;

  async generateWithRetry(prompt: string, retryCount = 0): Promise<any> {
    try {
      const chat = await this.client.chats.create({
        message: prompt,
        modelConfiguration: { modelId: 'v0-auto' }
      });

      // Validate response
      if (!chat.latestVersion?.files?.length) {
        throw new Error('No code generated');
      }

      return chat;

    } catch (error) {
      const apiError = error as { status?: number; code?: string; message?: string };

      if (apiError.status === 429 || apiError.code === 'rate_limit_exceeded') {
        if (retryCount < this.maxRetries) {
          const delay = Math.pow(2, retryCount) * 1000;
          console.log(`Rate limited. Retrying in ${delay}ms...`);
          await new Promise(resolve => setTimeout(resolve, delay));
          return this.generateWithRetry(prompt, retryCount + 1);
        }
      }

      // Log unexpected errors
      console.error('V0 API Error:', {
        error,
        prompt: prompt.substring(0, 100),
        retryCount,
        timestamp: new Date().toISOString()
      });

      throw error;
    }
  }

  async safeDeployment(projectId: string, chatId: string, versionId: string): Promise<any> {
    try {
      const deployment = await this.client.deployments.create({
        projectId,
        chatId,
        versionId
      });

      return this.client.deployments.getById({
        deploymentId: deployment.id
      });

    } catch (error) {
      console.error('Deployment Error:', error);
      throw error;
    }
  }
}