Claude Code से REST API बनाएं | शुरुआती लोगों के लिए व्यावहारिक गाइड

“REST API के साथ कहाँ से शुरू करूं, मुझे समझ नहीं आता” — शुरुआत में मैं भी ऐसा ही सोचता था।

Documentation पढ़ना बहुत abstract लगता था। समझ नहीं आता था कि असल में क्या बनाना है। तब मैंने Claude Code इस्तेमाल करना शुरू किया और एहसास हुआ कि “पहले कुछ काम करने वाला बनाओ, सीखते जाओ” सबसे तेज़ तरीका है।

इस गाइड में हम REST API की बिल्कुल बुनियाद से एक पूरी तरह काम करने वाली API तक जाएंगे — step by step, Claude Code के साथ। सारे code snippets copy-paste के लिए तैयार हैं।

---

REST API क्या है? (3 लाइनों में)

REST API एक convention है HTTP के ज़रिए web पर resources (data) को manipulate करने की।

Browser/App  →  HTTP Request  →  Server (API)
             ←  JSON Response  ←

User management API के लिए यह ऐसा दिखता है:

लक्ष्य	HTTP Method	URL
सभी users पाएं	GET	/users
एक specific user पाएं	GET	/users/123
User बनाएं	POST	/users
User update करें	PUT	/users/123
User delete करें	DELETE	/users/123

यह समझ आ गया तो Claude Code के साथ बनाना शुरू कर सकते हैं।

---

Environment Setup

हम Hono इस्तेमाल करेंगे — एक lightweight TypeScript web framework। यह Express से ज़्यादा type-safe है और Claude Code के साथ बेहतरीन काम करता है।

mkdir my-first-api
cd my-first-api
npm init -y
npm install hono
npm install -D typescript @types/node ts-node
npx tsc --init

src/index.ts बनाएं और Claude Code से पूछें:

claude -p "
src/index.ts में Hono का इस्तेमाल करके REST API boilerplate बनाओ।
- Port 3000 पर server शुरू करो
- Health check के लिए GET /health endpoint जोड़ो
- JSON responses return करो
Run command: npx ts-node src/index.ts
"

Claude Code कुछ ऐसा generate करेगा:

// src/index.ts
import { Hono } from "hono";
import { serve } from "@hono/node-server";

const app = new Hono();

app.get("/health", (c) => {
  return c.json({ status: "ok", timestamp: new Date().toISOString() });
});

serve({ fetch: app.fetch, port: 3000 }, () => {
  console.log("Server running at http://localhost:3000");
});

npx ts-node src/index.ts
# → Server running at http://localhost:3000

curl http://localhost:3000/health
# → {"status":"ok","timestamp":"2026-04-27T07:30:00.000Z"}

काम किया? यही REST API की शुरुआत है।

---

Step 1: Basic CRUD बनाएं

अब Todo list manage करने वाली API बनाते हैं। Claude Code से कहें:

claude -p "
src/index.ts में Todo के CRUD endpoints जोड़ो।
- GET  /todos         — सभी todos की list
- GET  /todos/:id     — एक todo
- POST /todos         — Create करें (title: string ज़रूरी)
- PUT  /todos/:id     — Update करें (title: string)
- DELETE /todos/:id   — Delete करें

Data को in-memory array में manage करो।
Todo type: { id: string, title: string, done: boolean, createdAt: string }
id को crypto.randomUUID() से generate करो
"

Generate हुआ code:

import { Hono } from "hono";
import { serve } from "@hono/node-server";

const app = new Hono();

// In-memory data store
type Todo = { id: string; title: string; done: boolean; createdAt: string };
let todos: Todo[] = [];

// सभी todos पाएं
app.get("/todos", (c) => c.json(todos));

// एक todo पाएं
app.get("/todos/:id", (c) => {
  const todo = todos.find((t) => t.id === c.req.param("id"));
  if (!todo) return c.json({ error: "Not found" }, 404);
  return c.json(todo);
});

// Create करें
app.post("/todos", async (c) => {
  const body = await c.req.json();
  if (!body.title) return c.json({ error: "title is required" }, 400);
  const todo: Todo = {
    id: crypto.randomUUID(),
    title: body.title,
    done: false,
    createdAt: new Date().toISOString(),
  };
  todos.push(todo);
  return c.json(todo, 201);
});

// Update करें
app.put("/todos/:id", async (c) => {
  const idx = todos.findIndex((t) => t.id === c.req.param("id"));
  if (idx === -1) return c.json({ error: "Not found" }, 404);
  const body = await c.req.json();
  todos[idx] = { ...todos[idx], ...body };
  return c.json(todos[idx]);
});

// Delete करें
app.delete("/todos/:id", (c) => {
  const idx = todos.findIndex((t) => t.id === c.req.param("id"));
  if (idx === -1) return c.json({ error: "Not found" }, 404);
  todos.splice(idx, 1);
  return c.json({ message: "Deleted" });
});

serve({ fetch: app.fetch, port: 3000 }, () => {
  console.log("Server running at http://localhost:3000");
});

आज़माकर देखें:

# Todo बनाएं
curl -X POST http://localhost:3000/todos \
  -H "Content-Type: application/json" \
  -d '{"title": "Claude Code try करें"}'

# सभी todos पाएं
curl http://localhost:3000/todos

# Delete करें (ऊपर मिला id इस्तेमाल करें)
curl -X DELETE http://localhost:3000/todos/<id>

---

Step 2: Validation जोड़ें

“खाली title से भी todo बन जाता है” या “कोई भी string ID की तरह काम करती है” — validation ऐसी समस्याओं को रोकता है। Claude Code से कहें:

