เครื่องมือแปลง Query String

แยกวิเคราะห์ Query String ของ URL และข้อมูล form-urlencoded เป็นตาราง key-value และ JSON ที่แก้ไขได้ทันทีบนเบราว์เซอร์ รองรับอาร์เรย์ วงเล็บเหลี่ยม.

ไม่ต้องอัปโหลดไม่ต้องลงทะเบียนผลลัพธ์ทันที
ตัวแก้ไขสลับเปิด-ปิดคู่คีย์-ค่าแบบโต้ตอบอาเรย์และวงเล็บซ้อน → JSONx-www-form-urlencoded (+) เทียบกับ %20 แบบเคร่งครัด
แยกวิเคราะห์ Query String
ระบบออฟไลน์พร้อมใช้งานพื้นที่ทำงานบนเบราว์เซอร์ส่วนตัว 100% • ไม่มีการอัปโหลดลงคลาวด์
ส่วนตัว 100% • ไม่อัปโหลดไฟล์ขึ้นเซิร์ฟเวอร์

ทำไมต้องใช้ เครื่องมือแปลง Query String ฟรีของ Utiliome?

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

แปลงข้อมูลไปมาระหว่าง Query String และ JSON

แยกวิเคราะห์สตริง ?key=value หรือข้อมูล application/x-www-form-urlencoded ให้เป็นออบเจ็กต์ JSON ที่อ่านง่าย และแปลง JSON ที่แก้ไขแล้วกลับเป็นพารามิเตอร์คิวรีที่ได้มาตรฐานได้ทันที

รองรับคีย์อาร์เรย์ซ้ำและไวยากรณ์วงเล็บเหลี่ยมซ้อนกัน

จัดการคีย์ที่ซ้ำกัน (?tag=go&tag=rust), วงเล็บอาร์เรย์แบบระบุชัดเจน (ids[]=1&ids[]=2) และโครงสร้างออบเจ็กต์หลายระดับ (filter[status]=open&page[limit]=50) ได้อย่างถูกต้อง

เลือกตั้งค่าการแปลงช่องว่างระหว่าง + และ %20 ได้

ถอดรหัสช่องว่างทั้งแบบ + และ %20 ขาเข้าตามกฎ URLSearchParams พร้อมให้คุณเลือกส่งออกช่องว่างตามมาตรฐาน RFC 3986 (%20) หรือแบบฟอร์ม HTML (+) เมื่อสร้างสตริงใหม่

ตารางแก้ไขพารามิเตอร์แบบโต้ตอบโดยไม่อัปโหลดข้อมูล

เพิ่ม เปิด/ปิด แก้ไข หรือลบพารามิเตอร์ได้โดยตรงในหน่วยความจำของเบราว์เซอร์ โดยไม่ส่ง API key, โทเค็น OAuth state หรือเพย์โหลด webhook ไปยังเซิร์ฟเวอร์ภายนอก

Utiliome เปรียบเทียบกับทางเลือกคลาวด์แบบเดิม

เปรียบเทียบขีดความสามารถของเอนจิน WebAssembly ภายในเครื่อง กับเครื่องมือคลาวด์แบบเก่า

ฟีเจอร์ Utiliome (ประมวลผลในเบราว์เซอร์) เครื่องมือแปลงไฟล์บนคลาวด์แบบเดิม
แปลงข้อมูลไปมาระหว่าง Query String และ JSON แยกวิเคราะห์สตริง ?key=value หรือข้อมูล application/x-www-form-urlencoded ให้เป็นออบเจ็กต์ JSON ที่อ่านง่าย และแปลง JSON ที่แก้ไขแล้วกลับเป็นพารามิเตอร์คิวรีที่ได้มาตรฐานได้ทันที ตัวเลือกจำกัดและไม่มีการปรับแต่งขั้นสูง
รองรับคีย์อาร์เรย์ซ้ำและไวยากรณ์วงเล็บเหลี่ยมซ้อนกัน จัดการคีย์ที่ซ้ำกัน (?tag=go&tag=rust), วงเล็บอาร์เรย์แบบระบุชัดเจน (ids[]=1&ids[]=2) และโครงสร้างออบเจ็กต์หลายระดับ (filter[status]=open&page[limit]=50) ได้อย่างถูกต้อง ต้องใช้โปรแกรมเสริมหรือแก้ไขด้วยตนเอง
ความเป็นส่วนตัวและการประมวลผล ประมวลผลในเบราว์เซอร์ 100% (ไม่อัปโหลดขึ้นเซิร์ฟเวอร์) อัปโหลดข้อมูลไปยังเซิร์ฟเวอร์คลาวด์ภายนอก
ราคาและการสมัครสมาชิก ฟรี 100% ตลอดชีพโดยไม่ต้องสมัครสมาชิก บังคับสมัครสมาชิกหรือต้องจ่ายค่าบริการรายเดือน
วิธีใช้งาน

