DummyJSON คืออะไร? REST API จำลองฟรี พร้อมวิธีสร้างของคุณเอง

หากคุณกำลังสร้าง UI ก่อนที่แบ็กเอนด์จะพร้อม คุณต้องมีข้อมูลสำหรับแสดงผลและทดสอบ flow จริง DummyJSON เป็น REST API ปลอมฟรีที่ให้ข้อมูลผลิตภัณฑ์ ผู้ใช้ รถเข็น และทรัพยากรอื่น ๆ ผ่าน HTTP โดยไม่ต้องสมัครใช้งาน บทความนี้สรุปวิธีใช้งาน DummyJSON เปรียบเทียบกับ API สำหรับการทดสอบสาธารณะอื่น ๆ และอธิบายว่าควรทำอย่างไรเมื่อข้อมูล placeholder แบบคงที่เริ่มไม่พอสำหรับโปรเจกต์จริง

ลองใช้ Apidog วันนี้

DummyJSON คืออะไร?

DummyJSON คือ JSON placeholder API ฟรี คุณเรียก endpoint สาธารณะ แล้วได้ JSON ที่มีโครงสร้างกลับมาโดยไม่ต้องตั้งฐานข้อมูล ไม่ต้องสร้าง mock server เอง และไม่ต้องใช้ API key

เหมาะกับงานเหล่านี้:

• สร้าง UI ก่อน API จริงพร้อม
• ทดลอง pagination, filtering, sorting
• ทำ tutorial หรือ demo ที่ต้องเรียก HTTP จริง
• ทดสอบ loading state และ error handling บางส่วน
• ลดการ hardcode array ใน frontend

ข้อมูลเป็นข้อมูลปลอม แต่มีโครงสร้างใกล้เคียงข้อมูลจริง เช่น product มีชื่อ ราคา rating stock และ category ส่วน user มีชื่อ email address และ company ทำให้ใช้ต่อกับ table, card, detail page และ list page ได้ทันที

ตัวอย่างการเรียก API ด้วย fetch:

const res = await fetch("https://dummyjson.com/products?limit=5");
const data = await res.json();

console.log(data.products);

หรือใช้ curl:

curl https://dummyjson.com/products?limit=5

DummyJSON ให้บริการผ่าน HTTPS และตอบกลับเป็น JSON ดังนั้นจึงเรียกได้จาก browser, mobile app, server script หรือ command line เหมาะมากสำหรับช่วงต้นของโปรเจกต์ที่ backend ยังไม่พร้อม

Endpoint, authentication และข้อจำกัดของ DummyJSON

DummyJSON มี resource หลักหลายชุดที่ใช้งานได้ทันที:

• /products — รายการสินค้า พร้อมราคา stock rating และ category
• /users — ข้อมูลผู้ใช้ พร้อม email, address และ company
• /carts — รถเข็นสินค้าที่ผูกกับ user
• /posts และ /comments — ข้อมูลเนื้อหาแบบ blog
• /todos — รายการงาน
• /recipes และ /quotes — ข้อมูลตัวอย่างเพิ่มเติม

ตัวอย่างการดึงสินค้าแบบ pagination:

curl "https://dummyjson.com/products?limit=5&skip=10"

ตัวอย่างการเลือกเฉพาะ field ที่ต้องใช้:

curl "https://dummyjson.com/products?limit=5&select=title,price,stock"

ตัวอย่างการค้นหา:

curl "https://dummyjson.com/products/search?q=phone"

ตัวอย่างการดึง product ตาม ID:

curl https://dummyjson.com/products/1

DummyJSON ยังรองรับ parameter delay เพื่อจำลอง network ช้าได้ เช่น delay 2 วินาที:

curl "https://dummyjson.com/products?delay=2000"

เหมาะสำหรับทดสอบ loading state ใน frontend:

async function loadProducts() {
  setLoading(true);

  try {
    const res = await fetch("https://dummyjson.com/products?delay=2000");
    const data = await res.json();
    setProducts(data.products);
  } finally {
    setLoading(false);
  }
}

การใช้ authentication

DummyJSON มี endpoint สำหรับ login และใช้ Bearer token กับ endpoint ที่ต้อง authentication

ขั้นตอนคือ:

