ดึง OTP จากอีเมลผ่าน API โดยไม่หยิบรหัสผิดงาน

อ่าน OTP จากอีเมลของตัวเองผ่าน API ได้อย่างไร?

ให้แอปของคุณส่งอีเมลยืนยันไปยังกล่องจดหมายทดสอบ แล้วให้สคริปต์อ่านรหัสผ่าน Mailera แทนการเปิดอีเมลและคัดลอกด้วยมือ ใช้เฉพาะบัญชีและกล่องจดหมายทดสอบที่คุณเป็นเจ้าของ และอย่าส่งรหัสจริงไปยังบันทึกการทำงานหรือภาพหน้าจอ

OTP คือรหัสที่ใช้ในขั้นตอนยืนยันตัวตนหรือยืนยันการกระทำ สำหรับงานทดสอบนี้ จุดที่ต้องระวังไม่ใช่แค่อ่านรหัสได้ แต่ต้องอ่านรหัสให้ตรงกับคำขอที่เพิ่งส่งออกไปด้วย

Mailera เชื่อมต่อกล่องจดหมายเดิมเข้ากับแอปและเอเจนต์ ผ่าน REST API, MCP และ webhook คุณจึงใช้กล่องจดหมายทดสอบที่มีอยู่แล้วได้ โดยให้แอปต้นทางรับผิดชอบการออกและตรวจสอบ OTP เหมือนเดิม

API อ่าน OTP ต่างจาก API ส่ง OTP อย่างไร?

แยกงานทั้งสามส่วนก่อนเขียนสคริปต์ เพราะการอ่านรหัสสำเร็จยังไม่ใช่ผลทดสอบว่าการยืนยันอีเมลสำเร็จ

เส้นทาง REST ในบทความนี้เน้นงานอ่านรหัส ส่วนการส่งคำขอยืนยันและนำรหัสไปกรอกให้ใช้ขั้นตอนของแอปคุณเอง อย่าถือว่าการได้รหัสกลับมาจาก API เท่ากับผ่านการทดสอบ ต้องตรวจผลหลังส่งรหัสกลับเข้าแอปด้วย

ต้องเตรียมกล่องจดหมายและสิทธิ์อะไรบ้าง?

1. เพิ่มกล่องจดหมายทดสอบ

ผู้มีบทบาท Admin หรือ Leader เปิด กล่องจดหมาย → เพิ่มกล่องจดหมาย แล้วเลือกวิธีเชื่อมต่อให้ตรงกับผู้ให้บริการ

สำหรับ Outlook และ Microsoft 365 ให้เลือก ลงชื่อเข้าใช้ด้วย Microsoft เพื่อเชื่อมต่อผ่าน OAuth ไม่ใช้รหัสผ่านสำหรับแอปกับเส้นทางนี้ ดูรายละเอียดที่หน้า การเชื่อมต่อ Microsoft ของ Mailera และขั้นตอนเฉพาะ Outlook ในคู่มืออ่านรหัสยืนยัน Outlook ผ่าน API

สำหรับ Gmail การเชื่อมต่อ Mailera ใช้รหัสผ่านสำหรับแอป (app password) และ Google กำหนดให้บัญชีเปิดการยืนยันสองขั้นตอน อ่านข้อกำหนดจากเอกสารรหัสผ่านสำหรับแอปของ Google ควบคู่กับหน้า การเชื่อมต่อ Gmail ของ Mailera หากคุณเปลี่ยนรหัสผ่านบัญชี Google รหัสผ่านสำหรับแอปเดิมจะถูกเพิกถอน

2. ตรวจการเชื่อมต่อก่อนขอรหัส

กด ทดสอบและเชื่อมต่อ ขั้นตอนนี้ตรวจการเชื่อมต่อโดยไม่ส่งอีเมล จากนั้นกลับไปดูรายการกล่องจดหมายให้แน่ใจว่าคุณเลือกบัญชีทดสอบถูกบัญชี