วิธีใช้งาน เครื่องมือแปลง Query String ใน 3 ขั้นตอนง่ายๆ

ไม่ต้องติดตั้งโปรแกรม ทุกอย่างทำงานได้โดยตรงผ่านเว็บเบราว์เซอร์ของคุณ

1

วาง Query String, URL เต็มรูปแบบ หรือ JSON

ป้อนสตริงคิวรีดิบเช่น ?a=1&b=2, URL เต็มรูปแบบ (ระบบจะดึงเฉพาะส่วนคิวรีออกมาโดยอัตโนมัติ), ข้อมูล application/x-www-form-urlencoded หรือ JSON ที่ถูกต้อง

2

แก้ไขคีย์ อาร์เรย์ และตัวเลือกการเข้ารหัส

ปรับแก้ชื่อและค่าที่ถอดรหัสแล้วในตาราง key-value แบบโต้ตอบหรือในตัวแก้ไข JSON เปิดหรือปิดใช้งานแต่ละแถว และเลือกรูปแบบการจัดการอาร์เรย์รวมถึงการเข้ารหัสช่องว่าง

3

คัดลอก Query String ที่สร้างใหม่หรือ JSON

คัดลอก Query String ที่ผ่านการ escape อย่างถูกต้องเพื่อนำไปใช้กับคำสั่ง cURL และไคลเอนต์ API หรือส่งออกเอกสาร JSON ที่มีโครงสร้างไปยังชุดทดสอบและไฟล์จำลองคำขอได้ทันที

การแปลง Query String ที่ซับซ้อนและเพย์โหลดของฟอร์มให้เป็น JSON

คำตอบโดยย่อ: เครื่องมือแยกวิเคราะห์ Query String จะแบ่งไบต์ข้อมูลขาเข้าด้วยตัวคั่น & ก่อนการถอดรหัส จากนั้นแยกแต่ละส่วนด้วยเครื่องหมาย = ตัวแรก ถอดรหัสลำดับ UTF-8 ทั้งแบบ + และ %XX แล้วรวบรวมคีย์ที่ซ้ำกันหรือคีย์ที่มีวงเล็บเหลี่ยม (tag=a&tag=b, filter[status]=open) ให้กลายเป็นอาร์เรย์และออบเจ็กต์ซ้อนกันในรูปแบบ JSON

เอ็นด์พอยต์ REST สมัยใหม่, GraphQL-over-GET และ webhook มักจะรวมอาร์เรย์ที่มีหลายค่า ออบเจ็กต์ตัวกรองที่ซ้อนกัน เคอร์เซอร์แบ่งหน้าแบบ Base64 และวลีค้นหาที่เข้ารหัส URL ไว้ใน Query String เดียว หรือในบอดี้ของคำขอแบบ application/x-www-form-urlencoded การตรวจสอบหรือแก้ไขเพย์โหลดเหล่านั้นในรูปแบบสตริงดิบยาวๆ มักนำไปสู่ปัญหาอักขระหลีก %26 เสียหายหรือวงเล็บเหลี่ยมไม่ครบคู่

ลองพิจารณาคิวรีสำหรับการค้นหาผ่าน API ที่ผสมผสานทั้งช่องว่างที่เข้ารหัสด้วย +, คีย์ที่ซ้ำกัน, ตัวกรองวงเล็บเหลี่ยมซ้อนกัน, เคอร์เซอร์แบ่งหน้า Base64 ที่มีเครื่องหมาย = ซึ่งเข้ารหัสเปอร์เซ็นต์ไว้ และพารามิเตอร์แฟล็กแบบไม่มีค่า:

