logo
GeekFormat

เครื่องมือตรวจสอบ CORS

แผงตรวจสอบ CORS

จำลอง preflight และคำขอจริงจากฝั่งเซิร์ฟเวอร์ ระบุปัญหาได้อย่างรวดเร็วว่าเกิดจาก Allow-Origin, Allow-Headers หรือ credentials

จำลอง CORS preflight และคำขอจริงจากเซิร์ฟเวอร์ ตรวจสอบส่วนหัวหลัก 6 รายการ ค้นหาข้อผิดพลาดการตั้งค่าข้ามโดเมนอย่างแม่นยำ พร้อมตัวอย่างโค้ด Nginx/Node.js/Spring

คำแนะนำที่เกี่ยวข้อง

กรณีการใช้งาน

  • เมื่อคอนโซลเบราว์เซอร์แสดงข้อผิดพลาด No 'Access-Control-Allow-Origin' header ใช้เครื่องมือนี้ทันทีเพื่อตรวจสอบส่วนหัว CORS ที่อินเทอร์เฟซเป้าหมายส่งคืนจริง
  • ในระหว่างการเชื่อมต่อโปรเจ็กต์ฟรอนต์เอนด์-แบ็กเอนด์แยกกัน ตรวจสอบว่าการตั้งค่า CORS ของแบ็กเอนด์ทำงานถูกต้อง หลีกเลี่ยงการเสียเวลาแก้ไขแบบไม่มีจุดหมาย
  • หลังกำหนดค่า Nginx, Apache reverse proxy หรือ API gateway (Kong/APISIX/Spring Cloud Gateway) ตรวจสอบว่ากฎ CORS ถูกส่งผ่านอย่างถูกต้อง
  • เมื่อคำขอข้ามโดเมนที่มี Cookie ล้มเหลว สลับโหมด credentials เพื่อตรวจสอบความขัดแย้งระหว่าง Allow-Credentials และ Allow-Origin
  • หลังเพิ่มส่วนหัวคำขอที่กำหนดเอง (เช่น X-Token, X-Requested-With) คำขอถูกบล็อก ตรวจสอบว่าได้ประกาศใน Allow-Headers อย่างถูกต้องหรือไม่
  • คำขอข้ามโดเมนด้วยวิธีที่ไม่ใช่ simple method เช่น PUT/DELETE/PATCH ล้มเหลว ตรวจสอบว่า Allow-Methods มีวิธีที่เกี่ยวข้องหรือไม่
  • ฟรอนต์เอนด์ไม่สามารถอ่านส่วนหัวการตอบสนองที่กำหนดเอง (เช่น X-Request-Id, X-Total-Count) ตรวจสอบการตั้งค่า Access-Control-Expose-Headers
  • หลังใช้ CDN การข้ามโดเมนทำงานไม่สม่ำเสมอ ตรวจสอบว่า Vary: Origin ถูกตั้งค่าถูกต้องเพื่อหลีกเลี่ยง CDN แคชการตอบสนองที่ผิด
  • สำหรับข้อผิดพลาดข้ามโดเมนที่เกิดขึ้นเป็นครั้งคราวในสภาพแวดล้อมการผลิต จำลองสถานการณ์ปัญหาและเก็บรักษาข้อความการตอบสนองที่สมบูรณ์สำหรับแบ็กเอนด์ตรวจสอบ
  • เมื่อเรียนรู้หลักการ CORS สังเกตผลของแต่ละส่วนหัวผ่านคำขอจริง เพื่อทำความเข้าใจกลไกข้ามโดเมนให้ลึกซึ้งยิ่งขึ้น