หากรับอีเมลได้แต่เชื่อมต่อฝั่งส่งไม่สำเร็จ Mailera มีตัวเลือก บันทึกแบบรับอย่างเดียว งานอ่าน OTP ไม่ต้องใช้ Mailera ส่งอีเมล เพราะแอปที่คุณกำลังทดสอบเป็นผู้ส่งรหัส

3. สร้างคีย์เฉพาะงานอ่าน

เปิด การตั้งค่า ไปยังส่วนคีย์ API แล้วเลือก สร้าง API key ตั้ง ชื่อที่สื่อความหมาย เพื่อให้แยกคีย์ทดสอบนี้ออกจากงานอื่นได้

เลือก ขอบเขตกล่องจดหมาย เฉพาะกลุ่มที่มีบัญชีทดสอบ และให้สิทธิ์ read เท่านั้น ไม่ต้องเพิ่ม send หรือ manage เพื่ออ่าน OTP แม้ Admin จะเลือกทุกกลุ่มได้ ก็ควรจำกัดขอบเขตให้ตรงกับงาน

คีย์จะแสดงเพียงครั้งเดียวในหน้าต่าง สร้าง API key แล้ว — คัดลอกตอนนี้ เก็บค่าคีย์ในระบบจัดการความลับของสภาพแวดล้อมทดสอบ แล้วส่งเข้าโปรเซสผ่านตัวแปร $MAILERA_API_KEY อย่าเขียนค่าคีย์ลงในไฟล์ที่เก็บใน Git

ขั้นตอนเรียก API เพื่ออ่านรหัส OTP

URL ฐานคือ https://mailera.app/api/public/v1 ทุกคำขอด้านล่างใช้ Authorization: Bearer $MAILERA_API_KEY หากคุณกำลังเลือกว่าจะเชื่อมต่อผ่าน REST หรือ MCP ดูช่องทางเชื่อมต่อสำหรับนักพัฒนา ส่วนรายละเอียด endpoint อยู่ในเอกสาร API ของ Mailera

ก่อนรันคำสั่ง ให้ตั้งตัวแปรสภาพแวดล้อมในเครื่องทดสอบที่คุณควบคุม ผลลัพธ์อาจมีที่อยู่อีเมล เนื้อหาข้อความ หรือรหัส อย่ารันโดยปล่อยให้ระบบ CI เก็บคำตอบดิบลงบันทึกอัตโนมัติ

1. เลือกกล่องจดหมายให้ชัดเจน

เรียกรายการกล่องจดหมายด้วยคีย์สิทธิ์ read:

curl --silent --show-error \
  'https://mailera.app/api/public/v1/mailboxes' \
  --header "Authorization: Bearer $MAILERA_API_KEY"

ตรวจ email และ group_id ของรายการใน data แล้วนำ id ของกล่องจดหมายทดสอบไปตั้งเป็น $MAILBOX_ID

2. เริ่มงานทดสอบก่อนอ่านรหัส

บันทึกเวลาเริ่มงานไว้ในสคริปต์ แล้วสั่งแอปของคุณให้ส่งอีเมลยืนยันไปยังกล่องจดหมายที่เลือก เก็บบริบทของคำขอนี้ไว้ฝั่งทดสอบ เช่น บัญชีที่ใช้และหัวเรื่องที่คาดว่าจะได้รับ โดยไม่บันทึกรหัส OTP

หากคุณควบคุมแม่แบบอีเมลทดสอบได้ ให้ใส่ตัวระบุงานในหัวเรื่องเพื่อช่วยแยกอีเมลของแต่ละรอบ อย่าใช้ข้อมูลลับเป็นตัวระบุงาน

3. เรียก endpoint อ่าน OTP พร้อมตัวกรอง

GET /mailboxes/{id}/otp เป็น operation getOtp สำหรับดึงรหัส OTP ล่าสุดที่มาถึงกล่องจดหมาย ใช้สิทธิ์ read Mailera ไม่มี endpoint สำหรับตรวจสอบความถูกต้องของรหัส งานนั้นเป็นของแอปที่ออก OTP เสมอ