1. ส่ง username และ password ไปที่ /auth/login
2. รับ access token
3. ส่ง token ผ่าน header Authorization

# 1. Login เพื่อรับ token
curl -X POST https://dummyjson.com/auth/login \
  -H "Content-Type: application/json" \
  -d '{"username":"emilys","password":"emilyspass"}'

# 2. ใช้ token กับ authenticated endpoint
curl https://dummyjson.com/auth/me \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN_HERE"

ตัวอย่างใน JavaScript:

const loginRes = await fetch("https://dummyjson.com/auth/login", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    username: "emilys",
    password: "emilyspass",
  }),
});

const auth = await loginRes.json();

const meRes = await fetch("https://dummyjson.com/auth/me", {
  headers: {
    Authorization: `Bearer ${auth.accessToken}`,
  },
});

const me = await meRes.json();
console.log(me);

การเขียนข้อมูลเป็นการจำลองเท่านั้น

DummyJSON รองรับ POST, PUT, PATCH และ DELETE แต่เป็น simulated write เท่านั้น API จะตอบกลับเหมือนสร้างหรือแก้ไขสำเร็จ แต่ข้อมูลจะไม่ถูกบันทึกจริง

ตัวอย่างการเพิ่ม product:

curl -X POST https://dummyjson.com/products/add \
  -H "Content-Type: application/json" \
  -d '{"title":"New Product","price":99}'

ข้อควรจำ:

• response จะดูเหมือนสร้างข้อมูลสำเร็จ
• ข้อมูลใหม่จะไม่ persist
• reload หรืออ่านซ้ำจาก list จะไม่เจอข้อมูลที่เพิ่ม
• ไม่เหมาะกับ flow ที่ต้องทดสอบ state จริง เช่น cart, admin panel หรือ checkout

สำหรับตัวเลือก API ฟรีเพิ่มเติม ดูสรุป API ฟรีสำหรับนักพัฒนา

DummyJSON เทียบกับ JSONPlaceholder เทียบกับ Reqres

DummyJSON ไม่ใช่ fake REST API ฟรีเพียงตัวเดียว เครื่องมือที่มักถูกเปรียบเทียบด้วยคือ JSONPlaceholder และ Reqres

Tool	เหมาะกับ	Resources	Auth flow	Writes persist?
DummyJSON	Demo แนว e-commerce ที่ต้องการข้อมูลสมจริง	Products, users, carts, posts, recipes และอื่น ๆ	Login endpoint + bearer token	ไม่ persist
JSONPlaceholder	CRUD tutorial แบบเร็วและง่าย	Posts, comments, users, todos, albums, photos	ไม่มี	ไม่ persist
Reqres	Demo auth และ request/response flow	Users, register/login mock	Mock register/login	ไม่ persist

ทั้งสามตัวมีรูปแบบคล้ายกัน:

• ข้อมูลส่วนใหญ่เป็น static dataset
• การเขียนข้อมูลเป็น simulation
• ไม่สามารถปรับ schema ได้ตามต้องการ
• เหมาะกับ demo หรือ prototype มากกว่า production-like testing

JSONPlaceholder ทำงานบน json-server จึงให้ model ข้อมูลที่ค่อนข้าง generic ส่วน DummyJSON เหมาะกว่าเมื่อคุณต้องการข้อมูลสินค้าและผู้ใช้ที่ดูเหมือนระบบร้านค้า Reqres เหมาะกับการสาธิต login/register flow

แหล่งข้อมูลที่ควรบุ๊กมาร์ก:

• JSONPlaceholder
• GitHub repo ของ DummyJSON

เมื่อข้อมูล placeholder แบบตายตัวไม่เพียงพอ

Hosted fake API มีประโยชน์มากในช่วงแรก แต่จะเริ่มจำกัดเมื่อโปรเจกต์มี schema เฉพาะของตัวเอง

สัญญาณที่บอกว่าคุณควรสร้าง mock API เอง:

