Building REST & GraphQL APIs with Google Antigravity: Complete Backend Development Guide

API development is where Google Antigravity truly shines. Gemini 3 can generate complete API endpoints, handle authentication, create validation schemas, and even write documentation. This guide covers building production-grade APIs.

API Architecture Options

When to Use Each

Type	Best For	Complexity
REST	Simple CRUD, public APIs	Low
GraphQL	Complex data relationships	Medium
tRPC	Type-safe full-stack apps	Low
gRPC	Microservices, high performance	High

REST API with Next.js

Basic API Route

You: "Create a REST API for managing blog posts with CRUD operations"

Gemini 3 generates:

// app/api/posts/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { createClient } from '@/lib/supabase/server';
import { z } from 'zod';

// Validation schemas
const createPostSchema = z.object({
  title: z.string().min(1).max(200),
  content: z.string().min(1),
  published: z.boolean().default(false),
});

const querySchema = z.object({
  page: z.coerce.number().min(1).default(1),
  limit: z.coerce.number().min(1).max(100).default(10),
  published: z.enum(['true', 'false']).optional(),
});

// GET /api/posts - List posts with pagination
export async function GET(request: NextRequest) {
  try {
    const { searchParams } = new URL(request.url);
    const query = querySchema.parse(Object.fromEntries(searchParams));
    
    const supabase = createClient();
    
    let queryBuilder = supabase
      .from('posts')
      .select('*, author:profiles(username, avatar_url)', { count: 'exact' });
    
    if (query.published !== undefined) {
      queryBuilder = queryBuilder.eq('published', query.published === 'true');
    }
    
    const { data, error, count } = await queryBuilder
      .order('created_at', { ascending: false })
      .range((query.page - 1) * query.limit, query.page * query.limit - 1);
    
    if (error) throw error;
    
    return NextResponse.json({
      data,
      pagination: {
        page: query.page,
        limit: query.limit,
        total: count ?? 0,
        totalPages: Math.ceil((count ?? 0) / query.limit),
      },
    });
  } catch (error) {
    if (error instanceof z.ZodError) {
      return NextResponse.json(
        { error: 'Validation failed', details: error.errors },
        { status: 400 }
      );
    }
    console.error('GET /api/posts error:', error);
    return NextResponse.json(
      { error: 'Internal server error' },
      { status: 500 }
    );
  }
}

// POST /api/posts - Create new post
export async function POST(request: NextRequest) {
  try {
    const supabase = createClient();
    
    // Check authentication
    const { data: { user }, error: authError } = await supabase.auth.getUser();
    if (authError || !user) {
      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
    }
    
    // Validate request body
    const body = await request.json();
    const validatedData = createPostSchema.parse(body);
    
    // Create post
    const { data, error } = await supabase
      .from('posts')
      .insert({
        ...validatedData,
        author_id: user.id,
        slug: validatedData.title.toLowerCase().replace(/\s+/g, '-'),
      })
      .select()
      .single();
    
    if (error) throw error;
    
    return NextResponse.json({ data }, { status: 201 });
  } catch (error) {
    if (error instanceof z.ZodError) {
      return NextResponse.json(
        { error: 'Validation failed', details: error.errors },
        { status: 400 }
      );
    }
    console.error('POST /api/posts error:', error);
    return NextResponse.json(
      { error: 'Internal server error' },
      { status: 500 }
    );
  }
}