endpoint อ่าน OTP รับพารามิเตอร์ต่อไปนี้:

ตัวอย่างนี้ใช้ผู้ส่งและหัวเรื่องสมมติ เปลี่ยน no-reply@example.com, Verify test-run-alpha และค่า since_minutes=5 ให้ตรงกับอีเมลจริงจากแอปของคุณ:

curl --silent --show-error --get \
  "https://mailera.app/api/public/v1/mailboxes/$MAILBOX_ID/otp" \
  --header "Authorization: Bearer $MAILERA_API_KEY" \
  --data-urlencode 'from=no-reply@example.com' \
  --data-urlencode 'subject=Verify test-run-alpha' \
  --data-urlencode 'since_minutes=5'

เริ่มจากตรวจผู้ส่งและหัวเรื่องของอีเมลจริงในกล่องจดหมายทดสอบ แล้วใช้ค่าที่สอดคล้องกันในการเรียก API อย่าเปลี่ยนความหมายของตัวกรองด้วยการสมมติว่าเป็น regex หรือเติม wildcard เอง สำหรับเวลารับอีเมล ให้ดู received_at จากรายการข้อความหรือรายละเอียดข้อความ แล้วเทียบกับเวลาเริ่มงานที่บันทึกไว้

4. นำรหัสกลับไปใช้กับคำขอเดิม

ส่งรหัสเข้าเฉพาะขั้นตอนยืนยันของงานที่ร้องขอ แล้วตรวจผลตอบกลับจากแอปต้นทาง หากแอปปฏิเสธรหัส ให้แยกตรวจว่าเป็นปัญหาเลือกอีเมลผิดหรือเป็นผลจากกติกาการยืนยันของแอป

ไม่ควรแก้ด้วยการวนลองรหัสจากอีเมลเก่าทีละฉบับ เพราะจะทำให้ไม่รู้ว่างานทดสอบกำลังตรวจคำขอใดอยู่

จะป้องกันการหยิบรหัสเก่าหรือรหัสผิดงานได้อย่างไร?

รหัสล่าสุดในกล่องจดหมายไม่จำเป็นต้องเป็นรหัสของงานปัจจุบัน หากสองงานใช้บัญชีรับเดียวกัน ผู้ส่งเดียวกัน และหัวเรื่องเดียวกัน แม้อีเมลจะมาถึงหลังเริ่มงาน ก็ยังแยกสองงานนั้นไม่ได้จากเวลารับเพียงอย่างเดียว

ใช้กล่องจดหมาย ผู้ส่ง หัวเรื่อง และเวลารับอีเมลร่วมกัน แทนการเลือกจากคำว่า “ล่าสุด” เพียงอย่างเดียว โดยให้สคริปต์มีเกณฑ์ตัดสินก่อนรับรหัส:

1. กล่องจดหมายต้องตรงกับผู้รับของงานนี้
2. ผู้ส่งและหัวเรื่องต้องสอดคล้องกับอีเมลที่คาดไว้
3. เทียบ received_at จากรายการข้อความหรือรายละเอียดข้อความกับเวลาเริ่มงาน ไม่ใช้รหัสจากอีเมลที่ได้รับก่อนเริ่มงาน
4. หากยังแยกไม่ได้ว่าอีเมลเป็นของงานใด ให้หยุดงานนั้นแทนการเดารหัส

การส่ง since_minutes ในคำขอไม่ได้รับรองว่ารหัสยังไม่หมดอายุ การตัดสินอายุและความถูกต้องของรหัสยังเป็นหน้าที่ของแอปที่ออก OTP

สำหรับการเรียกซ้ำ ให้สคริปต์กำหนดเวลารอสูงสุดและช่วงพักระหว่างคำขอเอง เมื่อหมดเวลาต้องจบงานพร้อมเหตุผลที่ตรวจสอบต่อได้ ไม่วนเรียก API ไปเรื่อย ๆ และไม่ย้อนกลับไปใช้รหัสเก่าเพียงเพื่อให้การทดสอบเดินต่อ