?q=distributed+tracing&tag=otel&tag=grpc&filter[status]=open&filter[priority]=high&cursor=eyJpZCI6NDIwfQ%3D%3D&dry_run

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

{
  "q": "distributed tracing",
  "tag": [
    "otel",
    "grpc"
  ],
  "filter": {
    "status": "open",
    "priority": "high"
  },
  "cursor": "eyJpZCI6NDIwfQ==",
  "dry_run": ""
}

เหตุใดการแยกตัวคั่นจึงต้องทำก่อนการถอดรหัสเปอร์เซ็นต์

สังเกตว่า cursor=eyJpZCI6NDIwfQ%3D%3D ถูกถอดรหัสออกมาเป็น "eyJpZCI6NDIwfQ==" ได้อย่างถูกต้อง เครื่องมือจะแบ่งสตริงดิบด้วย & เป็นอันดับแรก แยกแต่ละคู่ด้วยเครื่องหมาย = ตัวแรกสุด แล้วจึงค่อยถอดรหัสลำดับ + และ %XX หากสคริปต์ทั่วไปเรียกใช้ decodeURIComponent() กับ Query String ทั้งหมดก่อนที่จะแยกด้วย & และ = ค่าพารามิเตอร์ใดๆ ที่มีเครื่องหมายแอมเพอร์แซนด์ที่เข้ารหัสไว้ (R%26D -> R&D) จะถูกตัดแบ่งออกเป็นสองพารามิเตอร์ที่ผิดพลาดทันที

เนื่องจากมุมมอง JSON และตาราง key-value ซิงโครไนซ์กันแบบสองทิศทาง คุณจึงสามารถวางออบเจ็กต์ตัวกรอง JSON จากโค้ดแอปพลิเคชันของคุณ แล้วแปลงออกมาเป็น Query String ที่ escape อย่างถูกต้องเพื่อนำไปใช้ส่งคำขอ HTTP ได้ทันที

เปรียบเทียบ WHATWG URLSearchParams กับ RFC 3986 และรูปแบบอาร์เรย์ของฝั่งแบ็กเอนด์

คำตอบโดยย่อ: มาตรฐาน RFC 3986 มองส่วนคิวรีเป็นสตริงที่ไม่มีโครงสร้างตายตัว โดยช่องว่างจะถูกเข้ารหัสเป็น %20 และเครื่องหมาย + จะคงความหมายตามตัวอักษรเดิม ในขณะที่มาตรฐาน application/x-www-form-urlencoded ของ WHATWG (URLSearchParams) จะเข้ารหัสช่องว่างเป็น + และปล่อยให้ไวยากรณ์ของอาร์เรย์และออบเจ็กต์ซ้อนกันเป็นไปตามข้อกำหนดของแต่ละเฟรมเวิร์ก

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

อัลกอริทึม `application/x-www-form-urlencoded` เปรียบเทียบกับ RFC 3986

ฟอร์ม HTML และ API URLSearchParams ของ JavaScript ทำงานตามขั้นตอนการแยกวิเคราะห์ application/x-www-form-urlencoded ของ WHATWG ดังนี้:

  1. ตัดเครื่องหมาย ? ด้านหน้าออก หากดึงค่ามาจาก location.search
  2. แบ่งข้อมูลขาเข้าที่ไบต์ 0x26 (&) โดยข้ามลำดับไบต์ว่างที่เกิดจาก && หรือ & ที่อยู่ด้านหน้าสุด
  3. สำหรับแต่ละส่วนย่อย ให้แยกที่ไบต์ 0x3D (=) ตัวแรก หากไม่มีเครื่องหมาย = เลย ส่วนย่อยทั้งหมดจะกลายเป็นชื่อคีย์ และค่าเริ่มต้นจะเป็น ""
  4. แทนที่ไบต์ 0x2B (+) ทุกตัวทั้งในชื่อคีย์และค่า ด้วย 0x20 (ช่องว่าง ASCII)
  5. ถอดรหัสเปอร์เซ็นต์ของลำดับไบต์ฐานสิบหก %XX ในรูปแบบ UTF-8 โดยแทนที่ลำดับไบต์ที่ไม่ถูกต้องด้วย U+FFFD