คุณสมบัติ

  • จำลองคำขอ preflight และคำขอจริงจากเซิร์ฟเวอร์โดยตรง ไม่ถูกรบกวนจากแคชและปลั๊กอินของเบราว์เซอร์ ผลลัพธ์ถูกต้องแม่นยำกว่า
  • แสดงการตอบสนอง OPTIONS preflight และคำขอ GET/POST จริงแยกกัน ช่วยระบุได้ชัดเจนว่ามีปัญหาที่ขั้นตอนใด
  • ตรวจสอบส่วนหัว CORS หลัก 6 รายการทีละข้อ: Access-Control-Allow-Origin, Allow-Methods, Allow-Headers, Allow-Credentials, Expose-Headers, Max-Age แต่ละส่วนหัวมีสถานะผ่าน/เตือน/ล้มเหลวแยกกัน
  • ตรวจจับความขัดแย้งคลาสสิกระหว่างสัญลักษณ์ * และโหมด credentials อย่างชาญฉลาด แจ้งเตือนกับดักการตั้งค่าที่พบบ่อยทันที
  • รองรับการกำหนด Origin, วิธี HTTP (GET/POST/PUT/DELETE/PATCH/HEAD/OPTIONS) และส่วนหัวคำขอที่กำหนดเองได้
  • สลับโหมดส่ง credentials (Cookie/ส่วนหัว Authorization/ใบรับรองไคลเอ็นต์ TLS) เพื่อจำลองสถานการณ์ withCredentials=true
  • ตรวจสอบอัตโนมัติว่าส่วนหัว Vary: Origin ถูกตั้งค่าถูกต้องหรือไม่ เพื่อป้องกัน CDN/reverse proxy แคชการตอบสนอง CORS ที่ไม่ถูกต้อง
  • แสดงการตั้งค่า Max-Age ของ preflight cache อย่างมีโครงสร้าง ประเมินผลกระทบต่อประสิทธิภาพจากความถี่ของคำขอ preflight
  • ตรวจสอบการตั้งค่า Access-Control-Expose-Headers ยืนยันว่าส่วนหัวใดที่ JavaScript ของฟรอนต์เอนด์สามารถอ่านได้
  • ให้คำแนะนำการแก้ไขทีละบรรทัด รวมถึงตัวอย่างการตั้งค่าสำหรับเฟรมเวิร์กยอดนิยม Nginx, Apache, Node.js/Express, Spring Boot, Python/Django/Flask
  • บันทึกข้อความดิบของคำขอและการตอบสนองอย่างสมบูรณ์ รวมถึงรหัสสถานะ ส่วนหัวการตอบสนองทั้งหมด และตัวอย่างเนื้อหาการตอบสนอง
  • ระบุความแตกต่างระหว่าง simple request และคำขอที่ต้อง preflight อัตโนมัติ อธิบายว่าทำไมคำขอของคุณถึงเรียกใช้ OPTIONS preflight
  • ตรวจจับปัญหา CORS ในสถานการณ์การเปลี่ยนเส้นทาง (ว่า Origin เปลี่ยนหลังจากการกระโดด 301/302/307/308 หรือไม่)
  • รองรับการตรวจสอบสถานการณ์เนื้อหาผสม HTTPS/HTTP แจ้งปัญหาข้ามโดเมนที่เกิดจากเนื้อหาผสม