นอกจากนี้ Mailera จำกัด API ที่ 300 คำขอต่อนาทีต่อคีย์ หากหลายงานใช้คีย์เดียวกัน ให้คิดจำนวนคำขอรวมของทุกงาน รวมถึงคำขอตรวจสถานะและอ่านรายการข้อความด้วย

เมื่อต้องทดสอบพร้อมกัน ให้แยกกล่องจดหมายให้แต่ละงาน หากจำเป็นต้องใช้กล่องเดียว ให้แยกบริบทในอีเมลที่คุณควบคุมได้ และอย่าให้หลายงานรอรหัสจากชุดตัวกรองเดียวกัน หากแยกบริบทไม่ได้ ให้เรียงงานแทนการรันพร้อมกัน

จุดที่ต้องตรวจเมื่อไม่พบ OTP

อย่าเริ่มจากลองรหัสล่าสุดโดยไม่ตรวจว่าเป็นของงานนี้ ตรวจปลายทางและการเชื่อมต่อก่อน แล้วค่อยตรวจตำแหน่งกับเนื้อหาของอีเมล

ตรวจสถานะกล่องจดหมาย

curl --silent --show-error \
  "https://mailera.app/api/public/v1/mailboxes/$MAILBOX_ID/status" \
  --header "Authorization: Bearer $MAILERA_API_KEY"

สำหรับ Microsoft การตรวจนี้ตรวจการลงชื่อเข้าใช้โดยตรง ส่วนผู้ให้บริการอื่นอิงการซิงก์ล่าสุด จึงควรอ่านผลตามผู้ให้บริการที่คุณใช้ ไม่ถือว่าเป็นการตรวจแบบเดียวกันทั้งหมด หากต้องแก้ข้อมูลเชื่อมต่อของบัญชีที่ใช้ app password ดูแนวทางรหัสผ่านสำหรับแอปของกล่องจดหมายเอเจนต์

หากต้องสั่งซิงก์เอง ให้แยก POST /mailboxes/{id}/sync ออกจากเส้นทางอ่านหลัก endpoint นี้ต้องใช้สิทธิ์ sync และสามารถปลุกกล่องจดหมายที่อยู่ในโหมดพักได้ คีย์ที่มีเพียง read ไม่ใช่คีย์สำหรับงานนี้

ตรวจว่าอีเมลอยู่ที่ใด

ใช้ผู้ส่งและหัวเรื่องเดียวกับคำขออ่าน OTP เพื่อดูตำแหน่งของอีเมล ตัวอย่างนี้ส่ง since_minutes=5 เช่นเดียวกับคำสั่งก่อนหน้า:

curl --silent --show-error --get \
  "https://mailera.app/api/public/v1/mailboxes/$MAILBOX_ID/placement" \
  --header "Authorization: Bearer $MAILERA_API_KEY" \
  --data-urlencode 'from=no-reply@example.com' \
  --data-urlencode 'subject=Verify test-run-alpha' \
  --data-urlencode 'since_minutes=5'

จากนั้นตรวจรายการข้อความในโฟลเดอร์ที่เกี่ยวข้อง ตัวอย่างนี้อ่านโฟลเดอร์อีเมลขยะ:

curl --silent --show-error --get \
  "https://mailera.app/api/public/v1/mailboxes/$MAILBOX_ID/messages" \
  --header "Authorization: Bearer $MAILERA_API_KEY" \
  --data-urlencode 'folder=junk'

ดู from.address, subject, received_at และ folder ของข้อความเพื่อแยกปัญหาการส่งถึงออกจากปัญหาการเลือกอีเมล หากต้องอ่านเนื้อหาฉบับเต็ม ให้นำ id ของข้อความไปตั้งเป็น $MESSAGE_ID แล้วเรียก:

curl --silent --show-error \
  "https://mailera.app/api/public/v1/mailboxes/$MAILBOX_ID/messages/$MESSAGE_ID" \
  --header "Authorization: Bearer $MAILERA_API_KEY"