ในทางตรงกันข้าม RFC 3986 ส่วนที่ 3.4 กำหนดส่วนคิวรีของ URI โดยไม่ได้ระบุให้เครื่องหมาย + แทนช่องว่างเป็นกรณีพิเศษ โปรโตคอลการลงนามด้วยการเข้ารหัสที่เข้มงวด—โดยเฉพาะอย่างยิ่ง AWS Signature Version 4 และคำขอมาตรฐานของ OAuth 2.0 / RFC 5849—กำหนดให้ช่องว่างต้องเข้ารหัสเป็น %20 และเครื่องหมาย + ต้องเข้ารหัสเป็น %2B ดังนั้นเมื่อต้องส่งข้อมูลไปยัง API ที่มีการตรวจสอบลายเซ็น ให้สร้าง Query String ใหม่โดยใช้โหมดแปลงช่องว่างเป็น %20 แทนที่จะใช้ +

การแปลงอาร์เรย์และออบเจ็กต์ในเฟรมเวิร์กต่างๆ

ทั้ง RFC 3986 และ URLSearchParams ไม่ได้กำหนดมาตรฐานกลางสำหรับอาร์เรย์หรือออบเจ็กต์ซ้อนกัน ระบบนิเวศฝั่งแบ็กเอนด์จึงได้พัฒนาแนวทางหลักขึ้นมา 4 รูปแบบ:

# 1. คีย์ซ้ำกัน (WHATWG URLSearchParams.getAll, Go net/url, Python parse_qs, Java Servlet)
?tag=otel&tag=grpc

# 2. วงเล็บเหลี่ยมไม่ระบุลำดับ (PHP $_GET, Ruby on Rails / Rack, Express qs)
?tag[]=otel&tag[]=grpc

# 3. วงเล็บเหลี่ยมระบุลำดับดัชนี (อาร์เรย์เรียงลำดับใน Node.js qs)
?tag[0]=otel&tag[1]=grpc

# 4. คีย์ออบเจ็กต์ซ้อนกัน (Node.js qs, Rails, PHP, Stripe REST API)
?filter[status]=open&filter[created][gte]=1730000000

ควรตรวจสอบให้แน่ใจว่าเซิร์ฟเวอร์ปลายทางของคุณรองรับรูปแบบใดก่อนทำการแปลงข้อมูล เช่น การส่ง tag=otel&tag=grpc ไปยัง $_GET['tag'] มาตรฐานของ PHP จะทำให้ค่าแรกถูกเขียนทับและคืนค่าเป็นสตริงเดี่ยว "grpc" เว้นแต่จะใช้วงเล็บเหลี่ยม tag[] ในขณะที่ r.URL.Query()["tag"] ของภาษา Go คาดหวังคีย์ tag แบบไม่มีวงเล็บเหลี่ยม

ประเด็นด้านความปลอดภัย: HTTP Parameter Pollution และ Prototype Pollution

  • HTTP Parameter Pollution (HPP): เมื่อมีการส่งคีย์เดี่ยวที่ซ้ำกันเข้ามา (?account=user_1&account=user_2) รันไทม์ของเซิร์ฟเวอร์แต่ละตัวจะจัดการกับการชนกันของข้อมูลแตกต่างกัน โดย Python urllib.parse.parse_qs และ Go Values.Get() จะอ่านค่า แรกสุด ส่วน PHP และ Ruby Rack จะอ่านค่า สุดท้าย ขณะที่ Node/Express จะสร้างเป็น อาร์เรย์ (["user_1", "user_2"]) หาก API Gateway ตรวจสอบสิทธิ์จากค่าแรกที่พบ แต่ไมโครเซอร์วิสปลายทางกลับนำค่าสุดท้ายไปประมวลผล การตรวจสอบสิทธิ์ก็อาจถูกหลีกเลี่ยงได้
  • Prototype Pollution ในตัวแยกวิเคราะห์วงเล็บเหลี่ยม: ตัวแยกวิเคราะห์วงเล็บเหลี่ยมใน JavaScript ที่เขียนแบบไม่รัดกุมโดยกำหนดค่า obj[key1][key2] = val ลงบน Object.prototype โดยตรง จะมีช่องโหว่ต่อเพย์โหลดอย่าง ?__proto__[isAdmin]=true หรือ ?constructor[prototype][isAdmin]=true ตัวแยกวิเคราะห์ที่ปลอดภัยจะสร้างดิกชันนารีด้วย Object.create(null) บล็อกคีย์สงวนของ prototype และจำกัดระดับความลึกของการซ้อนออบเจ็กต์