• แอปต้องการ field ที่ DummyJSON ไม่มี เช่น subscription_tier, feature_flags, billing_status
• ต้องการ write flow ที่อ่านข้อมูลกลับมาได้จริง
• ต้องการจำลอง error เช่น 400, 401, 429, 500
• ต้องการ payload ที่ตรงกับ OpenAPI spec ของทีม
• ต้องการ response ที่ต่างกันตาม role, status หรือ scenario
• ต้องการให้ frontend และ backend ทำงานตาม contract เดียวกันก่อน backend เสร็จ

ตัวอย่างเช่น ถ้า API จริงของคุณต้องส่ง response แบบนี้:

{
  "id": "prod_001",
  "name": "Team Plan",
  "price": 29,
  "currency": "USD",
  "subscription_tier": "pro",
  "feature_flags": {
    "api_access": true,
    "audit_log": true
  }
}

DummyJSON ไม่สามารถปรับ /products ให้ตรง schema นี้ได้โดยตรง คุณจึงต้องสร้าง mock server ที่ควบคุม schema และ response เอง

วิธีสร้าง REST API ปลอมของคุณเองด้วย Apidog

Apidog เป็นแพลตฟอร์มสำหรับออกแบบ ทดสอบ ทำเอกสาร และ mock API ในที่เดียว เมื่อข้อมูลจาก DummyJSON ไม่พอ คุณสามารถใช้ Apidog สร้าง mock API ที่อิงจาก schema ของคุณเองได้

แนวทางการทำงานมี 4 ขั้นตอน

1. กำหนด endpoint และ schema

สร้าง endpoint เช่น:

GET /products

กำหนด response schema เช่น:

{
  "products": [
    {
      "id": "string",
      "title": "string",
      "price": "number",
      "stock": "integer",
      "category": "string",
      "status": "string"
    }
  ],
  "total": "integer",
  "limit": "integer",
  "skip": "integer"
}

คุณสามารถกำหนดเองหรือ import จาก OpenAPI/Swagger ที่มีอยู่ เพื่อให้ mock ตรงกับ API contract จริง

2. ให้ smart mock สร้างข้อมูลจาก schema

Apidog อ่าน field name และ data type แล้วสร้างข้อมูลตัวอย่างที่เหมาะสม เช่น:

• email ได้ค่าเป็น email
• price ได้ค่าเป็นตัวเลข
• createdAt ได้ค่าเป็นวันที่
• status ได้ค่าตาม enum ที่กำหนด
• id ได้ค่าเป็น identifier

แนวคิดคล้ายการใช้ Faker แต่ผูกกับ API schema โดยตรง ดูรายละเอียดเพิ่มเติมได้ที่คู่มือ สร้างข้อมูลจำลองจาก OpenAPI schemas

3. ปรับแต่ง response และ edge case

เมื่อคุณเป็นเจ้าของ mock server คุณสามารถกำหนด scenario ที่ hosted fake API ทำไม่ได้ เช่น:

• ให้ price อยู่ใน range ที่ต้องการ
• จำกัด status เป็น active, inactive, archived
• ส่ง 401 เมื่อไม่มี token
• ส่ง 500 เพื่อทดสอบ error boundary
• ส่ง empty list เพื่อทดสอบ empty state
• ส่ง malformed payload เพื่อทดสอบ validation

ตัวอย่าง response สำหรับ error case:

{
  "error": {
    "code": "PRODUCT_SERVICE_UNAVAILABLE",
    "message": "Product service is temporarily unavailable"
  }
}

4. รัน mock server แล้วเชื่อม frontend

เมื่อสร้าง mock แล้ว Apidog จะให้ URL ที่เรียกใช้งานได้ คุณสามารถชี้ frontend ไปที่ mock server แทน backend จริง

curl "https://<your-mock-host>/products?limit=5"

ตัวอย่างตั้งค่า base URL ใน frontend:

const API_BASE_URL =
  import.meta.env.VITE_API_BASE_URL || "https://<your-mock-host>";

export async function getProducts() {
  const res = await fetch(`${API_BASE_URL}/products?limit=5`);

  if (!res.ok) {
    throw new Error("Failed to load products");
  }

  return res.json();
}

เมื่อ API spec เปลี่ยน mock ก็อัปเดตตาม schema ได้ ทำให้ frontend, mock และ API contract ไม่หลุดจากกัน หากต้องการสร้างชุดข้อมูลทดสอบที่สมจริงขึ้น ดูแนวทางใน การสร้างข้อมูลทดสอบ API ที่สมจริง