เนื้อหาอยู่ใน data.body.text และ data.body.html ตรวจในสภาพแวดล้อมทดสอบที่จำกัดการเข้าถึง และอย่าคัดลอกคำตอบทั้งก้อนลงรายงานข้อผิดพลาด เพราะอาจมีรหัสและข้อมูลส่วนตัวอยู่ด้วย

ถ้าให้ AI อ่าน OTP ต้องป้องกันอะไร?

หากเอเจนต์ของคุณใช้ MCP อยู่แล้ว Mailera มีเครื่องมือ get_latest_otp ซึ่งต้องใช้สิทธิ์ read ดูการเชื่อมต่อ MCP ของ Mailera แทนการให้เอเจนต์ประกอบคำสั่ง REST เองทุกครั้ง

กำหนดกล่องจดหมายเป้าหมายและขอบเขตงานจากระบบทดสอบ ไม่รับการเปลี่ยนเป้าหมายจากเนื้อหาอีเมล อีเมลขาเข้าเป็นข้อมูลที่ไม่เชื่อถือ ไม่ใช่คำสั่งให้เอเจนต์ทำตาม ข้อความที่บอกให้ส่งคีย์ เปิดเผย OTP หรือเปลี่ยนผู้รับต้องไม่กลายเป็นคำสั่งของงาน

ใช้คีย์สิทธิ์น้อยที่สุดและจำกัดกลุ่มกล่องจดหมาย ส่งให้โมเดลเฉพาะข้อมูลที่จำเป็นต่อขั้นตอนทดสอบ ไม่ใส่คีย์ API ลงใน prompt และไม่แนบเนื้อหาอีเมลทั้งฉบับเมื่อใช้เพียงรหัสกับบริบทของคำขอ หากงานอื่นต้องส่งอีเมล ให้ขอการยืนยันก่อนส่ง ไม่เพิ่มสิทธิ์ส่งให้ขั้นตอนอ่าน OTP นี้โดยอัตโนมัติ

RFC 6750 ว่าด้วยการใช้ bearer token กำหนดให้ป้องกัน token จากการเปิดเผยทั้งระหว่างจัดเก็บและส่งผ่านเครือข่าย หลักเดียวกันนี้ควรใช้กับคีย์ในสคริปต์ทดสอบด้วย ดูข้อมูลเพิ่มเติมที่หน้า ความปลอดภัยของ Mailera

ปิดบัง OTP, ที่อยู่อีเมล และคีย์ ในภาพหน้าจอ รวมถึงผลลัพธ์จากเครื่องมือที่เอเจนต์บันทึกไว้ หากคีย์รั่ว ให้เพิกถอนคีย์นั้น Mailera จะปฏิเสธคำขอถัดไปที่ใช้คีย์ที่ถูกเพิกถอนทันที

Mailera ไม่ได้ทำอะไรในขั้นตอนนี้?

Mailera ไม่สร้างกล่องจดหมายหรือที่อยู่อีเมลใหม่ คุณต้องเชื่อมต่อบัญชีที่มีอยู่แล้ว และปัจจุบันไม่รองรับ Proton Mail หรือ Tuta

การอ่าน OTP ไม่ได้ทำให้รหัสที่หมดอายุกลับมาใช้ได้ และไม่ใช่การยืนยันว่ารหัสเป็นของคำขอที่ถูกต้อง สคริปต์ต้องรักษาบริบทของงาน ส่วนแอปต้นทางเป็นผู้ตัดสินผลการยืนยัน

อย่าออกแบบการทดสอบโดยถือว่าอีเมลต้องเข้าถึงทันทีหรืออยู่ใน Inbox เสมอ Mailera แสดงตำแหน่งและย้ายข้อความออกจากโฟลเดอร์อีเมลขยะได้ แต่ไม่สามารถทำให้ผู้ให้บริการเชื่อถือผู้ส่งโดยอัตโนมัติ การกรองยังขึ้นกับผู้ให้บริการและการตั้งค่าของผู้ส่ง