WordPress REST API คืออะไร? วิธีใช้งานและเชื่อมต่อระบบภายนอกแบบละเอียด

WordPress REST API คือระบบที่ช่วยให้เว็บไซต์ WordPress สามารถรับส่งข้อมูลกับแอปพลิเคชัน เว็บไซต์ หรือบริการภายนอกผ่าน HTTP Requests โดยใช้ข้อมูลรูปแบบ JSON เป็นหลัก ทำให้นักพัฒนาสามารถอ่าน สร้าง แก้ไข และลบข้อมูล WordPress ได้ตามสิทธิ์ที่กำหนด โดยไม่จำเป็นต้องดำเนินการทุกอย่างผ่านหน้า WordPress Admin
ตัวอย่างเช่น หากธุรกิจต้องการเชื่อมเว็บไซต์ WordPress เข้ากับระบบ CRM, Mobile Application, ระบบจัดการสินค้า หรือแพลตฟอร์ม Automation ก็สามารถใช้ WordPress REST API เป็นช่องทางแลกเปลี่ยนข้อมูลระหว่างระบบได้
นอกจากนี้ WordPress REST API ยังเป็นส่วนสำคัญของการพัฒนาเว็บไซต์แบบ Headless WordPress และการทำงานของเครื่องมือสมัยใหม่ที่ต้องเข้าถึงข้อมูล WordPress ผ่านโปรแกรม
อย่างไรก็ตาม การเชื่อมต่อ API ต้องคำนึงถึง Authentication, Permissions, Data Validation และความปลอดภัย โดยเฉพาะคำขอที่มีสิทธิ์สร้างหรือเปลี่ยนแปลงข้อมูลเว็บไซต์
บทความนี้จะอธิบายว่า WordPress REST API คืออะไร ทำงานอย่างไร มี Endpoints อะไรบ้าง พร้อมตัวอย่างการใช้งานด้วย JavaScript, PHP และ cURL รวมถึงวิธีเชื่อม Custom Post Types, Custom Fields และระบบภายนอกอย่างปลอดภัย
WordPress REST API คืออะไร?
WordPress REST API คือส่วนติดต่อสำหรับโปรแกรม หรือ Application Programming Interface ที่เปิดให้ระบบอื่นสื่อสารกับ WordPress ผ่านเว็บโปรโตคอลมาตรฐาน
REST ย่อมาจาก Representational State Transfer ซึ่งเป็นรูปแบบสถาปัตยกรรมสำหรับการออกแบบระบบที่ทำงานผ่านเครือข่าย
WordPress REST API ใช้ HTTP Methods เช่น GET, POST, PUT, PATCH และ DELETE เพื่อทำงานกับ Resources เช่น Posts, Pages, Media, Users และข้อมูลประเภทอื่นที่ระบบรองรับ
ตัวอย่างเช่น หากต้องการอ่านบทความจากเว็บไซต์ WordPress สามารถส่ง HTTP GET Request ไปยัง Endpoint ที่เกี่ยวข้องได้
https://example.com/wp-json/wp/v2/posts เมื่อเรียก URL นี้บนเว็บไซต์ WordPress ที่เปิดให้เข้าถึงข้อมูลสาธารณะได้ ระบบจะส่งข้อมูลบทความกลับมาในรูปแบบ JSON
ตัวอย่างข้อมูลอย่างย่อ:
[
{
"id": 101,
"date": "2026-11-22T10:00:00",
"slug": "wordpress-api-guide",
"title": {
"rendered": "WordPress REST API Guide"
},
"status": "publish"
}
] ตัวอย่างนี้เป็นข้อมูลสมมติที่แสดงรูปแบบ Response ไม่ใช่ข้อมูลจากเว็บไซต์จริง
WordPress REST API เป็นฟีเจอร์พื้นฐานของ WordPress ที่รองรับการเข้าถึงข้อมูลตามสิทธิ์ที่กำหนด โดยไม่จำเป็นต้องติดตั้งปลั๊กอิน REST API เพิ่มเพื่อใช้งาน Endpoints มาตรฐาน
WordPress REST API ทำงานอย่างไร?
การทำงานของ WordPress REST API สามารถอธิบายเป็นกระบวนการรับคำขอและส่งข้อมูลกลับ
- แอปพลิเคชันภายนอกส่ง HTTP Request ไปยัง WordPress
- WordPress ตรวจสอบ Endpoint และ HTTP Method
- ระบบตรวจสอบ Authentication และ Permissions เมื่อจำเป็น
- WordPress ประมวลผลคำขอและเข้าถึงข้อมูลที่เกี่ยวข้อง
- ระบบส่ง HTTP Response กลับพร้อมข้อมูล JSON หรือข้อความแจ้งข้อผิดพลาด
ตัวอย่างเช่น แอปพลิเคชันมือถือส่งคำขอไปยังเว็บไซต์ WordPress เพื่อดึงรายการบทความล่าสุด
WordPress จะอ่านข้อมูลบทความที่สามารถเผยแพร่ต่อสาธารณะ แล้วส่งข้อมูลกลับให้นำไปแสดงใน Mobile Application
แต่หากแอปพลิเคชันต้องการสร้างบทความใหม่ ระบบจำเป็นต้องตรวจสอบว่าผู้ใช้งานมีสิทธิ์ดำเนินการนั้นหรือไม่
การอ่านข้อมูลสาธารณะกับการแก้ไขข้อมูลจึงมีข้อกำหนดด้านสิทธิ์แตกต่างกัน
WordPress REST API ใช้ทำอะไรได้บ้าง?
WordPress REST API สามารถนำไปใช้กับการพัฒนาและเชื่อมต่อระบบได้หลากหลาย
1. เชื่อม WordPress กับ Mobile Application
สามารถให้แอปพลิเคชัน Android หรือ iOS ดึงบทความ ข่าวสาร หรือข้อมูลบริการจาก WordPress มาแสดงได้
หากต้องการให้ผู้ใช้ส่งข้อมูลกลับมายังเว็บไซต์ ก็สามารถออกแบบ Endpoint และระบบยืนยันตัวตนที่เหมาะสมเพิ่มเติม
2. เชื่อมต่อระบบ CRM
ธุรกิจสามารถพัฒนาการเชื่อมต่อระหว่าง WordPress กับระบบ CRM เพื่อจัดการข้อมูล Lead หรือสถานะงานตามสิทธิ์ที่กำหนด
ตัวอย่างเช่น เมื่อมีการส่งฟอร์มติดต่อ ระบบฝั่งเซิร์ฟเวอร์อาจส่งข้อมูลที่จำเป็นไปยัง CRM ผ่าน API
ทั้งนี้ควรให้ความสำคัญกับข้อมูลส่วนบุคคล ความยินยอม และการจัดเก็บข้อมูลอย่างปลอดภัย
3. เชื่อมระบบจัดการสินค้า
เว็บไซต์ที่ใช้ WordPress ร่วมกับ WooCommerce สามารถใช้ API ที่เกี่ยวข้องเพื่อเชื่อมต่อข้อมูลสินค้าและคำสั่งซื้อกับระบบอื่นได้
อย่างไรก็ตาม WooCommerce REST API มีระบบ Endpoints และข้อกำหนดด้าน Authentication เฉพาะ จึงควรศึกษาเอกสาร WooCommerce แยกจาก WordPress REST API มาตรฐาน
4. สร้างระบบ Automation
สามารถใช้ API เพื่อช่วยงานที่ต้องทำซ้ำ เช่น สร้าง Draft, อัปเดตข้อมูล หรือส่งข้อมูลระหว่างระบบ
การใช้งานลักษณะนี้ควรมีระบบตรวจสอบสิทธิ์ การจัดการข้อผิดพลาด และบันทึกการดำเนินการ
5. พัฒนา Headless WordPress
Headless WordPress คือการใช้ WordPress เป็นระบบจัดการเนื้อหาส่วน Backend ขณะที่ Frontend ใช้เทคโนโลยีอื่น เช่น React หรือ Next.js
REST API สามารถทำหน้าที่ส่งข้อมูลจาก WordPress ไปยัง Frontend ได้
6. เชื่อม Custom Post Types
เว็บไซต์ที่ใช้ Custom Post Types เช่น Jobs, Events, Products หรือ Team Members สามารถเปิดให้ข้อมูลบางส่วนเข้าถึงผ่าน REST API ได้ตามการตั้งค่า
7. สร้าง Dashboard หรือระบบรายงาน
ระบบภายนอกสามารถอ่านข้อมูลที่ได้รับอนุญาตผ่าน API และนำไปแสดงใน Dashboard ได้
แต่ข้อมูลที่เป็นความลับต้องได้รับการป้องกันด้วย Authentication และ Permissions อย่างเหมาะสม
WordPress REST API Endpoint คืออะไร?
Endpoint คือ URL ที่ระบบใช้เป็นจุดรับคำขอเพื่อเข้าถึง Resource หรือดำเนินการที่กำหนด
WordPress มี REST API Namespace มาตรฐานคือ
wp/v2 ตัวอย่าง URL พื้นฐาน:
https://example.com/wp-json/ URL นี้ใช้เข้าถึง API Index ซึ่งสามารถแสดงข้อมูลเกี่ยวกับ Routes ที่มีการลงทะเบียนไว้
ตัวอย่าง Endpoints:
| Endpoint | การใช้งาน |
|---|---|
/wp-json/wp/v2/posts | จัดการ Posts |
/wp-json/wp/v2/pages | จัดการ Pages |
/wp-json/wp/v2/categories | จัดการ Categories |
/wp-json/wp/v2/tags | จัดการ Tags |
/wp-json/wp/v2/media | จัดการ Media |
/wp-json/wp/v2/users | เข้าถึงข้อมูล Users ตามสิทธิ์ |
/wp-json/wp/v2/comments | จัดการ Comments ตามสิทธิ์ |
/wp-json/wp/v2/types | ดูข้อมูล Post Types ที่เปิดเผยผ่าน API |
/wp-json/wp/v2/taxonomies | ดู Taxonomies ที่เปิดเผยผ่าน API |
บาง Endpoint มีข้อกำหนดการเข้าถึงเพิ่มเติม หรือข้อมูลที่ตอบกลับแตกต่างกันระหว่างผู้ใช้ทั่วไปกับผู้ใช้ที่ยืนยันตัวตนแล้ว
การที่ Endpoint มีอยู่ไม่ได้หมายความว่าทุกคนสามารถอ่านหรือแก้ไขข้อมูลทั้งหมดได้
HTTP Methods ใน WordPress REST API มีอะไรบ้าง?
HTTP Methods ใช้กำหนดประเภทการดำเนินการกับ API
| HTTP Method | หน้าที่หลัก | ตัวอย่าง |
|---|---|---|
| GET | อ่านข้อมูล | อ่านรายการ Posts |
| POST | สร้างหรือดำเนินการตาม Endpoint | สร้าง Post |
| PUT | อัปเดต Resource ตามที่ Endpoint รองรับ | อัปเดตข้อมูล |
| PATCH | อัปเดตข้อมูลบางส่วนตามที่ Endpoint รองรับ | แก้ไขบาง Field |
| DELETE | ลบ Resource | ลบ Post |
ต้องตรวจสอบวิธีที่ Endpoint แต่ละรายการรองรับจริง เพราะ WordPress REST API ไม่ได้กำหนดให้ทุก Route รองรับทุก HTTP Method
สำหรับ Endpoints มาตรฐานของ WordPress การอัปเดต Post สามารถใช้ POST กับ URL ของ Post นั้นได้ตาม API Reference
วิธีทดสอบ WordPress REST API เบื้องต้น
วิธีที่ง่ายที่สุดคือทดลองเปิด URL ของ API ผ่าน Browser
วิธีที่ 1: ตรวจสอบ API Index
เปิด URL:
https://example.com/wp-json/ หากระบบทำงานและอนุญาตให้เข้าถึง จะได้รับข้อมูล JSON เกี่ยวกับ API
วิธีที่ 2: ตรวจสอบบทความ
เปิด URL:
https://example.com/wp-json/wp/v2/posts ระบบจะส่งรายการ Posts ที่สามารถเข้าถึงได้ตามสิทธิ์
วิธีที่ 3: ตรวจสอบ Pages
https://example.com/wp-json/wp/v2/pages วิธีที่ 4: ตรวจสอบข้อมูลบทความตาม ID
https://example.com/wp-json/wp/v2/posts/101 เปลี่ยน 101 เป็น Post ID ที่มีอยู่จริง
หากได้รับ HTTP 404, 401 หรือ 403 ต้องตรวจสอบรายละเอียด Response ก่อนสรุปว่า REST API เสีย
วิธีใช้ GET Request ดึงข้อมูล WordPress
GET เป็นวิธีพื้นฐานที่ใช้สำหรับอ่านข้อมูล
ตัวอย่างการเรียกผ่าน JavaScript:
async function getPosts() {
const response = await fetch(
"https://example.com/wp-json/wp/v2/posts?per_page=5"
);
if (!response.ok) {
throw new Error(`HTTP ${response.status}`);
}
const posts = await response.json();
return posts;
}
getPosts()
.then((posts) => console.log(posts))
.catch((error) => console.error(error)); โค้ดนี้จะพยายามดึง Posts จำนวนไม่เกิน 5 รายการตามสิทธิ์การเข้าถึงที่ Endpoint รองรับ
หากเรียก API ข้ามโดเมนจาก Browser จำเป็นต้องพิจารณา Cross-Origin Resource Sharing หรือ CORS ด้วย
การเปิด Endpoint ผ่าน Browser ได้ ไม่ได้หมายความว่าการเรียกผ่าน JavaScript จากทุก Origin จะได้รับอนุญาตเสมอไป
WordPress REST API Pagination ใช้อย่างไร?
เมื่อเว็บไซต์มีบทความจำนวนมาก ไม่ควรดึงข้อมูลทั้งหมดในคำขอเดียว
WordPress REST API มีระบบ Pagination สำหรับแบ่งผลลัพธ์ออกเป็นหน้า
ตัวอย่าง:
https://example.com/wp-json/wp/v2/posts?page=1&per_page=20 Parameters ที่สำคัญ ได้แก่
pageกำหนดหมายเลขหน้าper_pageกำหนดจำนวนรายการต่อหน้าsearchใช้ค้นหาข้อมูลใน Endpoints ที่รองรับorderbyใช้กำหนดรูปแบบการเรียงorderใช้กำหนดลำดับ ASC หรือ DESC_fieldsใช้เลือก Fields ที่ต้องการส่งกลับ
ตัวอย่าง:
https://example.com/wp-json/wp/v2/posts?per_page=10&page=2 จำนวนรายการสูงสุดต่อ Request มีข้อจำกัดตาม Endpoint โดย Endpoints แบบ Collection มาตรฐานจำนวนมากจำกัด per_page สูงสุดที่ 100
Response อาจมี Headers เช่น
X-WP-Total
X-WP-TotalPages ใช้สำหรับทราบจำนวนรายการและจำนวนหน้าตามที่ Endpoint รองรับ
หากต้องอ่านบทความหลายพันรายการ ควรใช้ Pagination อย่างเป็นระบบแทนการดึงข้อมูลจำนวนมากในครั้งเดียว
วิธีลดขนาด JSON Response ด้วย _fields
WordPress REST API รองรับ Global Parameter _fields เพื่อเลือกเฉพาะข้อมูลที่ต้องการ
ตัวอย่าง:
https://example.com/wp-json/wp/v2/posts?_fields=id,slug,title,link&per_page=10 เมื่อใช้ _fields ระบบจะพยายามส่งกลับเฉพาะ Fields ที่ร้องขอ
ตัวอย่างข้อมูล:
[
{
"id": 101,
"slug": "wordpress-api-guide",
"title": {
"rendered": "WordPress API Guide"
},
"link": "https://example.com/wordpress-api-guide/"
}
] วิธีนี้ช่วยลดปริมาณข้อมูลที่ต้องดาวน์โหลดและแปลง JSON โดยเฉพาะเมื่อเชื่อมต่อระบบที่ต้องใช้ข้อมูลเพียงไม่กี่ Fields
อย่างไรก็ตาม การลดขนาด Response ไม่ได้หมายความว่าจะลดภาระ Database ทุกส่วนตามสัดส่วนเดียวกัน
ควรตรวจสอบประสิทธิภาพของ Endpoint จริงเมื่อระบบมีผู้ใช้จำนวนมาก
WordPress REST API Authentication คืออะไร?
Authentication คือกระบวนการยืนยันตัวตนของผู้ที่ส่งคำขอ API
สำหรับการอ่านข้อมูลสาธารณะ เช่น Posts ที่เผยแพร่แล้ว บาง Endpoints สามารถเข้าถึงได้โดยไม่ต้อง Authentication
แต่เมื่อผู้ใช้งานต้องการสร้าง แก้ไข หรือลบข้อมูล WordPress จำเป็นต้องยืนยันตัวตนและมี Permissions ที่เหมาะสม
วิธี Authentication ที่ WordPress รองรับหรือสามารถใช้ผ่านระบบที่เกี่ยวข้อง ได้แก่
- Cookie Authentication พร้อม Nonce
- Application Passwords
- วิธี Authentication เพิ่มเติมจากปลั๊กอินหรือโครงสร้างระบบที่รองรับ
ควรเลือกวิธี Authentication ตามรูปแบบการใช้งานจริง
Application Passwords คืออะไร?
Application Passwords คือฟีเจอร์ของ WordPress ที่ช่วยให้ผู้ใช้สร้าง Credential แยกสำหรับแอปพลิเคชันหรือระบบภายนอก เพื่อเชื่อมต่อ API โดยไม่ต้องใช้รหัสผ่านสำหรับเข้าสู่ระบบ WordPress ตามปกติ
ฟีเจอร์นี้มีอยู่ใน WordPress Core ตั้งแต่ WordPress 5.6
ข้อดีคือสามารถสร้าง Credential สำหรับแต่ละระบบแยกกัน และเพิกถอน Application Password ที่ไม่ต้องการใช้งานแล้วได้
ตัวอย่างเช่น หากมีระบบ Integration สำหรับเผยแพร่บทความอัตโนมัติ สามารถสร้าง Application Password สำหรับการเชื่อมต่อนั้นโดยเฉพาะ
แต่ต้องเข้าใจว่า Application Password ไม่ได้กำหนดสิทธิ์ย่อยเป็นราย Endpoint โดยอัตโนมัติ สิทธิ์ของคำขอยังคงขึ้นอยู่กับ WordPress User และ Capability ของบัญชีที่ใช้
จึงไม่ควรใช้บัญชี Administrator หากระบบต้องการเพียงสิทธิ์สร้างหรือแก้ไขบทความ
วิธีสร้าง WordPress Application Password
ขั้นตอนทั่วไปมีดังนี้
- เข้าสู่ WordPress Admin
- เปิด Users
- เลือก Profile ของบัญชีที่ต้องการใช้
- ค้นหาส่วน Application Passwords
- กำหนดชื่อ Application
- สร้าง Application Password
- เก็บ Credential ไว้ในระบบจัดเก็บ Secrets ที่ปลอดภัย
เมนูอาจแตกต่างตามการตั้งค่าระบบหรือข้อกำหนดด้านความปลอดภัยของเว็บไซต์
ควรใช้ HTTPS และไม่ส่ง Application Password ผ่านช่องทางที่ไม่มีการเข้ารหัส
หากไม่พบตัวเลือก Application Passwords ควรตรวจสอบการตั้งค่า WordPress, HTTPS และปลั๊กอินหรือระบบที่อาจจำกัดฟีเจอร์นี้
วิธีเชื่อม WordPress REST API ด้วย cURL
การเชื่อมต่อผ่าน cURL เหมาะสำหรับการทดสอบหรือทำงานจาก Server และ Command Line
ตัวอย่างอ่าน Posts โดยไม่ต้องยืนยันตัวตน
curl "https://example.com/wp-json/wp/v2/posts?per_page=5" ตัวอย่างตรวจสอบ Authentication
curl --user "api_editor:APPLICATION_PASSWORD" \
"https://example.com/wp-json/wp/v2/users/me" เปลี่ยน api_editor และ APPLICATION_PASSWORD เป็น Credential ของบัญชีที่ได้รับอนุญาต
ตัวอย่างนี้ใช้ HTTP Basic Authentication ผ่าน HTTPS ตามแนวทางของ WordPress Application Passwords
ข้อควรระวัง: ไม่ควรใส่ Credential จริงในตัวอย่างโค้ดที่เผยแพร่สาธารณะ และการใส่ Secrets ลงใน Command Line โดยตรงอาจทำให้ข้อมูลปรากฏใน Shell History หรือกระบวนการตรวจสอบของระบบได้
สำหรับ Production ควรใช้วิธีจัดเก็บและส่ง Secrets อย่างปลอดภัยตามสภาพแวดล้อมที่ใช้งาน
วิธีสร้างบทความ WordPress ผ่าน REST API
การสร้าง Posts ผ่าน API ต้องใช้บัญชีที่มีสิทธิ์สร้างบทความ
ตัวอย่างการเรียกด้วย cURL:
curl --request POST \
--url "https://example.com/wp-json/wp/v2/posts" \
--user "api_editor:APPLICATION_PASSWORD" \
--header "Content-Type: application/json" \
--data '{
"title": "บทความตัวอย่างจาก REST API",
"content": "<p>เนื้อหาสำหรับทดสอบ API</p>",
"status": "draft"
}' โค้ดนี้เป็นตัวอย่างการสร้าง Draft ไม่ใช่การเผยแพร่บทความทันที
หากบัญชีมีสิทธิ์เหมาะสมและคำขอผ่านการตรวจสอบ WordPress จะสร้าง Post และส่งข้อมูล Response กลับ
ตัวอย่างข้อมูลบางส่วน:
{
"id": 102,
"status": "draft",
"title": {
"rendered": "บทความตัวอย่างจาก REST API"
}
} ก่อนใช้บนเว็บไซต์จริงควรทดลองกับ Staging และตรวจสอบว่าระบบไม่สร้างบทความซ้ำเมื่อ Retry Request
วิธีแก้ไขบทความผ่าน WordPress REST API
สามารถอัปเดต Post ที่มีอยู่ด้วย Endpoint ของ Post ID นั้น
ตัวอย่าง:
curl --request POST \
--url "https://example.com/wp-json/wp/v2/posts/102" \
--user "api_editor:APPLICATION_PASSWORD" \
--header "Content-Type: application/json" \
--data '{
"title": "อัปเดตชื่อบทความผ่าน REST API"
}' คำขอนี้จะพยายามอัปเดตชื่อ Post ID 102
บัญชีที่ใช้ต้องมีสิทธิ์แก้ไข Post นั้น
สำหรับงาน Automation ควรตรวจสอบ Post ID และสถานะปัจจุบันก่อนอัปเดต เพื่อป้องกันการแก้ไขบทความผิดรายการหรือเขียนทับงานของผู้ดูแลคนอื่น
วิธีลบบทความผ่าน REST API
WordPress รองรับ HTTP DELETE สำหรับการลบ Resources ที่เกี่ยวข้องตามสิทธิ์
ตัวอย่าง:
curl --request DELETE \
--url "https://example.com/wp-json/wp/v2/posts/102" \
--user "api_editor:APPLICATION_PASSWORD" พฤติกรรมการลบขึ้นอยู่กับ Endpoint และสถานะของรายการ โดย Posts มาตรฐานสามารถถูกย้ายไป Trash ได้ตามเงื่อนไข
บาง Endpoints รองรับ Parameter force=true สำหรับการลบถาวร ซึ่งไม่ควรใช้โดยไม่มีการตรวจสอบข้อมูลและสำรองข้อมูลก่อน
หากต้องพัฒนาระบบ Sync ข้อมูลระหว่างหลายระบบ ควรกำหนดขั้นตอนการลบและการกู้คืนให้ชัดเจน เพื่อหลีกเลี่ยงการลบข้อมูลโดยไม่ได้ตั้งใจ
วิธีเรียก WordPress REST API ด้วย JavaScript
JavaScript สามารถใช้ fetch() เพื่อส่ง HTTP Requests ไปยัง WordPress REST API
ตัวอย่างสำหรับอ่าน Posts สาธารณะ:
async function loadWordPressPosts() {
const url =
"https://example.com/wp-json/wp/v2/posts" +
"?per_page=5&_fields=id,slug,title,link";
const response = await fetch(url);
if (!response.ok) {
throw new Error(`Request failed: ${response.status}`);
}
return response.json();
}
loadWordPressPosts()
.then((posts) => {
posts.forEach((post) => {
console.log(post.title.rendered, post.link);
});
})
.catch(console.error); ตัวอย่างนี้ไม่ต้องใช้ Credential เพราะเป็นการอ่านข้อมูลที่ Endpoint อนุญาตให้เข้าถึงแบบ Public
ข้อควรระวังเกี่ยวกับ JavaScript
ไม่ควรเขียน Application Password ลงใน JavaScript ที่ส่งไปยัง Browser เพราะผู้ใช้งานสามารถตรวจสอบ Source Code และ Network Requests ได้
หากจำเป็นต้องใช้ Credential เพื่อเขียนข้อมูล WordPress ควรส่งคำขอผ่าน Backend ที่ดูแล Secrets และบังคับใช้ Authentication กับ Authorization อย่างเหมาะสม
สำหรับ JavaScript ที่ทำงานภายใน WordPress Admin หรือในบริบทผู้ใช้ที่ล็อกอิน สามารถใช้ Cookie Authentication และ REST Nonce ตามแนวทาง WordPress ได้
WordPress REST API กับ Cookie Authentication
Cookie Authentication เหมาะกับคำขอที่เกิดภายในเว็บไซต์ WordPress เมื่อผู้ใช้ลงชื่อเข้าใช้แล้ว
การส่ง REST API Request จาก JavaScript ในบริบทนี้มักใช้ REST Nonce เพื่อช่วยป้องกัน CSRF
ตัวอย่างการสร้าง Nonce ฝั่ง PHP:
wp_create_nonce( 'wp_rest' ); และส่งผ่าน Header:
X-WP-Nonce อย่างไรก็ตาม Nonce ไม่ใช่ตัวแทนของระบบ Permission และไม่ควรถูกใช้เป็นวิธี Authentication สำหรับแอปพลิเคชันภายนอกที่ไม่มี Session ของ WordPress
คำขอที่มีการเปลี่ยนข้อมูลต้องตรวจสอบ Capability ของผู้ใช้เสมอ
วิธีเรียก WordPress REST API ด้วย PHP
หากต้องการให้เว็บไซต์ WordPress หนึ่งดึงข้อมูลจากอีกเว็บไซต์ สามารถใช้ WordPress HTTP API ได้
ตัวอย่าง:
$response = wp_remote_get(
'https://example.com/wp-json/wp/v2/posts?per_page=5',
array(
'timeout' => 15,
)
);
if ( is_wp_error( $response ) ) {
error_log( $response->get_error_message() );
return;
}
$status = wp_remote_retrieve_response_code( $response );
if ( 200 !== $status ) {
error_log( 'REST API returned HTTP ' . $status );
return;
}
$body = wp_remote_retrieve_body( $response );
$posts = json_decode( $body, true );
if ( JSON_ERROR_NONE !== json_last_error() ) {
error_log( 'Invalid JSON response' );
return;
} ตัวอย่างนี้เหมาะสำหรับฝั่ง Server โดยใช้ wp_remote_get() แทนการเขียนระบบ HTTP Client ใหม่
แต่ไม่ควรเรียก API ภายนอกใหม่ทุกครั้งที่ผู้ใช้เปิดหน้าเว็บไซต์ หากข้อมูลไม่ได้เปลี่ยนบ่อย
ควรพิจารณาใช้ Transients หรือ Cache ที่เหมาะสม เพื่อลดจำนวน Requests และช่วยป้องกันความล่าช้าจากระบบภายนอก
WordPress REST API เชื่อมกับระบบภายนอกอย่างไร?
การเชื่อม WordPress กับระบบอื่นสามารถแบ่งออกเป็นสองรูปแบบหลัก
แบบที่ 1: ระบบภายนอกเรียก WordPress API
ตัวอย่าง:
Mobile App → WordPress REST API → WordPress Database
แอปพลิเคชันภายนอกส่งคำขอเพื่ออ่านหรืออัปเดตข้อมูลที่ได้รับอนุญาต
แนวทางนี้เหมาะกับ Headless CMS, Mobile Application และระบบจัดการเนื้อหาที่เชื่อมหลายแพลตฟอร์ม
แบบที่ 2: WordPress เรียก API ของระบบอื่น
ตัวอย่าง:
WordPress → CRM API → CRM Database
เมื่อเกิดเหตุการณ์บน WordPress ระบบอาจใช้ wp_remote_post() ส่งข้อมูลไปยัง API ของบริการภายนอก
ตัวอย่างเช่น เมื่อมี Lead ใหม่จากแบบฟอร์ม ระบบสามารถส่งข้อมูลที่จำเป็นไปยัง CRM ได้ หากผู้ดูแลมีสิทธิ์และการประมวลผลข้อมูลเป็นไปตามข้อกำหนดที่เกี่ยวข้อง
สำหรับงานที่ต้องรับส่งข้อมูลระหว่างสองระบบ ควรพิจารณาใช้ Webhooks หรือ Queue ร่วมกับ API ตามความเหมาะสม เพื่อไม่ให้คำขอฝั่งผู้ใช้ต้องรอระบบภายนอกนานเกินไป
WordPress REST API กับ Webhook ต่างกันอย่างไร?
REST API และ Webhook เป็นเทคโนโลยีที่สามารถใช้ร่วมกันได้ แต่มีจุดประสงค์แตกต่างกัน
| หัวข้อ | REST API | Webhook |
|---|---|---|
| รูปแบบการทำงาน | ระบบหนึ่งส่ง Request ไปยังอีกระบบ | ระบบส่งแจ้งเตือนเมื่อเกิดเหตุการณ์ |
| ตัวอย่าง | ขอข้อมูล Posts | แจ้งเมื่อมีรายการใหม่ |
| การเรียกใช้งาน | เมื่อ Client ต้องการ | เมื่อ Event เกิดขึ้น |
| การตรวจสิทธิ์ | ตาม Authentication ของ API | ต้องออกแบบการตรวจสอบคำขอ |
| การใช้งานร่วมกัน | ใช้ดึงหรือแก้ไขข้อมูล | ใช้แจ้งให้ระบบไปดึงข้อมูลเพิ่มเติม |
ตัวอย่างเช่น เมื่อมีการเผยแพร่บทความใหม่ WordPress อาจส่ง Webhook ไปยังระบบภายนอก
จากนั้นระบบภายนอกเรียก REST API เพื่อดึงข้อมูลบทความล่าสุด
WordPress Core ไม่ได้จัดเตรียม Webhook สำหรับทุกเหตุการณ์ธุรกิจในรูปแบบสำเร็จรูป ดังนั้นบางระบบอาจต้องพัฒนาปลั๊กอินหรือใช้เครื่องมือ Integration เพิ่มเติม
วิธีเปิด WordPress REST API สำหรับ Custom Post Type
Custom Post Type หรือ CPT คือประเภทเนื้อหาที่สร้างขึ้นเพิ่มเติมจาก Posts และ Pages
ตัวอย่าง ได้แก่
- Jobs
- Events
- Team Members
- Projects
- Properties
- Services
- Courses
การเปิด REST API สำหรับ CPT สามารถทำได้โดยกำหนด show_in_rest เป็น true
ตัวอย่าง:
add_action( 'init', function () {
register_post_type(
'portfolio',
array(
'label' => 'Portfolio',
'public' => true,
'show_in_rest' => true,
'rest_base' => 'portfolios',
'supports' => array(
'title',
'editor',
'thumbnail',
'custom-fields',
),
)
);
} ); เมื่อเปิดใช้งานแล้ว สามารถตรวจสอบ Endpoint:
https://example.com/wp-json/wp/v2/portfolios ตัวอย่างนี้ควรใช้ใน Custom Plugin หรือโครงสร้างโค้ดที่ควบคุมได้ ไม่ควรคัดลอกไปลงเว็บไซต์ที่มี CPT ชื่อเดียวกันอยู่แล้ว เพราะอาจเกิดความขัดแย้งจากการลงทะเบียนซ้ำ
หากเว็บไซต์ใช้ JetEngine หรือปลั๊กอินอื่นสำหรับจัดการ CPT ควรตรวจสอบว่าระบบมีตัวเลือกเปิด REST API ให้ใช้งานอยู่แล้วหรือไม่ ก่อนเขียนโค้ดเพิ่มเติม
วิธีเปิด Custom Fields ผ่าน WordPress REST API
Custom Fields เป็นข้อมูลเพิ่มเติมของ Post หรือ Custom Post Type
ตัวอย่างเช่น CPT ประเภท Jobs อาจมี Fields ได้แก่
- Salary
- Location
- Employment Type
- Experience
- Department
WordPress ไม่ได้เปิดเผย Post Meta ทุกตัวผ่าน REST API โดยอัตโนมัติ
หากต้องการให้ Meta Field ปรากฏผ่าน REST API สามารถใช้ register_post_meta() และกำหนด show_in_rest
ตัวอย่าง:
add_action( 'init', function () {
register_post_meta(
'portfolio',
'project_location',
array(
'type' => 'string',
'single' => true,
'show_in_rest' => true,
'sanitize_callback' => 'sanitize_text_field',
'auth_callback' => function () {
return current_user_can( 'edit_posts' );
},
)
);
} ); ตัวอย่างนี้กำหนดให้ข้อมูล project_location ใช้ชนิด String และมีการตรวจสิทธิ์ตาม Callback ที่ระบุ
อย่างไรก็ตาม auth_callback ในตัวอย่างอาจไม่เหมาะกับนโยบายข้อมูลของทุกเว็บไซต์ จึงควรปรับสิทธิ์ให้สัมพันธ์กับ Resource และประเภทผู้ใช้จริง
นอกจากนี้ CPT ต้องรองรับ custom-fields เพื่อให้ Registered Post Meta ทำงานผ่าน REST API ตามรูปแบบที่ WordPress กำหนด
ตัวอย่าง JSON Response
เมื่อมีการเปิดเผย Field และบัญชีมีสิทธิ์เข้าถึงตามเงื่อนไข อาจได้รับข้อมูลลักษณะนี้
{
"id": 301,
"title": {
"rendered": "Website Redesign"
},
"meta": {
"project_location": "Bangkok"
}
} ควรระมัดระวังการเปิดเผยข้อมูลส่วนบุคคลหรือข้อมูลที่เป็นความลับผ่าน Custom Fields
ไม่ควรกำหนด show_in_rest โดยไม่ตรวจว่าข้อมูลนั้นสามารถเปิดให้ผู้ใช้งานที่เกี่ยวข้องอ่านได้หรือไม่
WordPress REST API ใช้กับ JetEngine ได้หรือไม่?
ใช้ได้ หาก Custom Post Types และข้อมูลที่เกี่ยวข้องถูกตั้งค่าให้รองรับ REST API อย่างเหมาะสม
สำหรับเว็บไซต์ที่ใช้ JetEngine สามารถตรวจสอบการตั้งค่า CPT และ Fields รวมถึง Endpoints ที่เปิดให้เข้าถึงได้
อย่างไรก็ตาม การเปิด REST API สำหรับ CPT ไม่ได้หมายความว่า Custom Fields ทุกประเภทจะถูกส่งกลับโดยอัตโนมัติ
ฟิลด์ที่มีรูปแบบซับซ้อน เช่น Repeater, Relationship หรือข้อมูลแบบ Object อาจต้องใช้ Schema หรือกระบวนการแปลงข้อมูลเพิ่มเติมตามโครงสร้างของปลั๊กอิน
จึงควรทดสอบ Response จาก Endpoint จริงก่อนพัฒนาระบบเชื่อมต่อ
วิธีสร้าง Custom REST API Endpoint ใน WordPress
หาก Endpoints มาตรฐานไม่ตรงกับความต้องการ สามารถสร้าง Custom Endpoint ได้ด้วย register_rest_route()
ตัวอย่างต่อไปนี้เป็น Endpoint แบบอ่านข้อมูลสาธารณะ โดยส่งสถานะของระบบกลับเป็น JSON
add_action( 'rest_api_init', function () {
register_rest_route(
'demo/v1',
'/status',
array(
'methods' => 'GET',
'callback' => function () {
return rest_ensure_response(
array(
'success' => true,
'message' => 'API is working',
)
);
},
'permission_callback' => '__return_true',
)
);
} ); หลังลงทะเบียนแล้วสามารถเปิด URL:
https://example.com/wp-json/demo/v1/status ตัวอย่าง Response:
{
"success": true,
"message": "API is working"
} Endpoint นี้เปิดให้เข้าถึงแบบ Public โดยตั้งใจ จึงใช้ __return_true ได้เพราะไม่มีข้อมูลส่วนตัวและไม่มีการเปลี่ยนแปลงข้อมูล
แต่หากสร้าง Endpoint ที่อ่านข้อมูลภายใน สร้าง Posts หรือแก้ไขข้อมูล ต้องกำหนด permission_callback ให้ตรวจสอบสิทธิ์อย่างเหมาะสม
ไม่ควรใช้ __return_true กับ Endpoint ที่จัดการข้อมูลสำคัญเพียงเพื่อให้เชื่อมต่อได้ง่ายขึ้น
วิธีสร้าง Custom Endpoint ที่ตรวจสอบ Permission
ตัวอย่าง Endpoint ที่ต้องมีสิทธิ์แก้ไข Posts:
add_action( 'rest_api_init', function () {
register_rest_route(
'demo/v1',
'/protected-status',
array(
'methods' => 'GET',
'callback' => function () {
return rest_ensure_response(
array(
'success' => true,
'message' => 'Authorized request',
)
);
},
'permission_callback' => function () {
return current_user_can( 'edit_posts' );
},
)
);
} ); เมื่อเรียก Endpoint นี้ WordPress จะตรวจสอบว่าผู้ใช้ที่ยืนยันตัวตนมี Capability edit_posts หรือไม่
หากไม่มีสิทธิ์ ระบบจะปฏิเสธคำขอ
สำหรับ Endpoint ที่จัดการ Resource เฉพาะรายการ ควรใช้การตรวจสิทธิ์แบบสัมพันธ์กับ Resource เช่น current_user_can( 'edit_post', $post_id ) เมื่อเหมาะสม
WordPress REST API Security ต้องระวังอะไรบ้าง?
ความปลอดภัยเป็นองค์ประกอบสำคัญในการพัฒนา API โดยเฉพาะเว็บไซต์ที่เชื่อมต่อระบบภายนอก
1. ใช้ HTTPS
ควรส่งข้อมูลที่มี Authentication ผ่าน HTTPS เพื่อป้องกันการเปิดเผย Credentials ระหว่างการรับส่งข้อมูล
2. ใช้สิทธิ์เท่าที่จำเป็น
บัญชี API ควรมีสิทธิ์เฉพาะงานที่ต้องดำเนินการ
ไม่ควรใช้บัญชี Administrator หากงานมีขอบเขตเพียงสร้าง Draft Posts
3. ไม่เปิดเผย Application Password
ไม่ควรใส่ Credential ใน JavaScript ฝั่ง Browser, Git Repository หรือไฟล์ที่เปิดเผยต่อสาธารณะ
ควรเก็บใน Environment Variables หรือ Secret Management System ตามความเหมาะสม
4. ตรวจสอบ Permission ทุก Endpoint
Custom Endpoints ที่มีข้อมูลสำคัญต้องใช้ permission_callback เพื่อบังคับใช้สิทธิ์
5. Validate และ Sanitize Input
ข้อมูลจาก API Request ไม่ควรถูกเชื่อถือโดยอัตโนมัติ
ควรกำหนดชนิดข้อมูล ตรวจสอบค่า และใช้ฟังก์ชัน Sanitize ที่เหมาะสม
6. Escape Output
เมื่อนำข้อมูลไปแสดงบนหน้าเว็บ ควร Escape ตามบริบท เพื่อช่วยลดความเสี่ยงจากการแทรกโค้ดที่ไม่เหมาะสม
7. จำกัดคำขอเมื่อจำเป็น
ระบบ API ที่มีภาระงานสูงหรือมีความเสี่ยงถูกใช้งานผิดประเภทอาจต้องมี Rate Limiting หรือมาตรการควบคุมตามโครงสร้างเซิร์ฟเวอร์
8. บันทึกการใช้งานอย่างเหมาะสม
ระบบ Integration ควรมี Logs สำหรับตรวจสอบข้อผิดพลาด แต่ไม่ควรบันทึก Secrets หรือข้อมูลส่วนบุคคลเกินความจำเป็น
9. เพิกถอน Credentials ที่ไม่ได้ใช้งาน
หากยกเลิกการเชื่อมต่อกับบริการใด ควรเพิกถอน Application Password หรือ Token ที่เกี่ยวข้อง
10. อัปเดต WordPress และ Plugins
ควรติดตาม Security Updates และทดสอบความเข้ากันได้ของปลั๊กอินที่สร้าง REST Endpoints เพิ่มเติม
จำเป็นต้องปิด WordPress REST API เพื่อความปลอดภัยหรือไม่?
ไม่จำเป็นเสมอไป
WordPress REST API เป็นส่วนหนึ่งของระบบ WordPress และมีการใช้งานในฟีเจอร์ต่าง ๆ รวมถึง Block Editor และปลั๊กอินหลายประเภท
การปิด REST API ทั้งหมดอาจทำให้ฟังก์ชันบางอย่างไม่สามารถใช้งานได้
สำหรับเว็บไซต์ทั่วไป ควรเริ่มจากตรวจสอบว่า Endpoints ที่เปิดอยู่มี Permission และการเข้าถึงข้อมูลถูกต้องหรือไม่
หากพบ Endpoint ที่เปิดเผยข้อมูลที่ไม่ควรเปิดเผย ควรแก้ไขการลงทะเบียน Resource หรือ Permission โดยตรง แทนการปิด REST API ทั้งระบบโดยไม่มีการวิเคราะห์
WordPress REST API Error ที่พบบ่อย
ระหว่างพัฒนาระบบ Integration อาจพบ HTTP Error หรือ WordPress REST API Error หลายประเภท
400 Bad Request
หมายถึงคำขอไม่ถูกต้อง เช่น ส่ง Parameters ผิดประเภทหรือไม่ตรงตาม Schema
ควรตรวจสอบ Request Body, Query Parameters และ Error Message ที่ API ส่งกลับ
401 Unauthorized
อาจเกิดจากไม่มี Authentication หรือส่ง Credential ไม่ถูกต้อง
ตัวอย่างเช่น Application Password ถูกเพิกถอน หรือไม่ได้ส่ง Authorization Header ตามรูปแบบที่ระบบรองรับ
403 Forbidden
อาจเกิดจากผู้ใช้ไม่มีสิทธิ์ทำงานที่ร้องขอ หรือระบบรักษาความปลอดภัยบล็อกคำขอ
404 Not Found
อาจเกิดจาก Endpoint ไม่มีอยู่จริง Post ID ไม่ถูกต้อง หรือ Resource ที่ร้องขอไม่สามารถเข้าถึงได้ในบริบทนั้น
429 Too Many Requests
อาจเกิดจากระบบ Rate Limiting หรือมาตรการควบคุมคำขอของเซิร์ฟเวอร์หรือบริการที่เกี่ยวข้อง
ไม่ใช่ HTTP Status ที่ WordPress Core ทุกเว็บไซต์จะส่งกลับโดยอัตโนมัติสำหรับคำขอที่มากเกินไป
500 Internal Server Error
อาจเกิดจาก PHP Error, Plugin Conflict หรือปัญหาภายในระบบ
ควรตรวจสอบ Server Logs และ WordPress Debug Logs ในสภาพแวดล้อมที่ปลอดภัย
WordPress REST API ใช้ไม่ได้ แก้อย่างไร?
หากเปิด /wp-json/ แล้วพบข้อผิดพลาด ควรตรวจสอบตามลำดับดังนี้
- ตรวจสอบว่าเว็บไซต์เปิดใช้งานตามปกติ
- ตรวจสอบ Permalink Settings
- ตรวจสอบ Web Server Rewrite Rules
- ตรวจสอบปลั๊กอิน Security
- ตรวจสอบ Firewall และ WAF
- ตรวจสอบ Authentication
- ตรวจสอบ Custom Routes
- ตรวจสอบ PHP Errors
- ตรวจสอบปลั๊กอินหรือ Theme ที่มีความขัดแย้ง
- ทดสอบ Endpoint มาตรฐานก่อน Custom Endpoints
สำหรับเว็บไซต์ที่มี Cloudflare หรือ WAF บางประเภท คำขอ API อาจถูก Challenge หรือ Block ตามกฎความปลอดภัย
ควรตรวจสอบ Logs และปรับกฎเฉพาะคำขอที่จำเป็น ไม่ควรปิดระบบป้องกันทั้งหมดโดยไม่มีเหตุผล
WordPress REST API มีผลต่อความเร็วเว็บไซต์หรือไม่?
REST API เป็นช่องทางรับส่งข้อมูล จึงอาจมีผลต่อภาระงานของเว็บไซต์ตามจำนวนคำขอและรูปแบบการประมวลผล
ตัวอย่างเช่น หากระบบภายนอกเรียก API ทุกวินาทีเพื่อดึงข้อมูล Posts จำนวนมาก เซิร์ฟเวอร์อาจต้องประมวลผล Request และ Database Queries เพิ่มขึ้น
แนวทางปรับประสิทธิภาพ ได้แก่
- ใช้ Pagination
- ใช้
_fieldsเพื่อลดข้อมูล Response - Cache ข้อมูลที่เปลี่ยนไม่บ่อย
- ลด Database Queries ที่ไม่จำเป็น
- หลีกเลี่ยง Polling ถี่เกินไป
- ใช้ Webhooks เมื่อเหมาะสม
- กำหนด Timeout และ Retry Policy
- ตรวจสอบ Query Performance
- ติดตามจำนวน Requests และ Error Rates
อย่างไรก็ตาม การใช้ REST API ไม่ได้ทำให้เว็บไซต์ช้าโดยอัตโนมัติ
ปัญหาความเร็วขึ้นอยู่กับจำนวนคำขอ รูปแบบ Endpoint และทรัพยากรที่ใช้จริง
WordPress REST API กับ AJAX ต่างกันอย่างไร?
AJAX เป็นเทคนิคการส่งคำขอจากหน้าเว็บไปยังเซิร์ฟเวอร์โดยไม่จำเป็นต้องโหลดหน้าเว็บใหม่ทั้งหมด
WordPress มีระบบ admin-ajax.php ซึ่งนิยมใช้กับการดำเนินงานลักษณะนี้
ส่วน REST API เป็นอินเทอร์เฟซสำหรับเข้าถึง Resources ผ่าน Endpoints ที่มีโครงสร้างชัดเจนและใช้ HTTP Methods ตามการออกแบบ API
| หัวข้อ | WordPress REST API | admin-ajax.php |
|---|---|---|
| รูปแบบ URL | /wp-json/... | /wp-admin/admin-ajax.php |
| รูปแบบการออกแบบ | Resource-oriented API | WordPress AJAX Actions |
| การใช้งานกับระบบภายนอก | เหมาะสม | ใช้ได้บางกรณีแต่ไม่ใช่จุดประสงค์หลัก |
| การกำหนด Schema | มีระบบรองรับ | ต้องจัดการเองตามการออกแบบ |
| HTTP Methods | รองรับตาม Endpoint | มักใช้ GET/POST |
| Authentication | ตามระบบ REST API | ตามกลไกและ Hooks ที่ใช้งาน |
สำหรับระบบที่ต้องเชื่อมต่อแอปพลิเคชันภายนอก REST API มักเป็นตัวเลือกที่มีโครงสร้างชัดเจนกว่า
แต่ไม่ได้หมายความว่า REST API เร็วกว่า admin-ajax.php ทุกกรณี เพราะประสิทธิภาพจริงขึ้นอยู่กับโค้ดและลักษณะงาน
WordPress REST API กับ GraphQL ต่างกันอย่างไร?
REST API และ GraphQL เป็นแนวทางเข้าถึงข้อมูลที่แตกต่างกัน
WordPress REST API ใช้ Endpoints ตาม Resources เช่น Posts และ Pages
ส่วน GraphQL เปิดให้ Client ระบุโครงสร้างข้อมูลที่ต้องการผ่าน Query ตาม Schema ที่ระบบกำหนด
WordPress Core มี REST API มาให้ใช้งาน แต่ไม่ได้มี GraphQL API ทั่วไปเป็นฟีเจอร์มาตรฐานโดยตรง
หากต้องการ GraphQL อาจพิจารณาระบบหรือปลั๊กอินที่รองรับ เช่น WPGraphQL
| หัวข้อ | REST API | GraphQL |
|---|---|---|
| รูปแบบการเรียก | หลาย Endpoints ตาม Resource | Query ตาม Schema |
| การเลือก Fields | รองรับ _fields และ Parameters | เลือก Fields ใน Query |
| WordPress Core | มีให้ใช้ | ต้องมีระบบเพิ่ม |
| ความซับซ้อน | เหมาะกับงานทั่วไป | เหมาะกับบางรูปแบบข้อมูลที่ซับซ้อน |
| Authentication | ตามระบบที่ใช้ | ต้องกำหนดตาม Server |
| ประสิทธิภาพ | ขึ้นอยู่กับ Endpoint | ขึ้นอยู่กับ Resolver และ Query |
ควรเลือกตามความเหมาะสมของระบบ ไม่จำเป็นต้องใช้ GraphQL เพียงเพราะเว็บไซต์มีข้อมูลจำนวนมาก
WordPress REST API เหมาะกับ Headless CMS หรือไม่?
เหมาะ เพราะสามารถใช้ WordPress เป็นศูนย์กลางจัดการเนื้อหา แล้วให้ Frontend แยกต่างหากดึงข้อมูลผ่าน API
ตัวอย่างสถาปัตยกรรม:
WordPress CMS
|
| REST API
|
Next.js / React Frontend
|
|
Website Visitors ข้อดีของแนวทางนี้ ได้แก่ ความยืดหยุ่นในการพัฒนา Frontend และการนำเนื้อหาไปใช้หลายช่องทาง
แต่ต้องคำนึงถึงระบบ Preview, Authentication, Caching, SEO Metadata, Redirects และการแสดงเนื้อหาที่เหมาะกับ Search Engines ด้วย
Headless WordPress ไม่ได้รับประกันว่าจะเร็วกว่า WordPress แบบปกติทุกเว็บไซต์
Checklist ก่อนเชื่อม WordPress REST API กับระบบจริง
ก่อนนำ Integration ขึ้น Production ควรตรวจสอบรายการต่อไปนี้
- กำหนดวัตถุประสงค์ของ Integration ชัดเจน
- เลือก Endpoint ที่ถูกต้อง
- ตรวจ HTTP Methods ที่รองรับ
- ตรวจ Request และ Response Schema
- ตรวจ Authentication
- ใช้ HTTPS
- เลือกบัญชีที่มีสิทธิ์เท่าที่จำเป็น
- เก็บ Application Password อย่างปลอดภัย
- ไม่ส่ง Secrets ไปยัง Browser
- ตรวจ Permission ของ Custom Endpoints
- Validate และ Sanitize Input
- ตรวจสอบข้อมูลที่เปิดเผยผ่าน API
- ใช้ Pagination เมื่อมีรายการจำนวนมาก
- กำหนด Timeout
- ออกแบบ Retry และป้องกันรายการซ้ำ
- ทดสอบ Error Responses
- ตรวจสอบ CORS เมื่อเรียกข้ามโดเมน
- ตรวจสอบผลจาก Firewall หรือ WAF
- ใช้ Cache เมื่อเหมาะสม
- ทดสอบบน Staging
- บันทึก Logs โดยไม่เปิดเผย Secrets
- มีแนวทางเพิกถอน Credentials
- มีขั้นตอนสำรองและกู้คืนข้อมูล
การตรวจสอบครบทุกข้อไม่ได้รับประกันว่าระบบจะไม่มีช่องโหว่ทั้งหมด แต่ช่วยลดความเสี่ยงจากข้อผิดพลาดพื้นฐานในการเชื่อมต่อได้
คำถามที่พบบ่อยเกี่ยวกับ WordPress REST API (FAQ)
WordPress REST API คืออะไร?
WordPress REST API คือระบบที่เปิดให้แอปพลิเคชันหรือบริการภายนอกสื่อสารกับ WordPress ผ่าน HTTP Requests และรับส่งข้อมูลในรูปแบบ JSON เพื่ออ่านหรือจัดการข้อมูลตามสิทธิ์ที่กำหนด
WordPress REST API ใช้ทำอะไร?
ใช้ดึงบทความ สร้างหรือแก้ไขเนื้อหา เชื่อม Mobile Applications, CRM, ระบบ Automation, Custom Post Types และพัฒนา Headless WordPress ได้
WordPress มี REST API ในตัวหรือไม่?
มี WordPress Core รองรับ REST API มาตรฐาน โดยทั่วไปสามารถเข้าถึง API Index ผ่าน /wp-json/ ได้ตามการตั้งค่าและสิทธิ์ของเว็บไซต์
WordPress REST API Endpoint คืออะไร?
Endpoint คือ URL ที่ใช้รับคำขอ API สำหรับ Resource หรือการดำเนินการเฉพาะ เช่น /wp-json/wp/v2/posts สำหรับจัดการ Posts
WordPress REST API ใช้ JSON หรือไม่?
ใช่ WordPress REST API ใช้ JSON เป็นรูปแบบหลักในการรับส่งข้อมูล โดย HTTP Response และ Request อาจมีรายละเอียดอื่นเพิ่มเติมตาม Endpoint
WordPress REST API ใช้ฟรีไหม?
REST API มาตรฐานเป็นส่วนหนึ่งของ WordPress Core แต่การใช้ Hosting, ปลั๊กอินเสริม และบริการ Integration ภายนอกอาจมีค่าใช้จ่าย
WordPress REST API ต้องใช้ Authentication ทุกครั้งหรือไม่?
ไม่จำเป็นสำหรับข้อมูลสาธารณะที่ Endpoint อนุญาตให้เข้าถึง แต่การสร้าง แก้ไข หรือลบข้อมูลโดยทั่วไปต้องใช้ Authentication และมี Permissions ที่เหมาะสม
WordPress Application Password คืออะไร?
Application Password เป็น Credential สำหรับให้ระบบภายนอกเชื่อมต่อกับ WordPress โดยแยกจากรหัสผ่านเข้าสู่ระบบปกติ และสามารถเพิกถอนแยกตามการใช้งานได้
WordPress REST API ใช้กับ JavaScript ได้ไหม?
ได้ สามารถใช้ fetch() ส่ง HTTP Requests ไปยัง WordPress REST API แต่ไม่ควรฝัง Application Password หรือ Secrets ลงใน JavaScript ที่ส่งไปยัง Browser
WordPress REST API ใช้กับ PHP ได้ไหม?
ได้ สามารถใช้ PHP HTTP Clients หรือ WordPress HTTP API เช่น wp_remote_get() และ wp_remote_post() เพื่อรับส่งข้อมูลระหว่างระบบ
WordPress REST API ใช้กับ Custom Post Type ได้หรือไม่?
ได้ โดยเปิด show_in_rest สำหรับ CPT และกำหนด rest_base ตามความเหมาะสม เมื่อระบบรองรับจะสามารถเข้าถึงผ่าน Endpoint ของ CPT นั้นได้
WordPress REST API แสดง Custom Fields ได้หรือไม่?
ได้ หาก Field ถูกลงทะเบียนให้รองรับ REST API อย่างถูกต้อง เช่น ใช้ register_post_meta() พร้อม show_in_rest และกำหนดสิทธิ์เข้าถึงที่เหมาะสม
WordPress REST API เชื่อม JetEngine ได้ไหม?
ได้ โดยตรวจสอบว่า CPT และ Fields ที่ใช้กับ JetEngine เปิดให้เข้าถึงผ่าน REST API ตามรูปแบบที่รองรับ และทดสอบ Response จริงก่อนพัฒนาระบบ Integration
WordPress REST API ปลอดภัยหรือไม่?
สามารถใช้งานอย่างปลอดภัยได้เมื่อกำหนด Authentication, Permissions, HTTPS และการตรวจสอบข้อมูลอย่างเหมาะสม แต่ Custom Endpoints หรือปลั๊กอินที่พัฒนาไม่รัดกุมอาจสร้างความเสี่ยงได้
ควรปิด WordPress REST API หรือไม่?
ไม่ควรปิดทั้งหมดโดยไม่มีเหตุผล เพราะ WordPress และปลั๊กอินหลายตัวใช้ REST API ควรตรวจสอบและจำกัดสิทธิ์ของ Endpoints ที่มีความเสี่ยงแทน
WordPress REST API Error 401 แก้อย่างไร?
ควรตรวจสอบ Credentials, Authorization Header, Application Password และวิธี Authentication ที่ Endpoint รองรับ
WordPress REST API Error 403 เกิดจากอะไร?
อาจเกิดจากผู้ใช้ไม่มีสิทธิ์ตาม Capability หรือถูกระบบ Security, Firewall หรือ WAF ปฏิเสธคำขอ
WordPress REST API Error 404 เกิดจากอะไร?
อาจเกิดจาก Route ไม่มีอยู่จริง URL ผิด Resource ไม่พบ หรือการตั้งค่า Rewrite และ Permalinks มีปัญหา
WordPress REST API ทำให้เว็บไซต์ช้าหรือไม่?
ไม่โดยอัตโนมัติ แต่หากมี Requests จำนวนมากหรือ Endpoint ใช้ Database Query หนัก อาจเพิ่มภาระเซิร์ฟเวอร์ได้ ควรใช้ Pagination, Cache และการออกแบบ API ที่เหมาะสม
REST API กับ AJAX ต่างกันอย่างไร?
REST API เป็นระบบเข้าถึง Resources ผ่าน Endpoints และ HTTP Methods ส่วน AJAX เป็นเทคนิคส่งคำขอจากหน้าเว็บแบบไม่ต้อง Reload ทั้งหน้า โดย WordPress มี admin-ajax.php เป็นอีกช่องทางหนึ่งสำหรับงานลักษณะนี้
WordPress REST API เหมาะกับ Headless WordPress หรือไม่?
เหมาะ เพราะสามารถให้ WordPress ทำหน้าที่จัดการเนื้อหา และให้ Frontend ที่พัฒนาด้วยเทคโนโลยีอื่นดึงข้อมูลผ่าน API ได้
สรุป WordPress REST API คืออะไร และควรใช้อย่างไร?
WordPress REST API เป็นระบบสำคัญที่ช่วยให้ WordPress เชื่อมต่อกับเว็บไซต์ แอปพลิเคชัน และบริการภายนอกผ่าน HTTP และ JSON ได้อย่างเป็นมาตรฐาน
นักพัฒนาสามารถใช้ REST API เพื่อดึงข้อมูล Posts, Pages และ Resources อื่น รวมถึงสร้างหรือแก้ไขข้อมูลเมื่อมีสิทธิ์ที่เหมาะสม
สำหรับเว็บไซต์ที่ใช้ Custom Post Types และ Custom Fields สามารถเปิด REST API เพื่อใช้ข้อมูลกับระบบอื่นได้ แต่ต้องกำหนด Schema และ Permissions ให้ถูกต้อง โดยเฉพาะข้อมูลที่ไม่ควรเปิดเผยต่อสาธารณะ
การเชื่อมต่อระบบภายนอกควรให้ความสำคัญกับ Application Passwords, HTTPS, Capability Checks, Input Validation, Error Handling และการจัดเก็บ Credentials อย่างปลอดภัย
นอกจากนี้ การออกแบบ API ที่มีประสิทธิภาพควรใช้ Pagination, Response Filtering และ Cache ตามความเหมาะสม เพื่อลดภาระงานของเซิร์ฟเวอร์
ท้ายที่สุด WordPress REST API ไม่ใช่เพียงเครื่องมือสำหรับอ่านข้อมูลเว็บไซต์ แต่เป็นพื้นฐานสำคัญของการพัฒนา WordPress Integration, Automation และ Headless CMS ที่สามารถขยายความสามารถของเว็บไซต์ให้ทำงานร่วมกับระบบอื่นได้อย่างยืดหยุ่นและปลอดภัย
แหล่งข้อมูลอ้างอิง
- WordPress Developer Resources – REST API Handbook
- WordPress REST API – Authentication
- WordPress REST API – Endpoint Reference
- WordPress REST API – Pagination
- WordPress REST API – Global Parameters
- WordPress REST API – Adding Custom Endpoints
- WordPress REST API – Adding Custom Content Types
- WordPress REST API – Modifying Responses
- WordPress Developer Resources – Application Passwords
- WordPress Developer Resources – register_post_meta()
อย่ารอช้า! ให้ KNmasters ดูแลธุรกิจของคุณวันนี้!
หากคุณต้องการข้อมูลเพิ่มเติมหรืออยากเริ่มใช้บริการกับ KNmasters เราพร้อมช่วยให้ธุรกิจของคุณเติบโตด้วยกลยุทธ์การตลาดออนไลน์ครบวงจร
- Facebook: KNmasters
- LINE: @851ioidr
- Youtube: KNmasters
- Instagram: knmasters.official
- Tiktok: KNmasters.official
- Twitter: KNmasters Official
- Fastwork: KNmasters
- เว็บไซต์: www.knmasters.com
- แผนที่: KNmasters
- WordPress
- 2026-11-22 03:07:21
บริการของเรา
แบรนด์ที่ไว้วางใจเรา
บทความที่เกี่ยวข้อง
ผู้ช่วยที่จะขับเคลื่อนธุรกิจของคุณให้เติบโตอย่างมั่นคง
หากคุณกำลังมองหาทีมที่เข้าใจธุรกิจของคุณจริงๆ และพร้อมเปลี่ยนไอเดียให้กลายเป็นผลลัพธ์ที่จับต้องได้ KNmasters พร้อมอยู่เคียงข้างเพื่อให้คำปรึกษา วางกลยุทธ์ และสร้างแนวทางที่เหมาะกับคุณ เราช่วยให้ธุรกิจของคุณเติบโตได้อย่างยั่งยืนในโลกออนไลน์