claude -p "
POST /todos और PUT /todos/:id के लिए zod से validation जोड़ो।
- title: string, 1-100 characters
- done: (सिर्फ PUT) boolean
Validation fail होने पर specific error message के साथ 400 error return करो
"

npm install zod

Claude Code zod schemas जोड़ेगा:

import { z } from "zod";

const CreateTodoSchema = z.object({
  title: z.string().min(1, "Title कम से कम 1 character का होना चाहिए").max(100, "Title 100 characters से ज़्यादा नहीं होना चाहिए"),
});

const UpdateTodoSchema = z.object({
  title: z.string().min(1).max(100).optional(),
  done: z.boolean().optional(),
});

// POST /todos (validation के साथ)
app.post("/todos", async (c) => {
  const body = await c.req.json().catch(() => ({}));
  const result = CreateTodoSchema.safeParse(body);
  if (!result.success) {
    return c.json({ error: result.error.flatten().fieldErrors }, 400);
  }
  const todo: Todo = {
    id: crypto.randomUUID(),
    title: result.data.title,
    done: false,
    createdAt: new Date().toISOString(),
  };
  todos.push(todo);
  return c.json(todo, 201);
});

Validation errors check करें:

# Title के बिना create करें → error आना चाहिए
curl -X POST http://localhost:3000/todos \
  -H "Content-Type: application/json" \
  -d '{}'
# → {"error":{"title":["Title कम से कम 1 character का होना चाहिए"]}}

---

Step 3: Error Handling एकजुट करें

अभी हर endpoint अलग-अलग format में errors return करता है। Claude Code से standardize करवाएं:

claude -p "
Error handling को एकजुट करो।
- Common error response format: { error: { code: string, message: string } }
- 404: NOT_FOUND
- 400: VALIDATION_ERROR
- 500: INTERNAL_SERVER_ERROR
Hono के onError से global error handler implement करो
"

// Error type definition
class AppError extends Error {
  constructor(
    public code: string,
    public message: string,
    public statusCode: number = 400
  ) {
    super(message);
  }
}

// Global error handler
app.onError((err, c) => {
  if (err instanceof AppError) {
    return c.json(
      { error: { code: err.code, message: err.message } },
      err.statusCode as any
    );
  }
  console.error(err);
  return c.json(
    { error: { code: "INTERNAL_SERVER_ERROR", message: "एक अप्रत्याशित error हुई" } },
    500
  );
});

// इस्तेमाल
app.get("/todos/:id", (c) => {
  const todo = todos.find((t) => t.id === c.req.param("id"));
  if (!todo) throw new AppError("NOT_FOUND", "Todo नहीं मिला", 404);
  return c.json(todo);
});

---

Step 4: Swagger UI Documentation Auto-generate करें

API बना लेने के बाद documentation भी चाहिए। Claude Code कुछ मिनटों में set up कर देता है:

claude -p "
@hono/swagger-ui और @hono/zod-openapi का इस्तेमाल करके
/docs पर Swagger UI जोड़ो।
मौजूदा endpoints में OpenAPI schemas जोड़ो।
"

npm install @hono/swagger-ui @hono/zod-openapi

हो जाने के बाद http://localhost:3000/docs पर जाएं और API documentation देखें।

---

Claude Code के साथ API Development का Flow (सारांश)

यह वो flow है जो मैं रोज़ इस्तेमाल करता हूं:

1. Claude Code को बताएं "मुझे ऐसी API चाहिए जो X करे"
    ↓
2. Generate हुआ code review करें और test करें
    ↓
3. Iterate करें: "यह ठीक करो", "validation जोड़ो", आदि
    ↓
4. Tests pass होने पर git commit करें

मेरी पहली रुकावट (असली अनुभव)

जब मैंने अपनी पहली API बनाई, तो error handling पूरी तरह छोड़ दी और बाद में जोड़नी पड़ी — जिसमें बहुत समय लगा। अब मैं शुरू से ही “error handling भी include करो” prompt में लिख देता हूं, और code शुरू से ही अच्छा आता है। Claude Code का trick है शुरू से ही सभी requirements एक साथ देना।

---

3 आम गलतियां

गलती 1: JSON parse errors को ignore करना

// ❌ यहाँ errors किसी को पता नहीं चलते
const body = await c.req.json();

// ✅ Parse failures को catch करें
const body = await c.req.json().catch(() => null);
if (!body) return c.json({ error: "Invalid JSON" }, 400);

गलती 2: 404 और 400 को confuse करना

400: Request खुद गलत है (validation error, required field missing)
404: Resource exist नहीं करता (ID नहीं मिला)
422: Request format सही है लेकिन process नहीं हो सकता

Claude Code से पूछें “यहाँ 404 या 400 return करूं?” और सही जवाब मिलेगा।

गलती 3: सब कुछ memory में store करना

इस गाइड का code demo के लिए in-memory array इस्तेमाल करता है। Server restart करने पर data गायब हो जाता है। Production में PostgreSQL या MongoDB जैसा database चाहिए। Claude Code से कहें “memory की जगह SQLite में store करो” और migration हो जाएगी।

---

अगले कदम

REST API की बुनियाद सीख लेने के बाद इन्हें आज़माएं:

कदम	क्या करें
Database	SQLite → PostgreSQL (Prisma के साथ)
Authentication	JWT token auth जोड़ें
Testing	vitest से API tests लिखें
Deploy	Vercel / Cloudflare Workers पर publish करें

इन सबके लिए Claude Code से “X जोड़ो” कहें और कुछ मिनटों में foundation तैयार। पहले कुछ काम करने वाला बनाएं — यही सबसे तेज़ रास्ता है।

संबंधित लेख

• Claude Code से REST API का Design, Implementation और Testing तेज़ गति से
• Claude Code पूर्ण शुरुआती गाइड
• Claude Code Security Best Practices