สรุปการเลือกใช้งาน:

• ใช้ DummyJSON เมื่ออยากได้ข้อมูลเร็วที่สุดสำหรับ demo หรือ prototype
• ใช้ Apidog เมื่อคุณต้องการ schema ของตัวเอง, mock ที่ควบคุมได้, error case, และ contract ที่ตรงกับ API จริง

คำถามที่พบบ่อย

DummyJSON ใช้งานได้ฟรีหรือไม่?

ใช่ DummyJSON ใช้งานได้ฟรีและไม่ต้องใช้ API key คุณสามารถเรียก endpoint สาธารณะจาก browser, curl หรือ application ได้โดยตรง แต่ควรใช้สำหรับ prototype, learning และ demo ไม่ใช่ production traffic หรือ load testing

DummyJSON บันทึกข้อมูลที่ฉันสร้างหรืออัปเดตหรือไม่?

ไม่ คำขอ POST, PUT, PATCH และ DELETE จะตอบกลับเหมือนทำงานสำเร็จ แต่ข้อมูลไม่ persist บน server การอ่านครั้งถัดไปจะยังได้ข้อมูลเดิม หากต้องการ mock ที่ควบคุม state ได้ ให้ดูคู่มือ mock APIs

DummyJSON ต่างจาก mock server อย่างไร?

DummyJSON เป็น dataset คงที่ที่ทุกคนใช้ร่วมกัน คุณเรียก endpoint ที่มีอยู่แล้วและรับ response ตาม schema ของ DummyJSON

Mock server เช่นใน Apidog ให้คุณกำหนด endpoint, schema, response, status code และ scenario เอง เหมาะกว่าเมื่อ frontend ต้องพัฒนาตาม API contract ของโปรเจกต์จริง

ฉันสามารถใช้ DummyJSON กับ React หรือ Vue ได้หรือไม่?

ได้ เพราะ DummyJSON เป็น REST API ปกติ ตัวอย่าง React แบบง่าย:

import { useEffect, useState } from "react";

export default function ProductList() {
  const [products, setProducts] = useState([]);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    fetch("https://dummyjson.com/products?limit=5")
      .then((res) => res.json())
      .then((data) => setProducts(data.products))
      .finally(() => setLoading(false));
  }, []);

  if (loading) return <p>Loading...</p>;

  return (
    <ul>
      {products.map((product) => (
        <li key={product.id}>
          {product.title} - ${product.price}
        </li>
      ))}
    </ul>
  );
}

ฉันสามารถรับข้อมูลที่สมจริงกว่า placeholder ทั่วไปได้หรือไม่?

ได้ ถ้าสร้างจาก schema ของคุณเอง เครื่องมือที่ขับเคลื่อนด้วย schema สามารถอ่าน field name และ type แล้วสร้างค่าที่น่าเชื่อถือ เช่น email, price, createdAt หรือ status นี่เป็นเหตุผลหลักที่ทีมมักย้ายจาก hosted fake API ไปใช้ mock server ของตัวเองเมื่อโปรเจกต์เริ่มจริงจัง

สรุป

DummyJSON เป็น REST API ปลอมฟรีที่เหมาะกับการสร้าง UI อย่างรวดเร็ว โดยเฉพาะงานที่ต้องการข้อมูล product, user และ cart แบบสมจริงโดยไม่ต้องเขียน backend ก่อน คุณสามารถใช้เพื่อทดลอง list page, detail page, pagination, search, loading state และ authentication flow เบื้องต้นได้ทันที

แต่เมื่อโปรเจกต์ต้องการ schema เฉพาะของตัวเอง การเขียนข้อมูลที่ควบคุมได้ error case หรือ mock ที่ตรงกับ OpenAPI contract คุณควรสร้าง mock API เองแทนการพึ่ง dataset แบบคงที่

Apidog ช่วยให้คุณกำหนด schema สร้าง mock data จากสเปก และทำให้ mock sync กับ API ที่จะส่งมอบจริงได้ใน workflow เดียว ทดลองใช้ฟรีและเปลี่ยน API spec ของคุณให้เป็น mock ที่เรียกใช้งานได้ในไม่กี่นาที