Quick Start: From Spec to Running API in 30 Minutes

This is where it gets real. In the next 30 minutes, you'll go from your API design in Apidog to a fully working API running on your computer. No weeks of learning. No hundreds of lines of manual coding. Just results.

Here's what we're doing:

Export your API design from Apidog (2 minutes)

Use Cursor to generate a complete project (10 minutes)

Run it locally (5 minutes)

Let's go.

Export Your API Specification (2 minutes)

Your API design in Apidog contains everything the AI needs to generate code. You just need to export it.

Open your User API project in Apidog

Make sure you've completed the "Designing APIs" chapter and have the User module with all six endpoints:

POST /users (register)

POST /user/login

GET /users/{id}

PUT /users/{id}

DELETE /users/{id}

POST /user/logout

Export the OpenAPI specification

Click on your project name in the top left

Go to Settings → Import/Export

Click Export → OpenAPI

Choose OpenAPI 3.0 (not 3.1)

Format: JSON (easier for AI to read)

Click Export

You'll get a file named something like user-api.json. Save it somewhere you can find it easily (like your Desktop).

What you just exported

Open the file in any text editor. You'll see JSON describing your entire API - all your endpoints, request and response schemas, authentication requirements, and data validation rules. This file is the blueprint the AI will use to build your API.

Generate Your Project with Cursor (10 minutes)

Now comes the magic part. You'll give this specification to Cursor and watch it generate a complete, working project.

Create a project folder

Make a new folder somewhere organized:

Or just create it wherever you keep projects. The location doesn't matter.

Open the folder in Cursor

Launch Cursor

File → Open Folder

Select the folder you just created

Add your API specification

Drag your exported user-api.json file into Cursor's file explorer. It should appear in the sidebar.

Open Cursor Composer

Press Cmd+I (Mac) or Ctrl+I (Windows/Linux). This opens Composer mode, which can generate entire projects.

Use this prompt

Copy this entire prompt and paste it into Composer:

I have an OpenAPI 3.0 specification in user-api.json. Generate a complete, production-ready Python FastAPI project that implements this spec exactly.

TECH STACK:
- FastAPI (web framework)
- SQLAlchemy (ORM)
- SQLite for development (easy PostgreSQL migration later)
- JWT authentication (python-jose)
- Password hashing (passlib with bcrypt)
- Pydantic v2 (validation)
- Uvicorn (ASGI server)

REQUIREMENTS:
1. Implement ALL endpoints from the OpenAPI spec
2. Request/response formats must match the spec exactly
3. All HTTP status codes as specified
4. JWT token generation and validation
5. Password hashing (never store plain text)
6. Proper error handling with meaningful messages
7. Input validation matching the schemas
8. CORS enabled for local development
9. Clear code comments explaining key parts

PROJECT STRUCTURE:

user-api/
├── main.py # App entry point, routes registration
├── database.py # Database connection and session
├── auth.py # JWT token functions
├── dependencies.py # Reusable dependencies (get_db, get_current_user)
├── models/
│ └── user.py # SQLAlchemy database model
├── schemas/
│ └── user.py # Pydantic request/response models
├── routers/
│ └── users.py # All user endpoints
├── requirements.txt # Python dependencies
├── .env.example # Environment variables template
└── README.md # Setup and run instructions


IMPORTANT DETAILS:
- Email must be unique (database constraint)
- Password field is write-only (never return it)
- Protected endpoints require valid JWT in Authorization header
- User can only modify/delete their own account
- Tokens expire after 24 hours
- createdAt and updatedAt timestamps auto-managed
- All string inputs trimmed
- Proper HTTP status codes (200, 201, 204, 400, 401, 403, 404, 422)

Generate all files with complete, working code. Make sure it can run immediately after pip install.

Press Enter and watch Cursor generate your project. This takes about 1-2 minutes. You'll see it create files one by one: main.py, database.py, auth.py, and everything else.

Review what was generated

When it's done, you should have 8-10 files. Click through them in Cursor's sidebar. You don't need to understand everything yet, but notice it's a lot of working code you didn't have to write manually. The code has comments, proper structure, and matches your API specification.

If something looks wrong or files are missing, you can ask Cursor to fix it: "You forgot to create .env.example, please add it"

Run Your API Locally (5 minutes)

Let's get this thing running.

Open the terminal in Cursor

Press Ctrl+` (backtick key, usually above Tab). This opens a terminal at the bottom of Cursor.

Create and activate a virtual environment

This keeps your project dependencies isolated:

You should see (venv) appear at the start of your terminal prompt.

Install dependencies

This installs FastAPI, SQLAlchemy, and everything else your API needs. Takes about 30-60 seconds.

Run the API

You should see output like:

INFO:     Uvicorn running on http://127.0.0.1:8000
INFO:     Application startup complete.

Your API is now running!

Quick verification

Open your browser and go to:

http://localhost:8000/docs

You should see FastAPI's automatic documentation (Swagger UI) showing all your endpoints. If you see this page with your six endpoints listed, everything is working perfectly.

What You Just Did

In about 15 minutes, you:

✅ Exported your API design from Apidog as an OpenAPI specification
✅ Used AI to generate a complete FastAPI project with database, authentication, and validation
✅ Got it running locally without errors
✅ Saw your API's interactive documentation

The API you just generated includes:

Six fully implemented endpoints

JWT authentication

Password hashing with bcrypt

SQLite database with SQLAlchemy ORM

Input validation with Pydantic

Proper error handling

CORS support for development

All of this matches your OpenAPI specification exactly. And you didn't write a single line of code manually.

Quick Troubleshooting

"Module not found" error

Make sure you activated the virtual environment

Run pip install -r requirements.txt again

"Port 8000 already in use"

Something else is using port 8000

Run on a different port: uvicorn main:app --reload --port 8001

Cursor didn't generate all files

Ask it: "Please review the project structure and create any missing files"

What's Next

You have a working API running on your computer. But before we test it properly in Apidog, let's understand what this code actually does.

In the next chapter, we'll walk through the generated files and explain how everything fits together. You'll learn how the routing works, how authentication is implemented, how the database is structured, and how requests flow through your API.

Continue with → Understanding the Generated Code

Quick Start: From Spec to Running API in 30 Minutes

Export Your API Specification (2 minutes)#

Generate Your Project with Cursor (10 minutes)#

Run Your API Locally (5 minutes)#

What You Just Did#