เครื่องมือแปลง Query String, เครื่องมือแยกส่วนประกอบ URL และเครื่องมือเข้ารหัส URL: ควรเลือกใช้ตัวไหน?

คำตอบโดยย่อ: ใช้เครื่องมือแปลง Query String สำหรับการแก้ไขพารามิเตอร์แบบโต้ตอบ การแยกวิเคราะห์อาร์เรย์หรือวงเล็บเหลี่ยม และการแปลง JSON แบบสองทิศทาง ใช้เครื่องมือแยกส่วนประกอบ URL เมื่อคุณต้องการแยกหรือแก้ไข scheme, host, port, path segments และ hash หรือใช้เครื่องมือเข้ารหัสและถอดรหัส URL เพื่อ escape สตริงดิบแต่ละรายการ

เครื่องมือแต่ละตัวในกลุ่มจัดการ URL ของ Utiliome ถูกออกแบบมาให้รับผิดชอบหน้าที่เฉพาะทาง เพื่อให้คุณมีปุ่มควบคุมที่ตรงจุดโดยไม่ซับซ้อนเกินความจำเป็น:

ฟีเจอร์ เครื่องมือแปลง Query String (เครื่องมือนี้) เครื่องมือแยกส่วนประกอบ URL เครื่องมือเข้ารหัสและถอดรหัส URL เครื่องมือเข้ารหัสเปอร์เซ็นต์
จุดประสงค์หลัก พารามิเตอร์คิวรี, ข้อมูลฟอร์ม & การซิงค์ JSON โครงสร้าง URI ทั้งหมด (RFC 3986 / WHATWG) การ Escape และถอดรหัสสตริงดิบ การเข้ารหัสไบต์ %XX ตามมาตรฐาน RFC 3986 อย่างเคร่งครัด
การแปลง JSON สองทิศทาง รองรับเต็มรูปแบบ (ออบเจ็กต์ซ้อนกัน & อาร์เรย์) ส่งออก JSON ของฟิลด์ URI แบบอ่านอย่างเดียว ไม่รองรับ ไม่รองรับ
ไวยากรณ์อาร์เรย์ & วงเล็บเหลี่ยม (a[]=1, f[k]=v) แยกวิเคราะห์อัตโนมัติ & ตั้งค่ารูปแบบตอนสร้างใหม่ได้ แสดงคู่คิวรีแบบแบนราบ ไม่รองรับ ไม่รองรับ
สลับโหมดแปลงช่องว่าง + กับ %20 ตั้งค่ารูปแบบขาออกได้ ปรับมาตรฐานส่วนประกอบ URI ตามปกติ โหมดส่วนประกอบ (%20) & โหมดฟอร์ม (+) เฉพาะ %20 อย่างเคร่งครัดเท่านั้น
การแก้ไข Scheme, Host, Port, TLD & Path ตัดส่วนของ URL ที่ไม่ใช่คิวรีออกอัตโนมัติ แก้ไขและประกอบส่วนประกอบทั้งหมดได้ครบถ้วน ไม่มีการแยกโครงสร้าง ไม่มีการแยกโครงสร้าง

การเลือกเครื่องมือให้เหมาะกับงาน

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

คำถามที่พบบ่อยและคู่มือทางเทคนิค เครื่องมือแปลง Query String

รวมทุกสิ่งที่คุณควรรู้เกี่ยวกับการใช้งาน แปลง query string ออนไลน์ฟรีของ Utiliome

ทำไมเครื่องหมายบวก (+) ในพารามิเตอร์ URL จึงถูกถอดรหัสกลายเป็นช่องว่าง?