วิธีการใช้งาน

  1. กรอกที่อยู่ที่สมบูรณ์ของอินเทอร์เฟซที่ต้องการตรวจสอบในช่อง URL เป้าหมาย (รองรับ http/https ต้องมี path)
  2. กรอก Origin จริงของหน้าฟรอนต์เอนด์ในช่อง Origin ของคำขอ (เช่น https://example.com ต้องมีโปรโตคอลและพอร์ต ไม่ต้องมี path ต่อท้าย)
  3. เลือกวิธีคำขอ HTTP (GET/POST/PUT/DELETE/PATCH/HEAD/OPTIONS) ค่าเริ่มต้นคือ GET
  4. เพิ่มส่วนหัวที่ต้องการส่งในพื้นที่ส่วนหัวคำขอที่กำหนดเอง หนึ่งรายการต่อบรรทัดในรูปแบบเช่น X-Token: abc123 หาก Content-Type เป็นประเภทที่ไม่ใช่ simple type เช่น application/json จะเรียก preflight อัตโนมัติ
  5. ทำเครื่องหมายตัวเลือก "ส่ง credentials" ตามสถานการณ์ของคุณ — ต้องทำเครื่องหมายหากโค้ดฟรอนต์เอนด์ใช้ withCredentials=true หรือ credentials: 'include' ของ fetch
  6. คลิกปุ่ม "เริ่มตรวจสอบ" เครื่องมือจะส่งคำขอ OPTIONS preflight และคำขอจริงตามลำดับจากเซิร์ฟเวอร์ (ถ้า preflight ผ่านหรือไม่จำเป็น)
  7. ดูรายงานการวิเคราะห์: ดูผลประเมินรวมก่อน จากนั้นตรวจสอบสถานะแต่ละส่วนหัว CORS ทีละรายการ ปรับการตั้งค่าเซิร์ฟเวอร์ตามคำแนะนำการแก้ไข แล้วทดสอบใหม่เพื่อยืนยัน

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

เหตุใด Postman/curl ขอได้ปกติ แต่เบราว์เซอร์เข้าถึงก็แจ้งข้อผิดพลาดข้ามโดเมน?

นี่คือปัญหา CORS ที่คลาสสิกที่สุด! เพราะ Postman และ curl ไม่ได้รับผลกระทบจากนโยบายต้นทางเดียวกันเลย — พวกมันคือไคลเอ็นต์ HTTP ไม่ใช่เบราว์เซอร์ ไม่บล็อกการตอบสนอง และไม่ส่ง OPTIONS preflight อัตโนมัติ ข้อผิดพลาดข้ามโดเมนเป็นกลไกความปลอดภัยเฉพาะของเบราว์เซอร์ เฉพาะสภาพแวดล้อม JavaScript ของเบราว์เซอร์เท่านั้นที่ตรวจสอบ CORS Postman เรียกสำเร็จพิสูจน์ได้แค่ว่าอินเทอร์เฟซส่งคืนข้อมูลได้ ไม่ได้พิสูจน์ว่า CORS ถูกต้อง คุณต้องใช้เบราว์เซอร์หรือเครื่องมือนี้ (จำลองกระบวนการ CORS ฝั่งเซิร์ฟเวอร์) ในการตรวจสอบ

ข้อผิดพลาด CORS เป็นปัญหาฟรอนต์เอนด์หรือแบ็กเอนด์ ควรให้ใครแก้?

99% ของข้อผิดพลาด CORS เป็นปัญหาการตั้งค่าแบ็กเอนด์ ฟรอนต์เอนด์สามารถทำได้น้อยมาก แก่นของ CORS คือเซิร์ฟเวอร์ให้สิทธิ์เบราว์เซอร์ผ่านส่วนหัว ฟรอนต์เอนด์สามารถตั้งค่า withCredentials ได้เท่านั้น ไม่สามารถหลีกเลี่ยงข้อจำกัดความปลอดภัยได้ การใช้พร็อกซีของฟรอนต์เอนด์เป็นการหลอกเบราว์เซอร์ให้คิดว่าเป็นต้นทางเดียวกัน ไม่ใช่การแก้ CORS อย่างแท้จริง สภาพแวดล้อมการผลิตยังต้องให้แบ็กเอนด์กำหนดค่า CORS ที่ถูกต้อง

เหตุใด GET ไม่ข้ามโดเมน แต่พอเปลี่ยนเป็น POST/PUT ก็ข้ามโดเมน?

เพราะ GET มักตรงตาม simple request เบราว์เซอร์ส่งโดยตรง; ส่วน POST หากส่ง Content-Type: application/json (90% ของอินเทอร์เฟซ POST) จะไม่เป็น simple request จะเรียก OPTIONS preflight คำขอ preflight ต้องการส่วนหัว CORS ที่ถูกต้อง หลายคนกำหนดส่วนหัวแค่ GET/POST แต่ไม่จัดการ OPTIONS วิธี PUT/DELETE/PATCH เองก็ไม่ใช่วิธีอย่างง่าย จำเป็นต้องเรียก preflight แน่นอน

สภาพแวดล้อมการพัฒนาแก้ปัญหาข้ามโดเมนอย่างไร? สภาพแวดล้อมการผลิตล่ะ?

สภาพแวดล้อมการพัฒนามีหลายวิธี: ①พร็อกซีในตัวของเฟรมเวิร์ก (devServer.proxy, server.proxy): พร็อกซีคำขอไปยังต้นทางเดียวกัน; ②ปิดพารามิเตอร์ความปลอดภัยของเบราว์เซอร์ด้วย --disable-web-security จำกัดสำหรับทดสอบในเครื่องเท่านั้น; ③แบ็กเอนด์กำหนดค่า CORS อนุญาต localhost (แนะนำ) สภาพแวดล้อมการผลิตจำเป็นต้องให้แบ็กเอนด์กำหนดค่า CORS ที่ถูกต้อง: whitelist, Allow-Methods/Allow-Headers/Allow-Credentials, Vary: Origin หรือใช้เกตเวย์/Nginx จัดการอย่างเป็นหนึ่งเดียว

Access-Control-Allow-Origin กำหนดค่าหลายแหล่งที่มาได้หรือไม่?

ไม่ได้ ส่วนหัวนี้มีได้เพียงหนึ่งค่า ไม่ว่าจะเป็นแหล่งที่มาแบบเจาะจงหรือ * เบราว์เซอร์จะไม่ยอมรับหลายแหล่งที่มา วิธีที่ถูกต้องคือ: เซิร์ฟเวอร์ดูแลรักษา whitelist ทุกครั้งที่ได้รับคำขอให้อ่าน Origin ตรวจสอบว่าอยู่ใน whitelist หรือไม่ หากอยู่ให้ส่งคืน Access-Control-Allow-Origin เป็นค่า Origin นั้น พร้อม Vary: Origin อย่าพยายามส่งคืนส่วนหัวหลายตัวหรือคั่นด้วยจุลภาค

คำขอ OPTIONS preflight จำเป็นต้องส่งคืนตรรกะทางธุรกิจหรือไม่? สามารถส่งคืน 204 โดยตรงได้หรือไม่?

OPTIONS preflight ไม่จำเป็นต้องส่งคืนตรรกะทางธุรกิจและเนื้อหาใดๆ เพียงส่วนหัว CORS ที่ถูกต้องและ 200/204 ก็เพียงพอ แนวทางปฏิบัติที่ดีที่สุดคือ: ดัก OPTIONS ที่ Nginx/เกตเวย์โดยตรง ส่งคืน 204 No Content และส่วนหัว CORS ที่ถูกต้อง ไม่ต้องส่งต่อแบ็กเอนด์ ลดภาระและหลีกเลี่ยง 405 แต่ต้องตรวจสอบให้แน่ใจว่าส่วนหัว CORS ของ OPTIONS สอดคล้องกับคำขอจริง

เหตุใดตั้งค่า withCredentials: true แล้ว Cookie ยังไม่ถูกส่ง?

คำขอข้ามโดเมนที่มี Cookie ต้องตรงตามสามเงื่อนไข: ①withCredentials=true หรือ credentials: 'include'; ②Allow-Credentials: true; ③Allow-Origin ต้องเป็นแหล่งที่มาแบบเจาะจง (ห้าม *) ขาดอย่างใดอย่างหนึ่งไม่ได้ นอกจากนี้ Cookie ต้องตั้งค่า SameSite=None; Secure (HTTPS) จึงจะส่งข้ามโดเมนได้; SameSite=Lax/Strict จะไม่นำมา; คุณสมบัติ Domain ต้องถูกต้อง; ยังต้องสังเกตนโยบาย Cookie ของบุคคลที่สาม

CORS กับ CSRF มีความสัมพันธ์กันอย่างไร? กำหนดค่า CORS จะทำให้เกิดช่องโหว่ CSRF หรือไม่?

CORS คือการผ่อนปรนข้อจำกัดข้ามโดเมน CSRF คือการโจมตีปลอมแปลงคำขอข้ามไซต์ ทั้งสองเป็นแนวคิดที่แตกต่าง การกำหนดค่า CORS อย่างถูกต้องจะไม่ทำให้เกิด CSRF โดยตรง — CORS เพียงอนุญาตให้ JS อ่านการตอบสนอง ส่วน CSRF คือผู้โจมตีชักจูงผู้ใช้ส่งคำขอโดยไม่รู้ตัว คำขอเหล่านี้แม้ไม่มี CORS ก็จะถูกส่งไปพร้อม Cookie การป้องกัน CSRF ต้องใช้ CSRF Token, SameSite Cookie, ตรวจสอบ Origin/Referer อย่าป้องกัน CSRF ด้วยการปิด CORS แต่หาก Allow-Origin เป็น * และอนุญาต credentials จะขยายความเสี่ยง CSRF ดังนั้นเมื่อส่ง credentials ห้ามใช้ *

การดาวน์โหลดไฟล์ การเปลี่ยนเส้นทาง การโหลดแท็กรูปภาพ/script มีปัญหา CORS หรือไม่?

การโหลดทรัพยากรด้วย <img>, <script>, <link> ปกติจะไม่มีปัญหา CORS เป็น "ทรัพยากรที่ฝัง" ไม่ใช่ AJAX เบราว์เซอร์อนุญาตให้โหลดแต่ JS ไม่สามารถอ่านเนื้อหาได้ แต่หากต้องการใช้ Canvas จัดการรูปภาพข้ามโดเมนหรือใช้ fetch/XHR อ่านเนื้อหา จำเป็นต้องมี CORS และเพิ่มแอตทริบิวต์ crossorigin การดาวน์โหลดไฟล์ข้ามโดเมนไม่จำเป็นต้องมี CORS การเปลี่ยนเส้นทางจะส่งผลต่อ CORS: หาก OPTIONS ส่งคืน 3xx เบราว์เซอร์จะปฏิเสธโดยตรง (Preflight redirect not allowed)

Nginx กำหนดค่า CORS อย่างไรให้ถูกต้อง? ขอตัวอย่างการตั้งค่าที่ใช้งานได้?

ประเด็นสำคัญ: ①ใช้ map จับคู่ Origin whitelist ตั้งค่า $cors_origin แบบไดนามิก; ②OPTIONS ส่งคืน 204 โดยตรงไม่ต้องส่งต่อ; ③add_header ต้องเพิ่ม always เพื่อให้แน่ใจว่าการตอบสนองข้อผิดพลาดก็มีส่วนหัว; ④เพิ่ม Vary: Origin; ⑤กำหนดค่า Allow-Methods/Allow-Headers/Credentials อย่างถูกต้อง ตัวอย่างการตั้งค่าสามารถพบได้ในคำแนะนำการแก้ไขของเครื่องมือนี้ สำหรับ Nginx, Apache, Node.js Express, Spring Boot, Flask/Django, Koa, Go Gin เรามีตัวอย่างที่ผ่านการตรวจสอบแล้ว

หลังกำหนดค่า CORS แล้วจะยืนยันได้อย่างไรว่าใช้งานได้?

ขั้นตอนการยืนยัน: ①ใช้เครื่องมือนี้ตรวจสอบออนไลน์ก่อน; ②เปิด DevTools Network ทำเครื่องหมาย Disable cache กระตุ้นคำขอ ตรวจสอบส่วนหัว OPTIONS และคำขอจริง; ③ดู Console ว่ามีข้อผิดพลาดหรือไม่; ④ทดสอบสถานการณ์ต่างๆ: GET ไม่มีส่วนหัว, POST แบบ application/json, PUT/DELETE, มี/ไม่มี Cookie, มีส่วนหัวที่กำหนดเอง; ⑤ใช้ curl จำลอง OPTIONS: curl -i -X OPTIONS -H "Origin: https://yoursource.com" https://api.example.com/endpoint

เหตุใดคำขอข้ามโดเมนจึงมีข้อผิดพลาดใน Chrome แต่ใน Safari/Firefox ปกติ? หรือกลับกัน?

เบราว์เซอร์ต่างๆ มีความแตกต่างกันในรายละเอียด CORS: ①Safari จำกัด Max-Age เข้มงวดกว่า นโยบาย Cookie (ITP) ก็เข้มงวดกว่า; ②Chrome ตรวจสอบสัญลักษณ์แทนเมื่อส่ง credentials เข้มงวดกว่า ไม่อนุญาต *; ③IE11 ใช้ XDomainRequest แทน XMLHttpRequest มีข้อจำกัดมากมาย; ④การประมวลผล Vary, การเปลี่ยนเส้นทาง, ส่วนหัวความปลอดภัยมีความแตกต่างละเอียดอ่อน วิธีแก้คือกำหนดค่าตามข้อกำหนดอย่างเข้มงวด อย่าพึ่งพาพฤติกรรมของเบราว์เซอร์ใดเบราว์เซอร์หนึ่ง

Access-Control-Max-Age ควรตั้งค่าเท่าใด? ตั้งค่ายาวหรือสั้นเกินไปมีปัญหาอะไร?

แนะนำ 3600 (1 ชั่วโมง) ถึง 86400 (24 ชั่วโมง) สั้นเกินไป (60 วินาที): แคชหมดเร็ว ส่ง OPTIONS บ่อย เพิ่มเวลาและภาระเซิร์ฟเวอร์ ยาวเกินไป (หนึ่งปี): หลังอัปเดตการตั้งค่าแคชเก่าอาจอยู่นาน ทำให้การตั้งค่าใหม่ไม่ทำงาน Chrome/Firefox ตัดค่าเกิน 86400 ไว้ที่ 86400 โดยอัตโนมัติ สภาพแวดล้อมการพัฒนาสามารถตั้งค่าเป็น -1 ปิดแคชเพื่อความสะดวกในการดีบัก

WebSocket มีปัญหาข้ามโดเมนหรือไม่? CORS ใช้กับ WebSocket หรือไม่?

WebSocket (ws:// และ wss://) ไม่ได้รับผลกระทบจากกลไก CORS ของ HTTP เพราะเป็นโปรโตคอลอิสระ แต่ระยะ handshake เป็นคำขอ HTTP เซิร์ฟเวอร์สามารถตรวจสอบ Origin เพื่อตัดสินใจอนุญาตการเชื่อมต่อ — นี่คือการควบคุมสิทธิ์ระดับ WebSocket ไม่ใช่ CORS มาตรฐาน แต่หลักการคล้ายกัน หาก WebSocket ถูกปฏิเสธ ต้องตรวจสอบการตั้งค่าการตรวจสอบ Origin ของเซิร์ฟเวอร์ WebSocket ไม่ใช่ส่วนหัว CORS ของ HTTP

ผลการตรวจสอบของเครื่องมือนี้สอดคล้องกับเบราว์เซอร์หรือไม่? เหตุใดเครื่องมือผ่านแล้วแต่เบราว์เซอร์ยังมีข้อผิดพลาด?

เครื่องมือนี้จำลองกระบวนการ preflight และคำขอจริงตามข้อกำหนด W3C CORS อย่างเข้มงวดฝั่งเซิร์ฟเวอร์ ตรรกะสอดคล้องกับเบราว์เซอร์สมัยใหม่โดยพื้นฐาน หากเครื่องมือผ่านแต่เบราว์เซอร์ยังมีข้อผิดพลาด สาเหตุที่เป็นไปได้: ①เบราว์เซอร์แคชผลลัพธ์เก่า ลอง Ctrl+F5 รีเฟรชหรือล้างแคช; ②ส่วนขยายเบราว์เซอร์แก้ไขหรือบล็อกคำขอ; ③การตั้งค่าที่กรอกในเครื่องมือไม่สอดคล้องกับที่ฟรอนต์เอนด์ส่งจริง; ④แคชโหนด CDN/พร็อกซีไม่สอดคล้องกัน; ⑤เบราว์เซอร์มีนโยบายความปลอดภัยพิเศษ (เนื้อหาผสม, ข้อจำกัด file://)

术语表

CORS (Cross-Origin Resource Sharing)
กลไกความปลอดภัยของเบราว์เซอร์ที่กำหนดโดย W3C ช่วยให้เซิร์ฟเวอร์ประกาศว่า origin ใดมีสิทธิ์เข้าถึงทรัพยากรใด โดยเพิ่มชุดส่วนหัวการตอบสนองที่ขึ้นต้นด้วย Access-Control- ในระดับโปรโตคอล HTTP
นโยบายต้นทางเดียวกัน (Same-Origin Policy)
กลไกความปลอดภัยหลักประการหนึ่งของเบราว์เซอร์ ห้าม JavaScript ส่งคำขอ HTTP ไปยังเซิร์ฟเวอร์ต้นทางอื่นตามค่าเริ่มต้น ป้องกันไม่ให้ไซต์ที่เป็นอันตรายอ่านข้อมูลละเอียดอ่อนจากเว็บไซต์อื่น
คำขอ Preflight (Preflight Request)
ก่อนส่งคำขอข้ามโดเมนที่อาจมีผลกับข้อมูลเซิร์ฟเวอร์ เบราว์เซอร์จะส่งคำขอ OPTIONS ล่วงหน้าเพื่อสอบถามเซิร์ฟเวอร์ เซิร์ฟเวอร์ต้องตอบกลับด้วยส่วนหัว CORS ที่ถูกต้อง มิฉะนั้นเบราว์เซอร์จะไม่ส่งคำขอจริง
คำขออย่างง่าย (Simple Request)
คำขอที่ตรงตามเงื่อนไขทั้งหมด: วิธีคือ GET/HEAD/POST, Content-Type เป็น text/plain/multipart/form-data/application/x-www-form-urlencoded เท่านั้น ไม่มีส่วนหัวคำขอที่กำหนดเอง จะถูกส่งโดยตรงโดยไม่ส่ง OPTIONS preflight
Access-Control-Allow-Origin (ACAO)
ส่วนหัว CORS ที่สำคัญที่สุด ระบุ origin ที่ได้รับอนุญาตให้เข้าถึงทรัพยากร ค่าอาจเป็น * หรือ origin ที่ระบุ เมื่อส่ง credentials ไม่สามารถใช้ * ได้
Access-Control-Allow-Methods (ACAM)
ส่วนหัวตอบสนอง preflight ระบุวิธี HTTP ทั้งหมดที่เซิร์ฟเวอร์รองรับ คั่นด้วยจุลภาค ต้องระบุทุกวิธีที่ใช้
Access-Control-Allow-Headers (ACAH)
ส่วนหัวตอบสนอง preflight ระบุส่วนหัวคำขอทั้งหมดที่อนุญาต เมื่อคำขอมีส่วนหัวที่กำหนดเองต้องประกาศที่นี่
Access-Control-Allow-Credentials (ACAC)
ระบุว่าอนุญาตให้ส่ง credentials ในการขอข้ามโดเมนหรือไม่ ค่าต้องเป็น true ตัวพิมพ์เล็ก
Access-Control-Max-Age (ACMA)
ระบุเวลาที่ผลลัพธ์ preflight สามารถแคชได้ (หน่วยวินาที) ลดคำขอ OPTIONS ซ้ำที่ไม่จำเป็น
Vary: Origin
ส่วนหัวตอบสนองที่บอก CDN/reverse proxy ว่าส่วนหัว Origin ส่งผลต่อเนื้อหาการตอบสนอง จำเป็นต้องมีเมื่อส่งคืน Allow-Origin แบบไดนามิก
ส่วนหัวคำขอที่ CORS อนุญาต (CORS-safelisted request headers)
ส่วนหัวพื้นฐานที่ CORS อนุญาตโดยไม่ต้องประกาศใน Allow-Headers ได้แก่ Accept, Accept-Language, Content-Language, Content-Type (เฉพาะบางประเภท)
ชื่อส่วนหัวที่ห้าม (Forbidden header name)
ส่วนหัวที่เบราว์เซอร์ห้ามไม่ให้ JavaScript ตั้งค่าเองได้ เช่น Host, Connection, Cookie, Origin เป็นต้น ถูกควบคุมโดยเบราว์เซอร์เอง
คำขอส่ง Credentials (Credentialed Request)
คำขอข้ามโดเมนที่ส่งข้อมูลรับรองตัวตน เช่น withCredentials=true หรือ credentials: 'include' จะนำ Cookie และส่วนหัว Authorization ไปด้วย
Access-Control-Expose-Headers
ระบุส่วนหัวการตอบสนองที่อนุญาตให้ JavaScript อ่านได้ นอกเหนือจากส่วนหัวพื้นฐานที่เปิดเผยตามค่าเริ่มต้น
วิธี OPTIONS
วิธี HTTP ที่ใช้สอบถามความสามารถของเซิร์ฟเวอร์ ใน CORS เบราว์เซอร์ใช้วิธีนี้ส่ง preflight request อัตโนมัติ
ส่วนหัว Origin
ส่วนหัวคำขอที่เบราว์เซอร์เพิ่มอัตโนมัติ ระบุ origin ของหน้าเว็บที่ส่งคำขอ เซิร์ฟเวอร์ใช้ค่านี้ตัดสินใจอนุญาตหรือไม่
แอตทริบิวต์ crossorigin
แอตทริบิวต์ HTML ที่ระบุวิธีจัดการคำขอข้ามโดเมนเมื่อโหลดทรัพยากร จำเป็นเมื่อใช้ Canvas จัดการรูปภาพข้ามโดเมน
โหมดคำขอ no-cors
โหมดพิเศษของ fetch API ส่งได้เฉพาะ simple request และ JavaScript ไม่สามารถอ่านการตอบสนองได้ (opaque response)

ตารางเปรียบเทียบส่วนหัวตอบสนอง CORS

ตารางตัดสินใจว่าคำขอใดจะเรียกใช้ Preflight

ตารางสรุปข้อผิดพลาด CORS ที่พบบ่อยและวิธีแก้ไข

Troubleshooting

เครื่องมือสร้าง Authentication Headerเครื่องมือวิเคราะห์ Cache-Controlเครื่องมือวิเคราะห์ Content-Dispositionเครื่องมือสร้าง CORS Headerเครื่องมือตรวจสอบ CORSCSP Builderตัวแปลง cURL เป็นโค้ดตรวจสอบการแพร่กระจาย DNS ทั่วโลกค้นหา DNSForwarded Header Parserเครื่องมือสร้าง Hreflang TagHSTS AnalyzerHTTP Cookie ParserHTTP Headers CheckerHTTP Request Runnerค้นหารหัสสถานะ HTTPค้นหา IPตัวแปลง IPv4เครื่องมือขยายช่วง IPv4เครื่องมือจัดการที่อยู่ IPv6ตัวแยกวิเคราะห์ส่วนหัว Linkค้นหา MX Recordตรวจสอบพอร์ตสร้างพารามิเตอร์ URLตัวแยกวิเคราะห์ส่วนหัว Rate Limitเครื่องมือตรวจสอบห่วงโซ่การเปลี่ยนเส้นทางสร้าง Robots.txtตรวจสอบ Robots.txtตรวจสอบส่วนหัวความปลอดภัยสร้าง Security.txtตัวแยกวิเคราะห์ Set-Cookieตรวจสอบเครือข่ายเว็บไซต์สร้าง Sitemapตรวจสอบ Sitemapตัวตรวจสอบใบรับรอง SSLเครื่องคำนวณซับเน็ตตัวแยกวิเคราะห์ URLตัวแยกวิเคราะห์ User-Agentตัวสร้างลิงก์ UTMทดสอบ WebSocketWhat Is My IP?ค้นหา WHOIS