ตามมาตรฐาน application/x-www-form-urlencoded และ URLSearchParams ของเบราว์เซอร์ ไบต์ 0x2B (+) จะถูกใช้แทนช่องว่างที่เข้ารหัสไว้ (0x20) หากค่าพารามิเตอร์ของคุณมีเครื่องหมายบวกอยู่จริงๆ—เช่น ค่าชดเชยเวลาตามมาตรฐาน ISO 8601 (2026-11-01T09:30:00+01:00), โทเค็น Base64 หรือหมายเลขโทรศัพท์ตามรูปแบบ E.164 (+14155550100)—จะต้องถูกส่งเป็น %2B แทน คุณสามารถนำสตริงดิบไปแปลงล่วงหน้าได้ที่ เครื่องมือเข้ารหัสและถอดรหัส URL

คีย์ที่ซ้ำกันอย่าง ?tag=api&tag=cli จะถูกแสดงอย่างไรเมื่อแปลงเป็น JSON?

เนื่องจากออบเจ็กต์ JSON ตามมาตรฐาน RFC 8259 กำหนดให้คีย์ในแต่ละระดับต้องไม่ซ้ำกัน ชื่อพารามิเตอร์ที่ซ้ำกันจึงถูกจัดกลุ่มตามลำดับที่ปรากฏให้อยู่ในอาร์เรย์ JSON ดังนี้: { "tag": ["api", "cli"] } และเมื่อแปลงอาร์เรย์ JSON นั้นกลับเป็น Query String คุณสามารถเลือกได้ว่าจะสร้างเป็นคีย์ซ้ำ (tag=api&tag=cli), วงเล็บเหลี่ยมว่าง (tag[]=api&tag[]=cli) หรือวงเล็บเหลี่ยมระบุลำดับ (tag[0]=api&tag[1]=cli)

ฉันสามารถวาง URL เต็มรูปแบบ หรือข้อมูล POST แบบ application/x-www-form-urlencoded โดยตรงได้หรือไม่?

ได้แน่นอน เมื่อคุณวาง URL เต็มรูปแบบ เช่น https://api.example.com/v2/events?limit=25&cursor=abc#section เครื่องมือจะแยกเฉพาะส่วนสตริงคิวรีที่อยู่ระหว่าง ? และ # (limit=25&cursor=abc) ออกมาโดยอัตโนมัติ ส่วนข้อมูลบอดี้แบบ application/x-www-form-urlencoded ดิบที่ไม่มีเครื่องหมาย ? นำหน้าก็จะถูกแยกวิเคราะห์ด้วยวิธีเดียวกัน หากคุณต้องการแก้ไขชื่อโฮสต์ พอร์ต พาธ หรือ hash ด้วย ให้เปิดลิงก์นั้นใน เครื่องมือแยกส่วนประกอบ URL

จะเกิดอะไรขึ้นกับพารามิเตอร์แฟล็กที่ไม่มีเครื่องหมายเท่ากับ เช่น ?debug หรือ ?dry_run?

ตามอัลกอริทึมการแยกวิเคราะห์ URLSearchParams ของ WHATWG ส่วนของพารามิเตอร์ที่ไม่มีเครื่องหมาย = จะถูกกำหนดให้ชื่อคีย์ที่ถอดรหัสแล้วตรงกับชื่อพารามิเตอร์นั้น ("dry_run") และมีค่าเป็นสตริงว่าง ("") ซึ่งในตารางแบบโต้ตอบ คุณสามารถกำหนดค่าที่ชัดเจนเช่น true ลบพารามิเตอร์นั้นทิ้ง หรือปล่อยให้เป็นค่าว่างไว้ตามเดิมก็ได้

API key, โทเค็น OAuth หรือพารามิเตอร์ webhook จะถูกส่งไปยังเซิร์ฟเวอร์หลังบ้านหรือไม่?

ไม่มีการส่งข้อมูลใดๆ ทั้งสิ้น การแยกวิเคราะห์ การแก้ไขในตาราง และการแปลงเป็น JSON ทั้งหมดทำงานอยู่บนเบราว์เซอร์ของคุณ 100% ด้วย JavaScript ฝั่งไคลเอนต์ ข้อมูลรับรองที่สำคัญในคิวรี ค่า access_token และเพย์โหลดวิเคราะห์ข้อมูลภายในจะไม่ถูกส่งออกจากเครื่องของคุณอย่างแน่นอน