คู่มือ API Perplexity: สร้างคำตอบที่อิงจากแหล่งข้อมูลอย่างละเอียดทีละขั้นตอน

PERPLEXITY API · คู่มือ Python · 2026

คู่มือ API Perplexity นี้จะแสดงวิธีสร้างสคริปต์ Python ที่ให้คำตอบพร้อมแหล่งข้อมูลเว็บที่สามารถคลิกได้ ใช้ Agent API เพื่อส่งคำถาม อ่านคำตอบ จับคู่เครื่องหมายอ้างอิงกับ ID แหล่งข้อมูล และส่งออกไฟล์ Markdown ที่คุณสามารถตรวจสอบได้.

เราจะใช้คำถามเดียวตลอดทั้งบทความ: โครงการ Python ขนาดเล็กควรใช้สภาพแวดล้อมเสมือนและจัดการการพึ่งพาอย่างไร? เริ่มด้วยคำขอพื้นฐาน แล้วเพิ่มการวิเคราะห์ข้อมูลต้นทางและตัวกรองโดเมน คุณจำเป็นต้องมีความรู้พื้นฐานเกี่ยวกับ Python และบัญชีผู้พัฒนา Perplexity ที่ได้ตั้งค่าการเรียกเก็บเงิน API แล้ว.

หากคุณก็ใช้ AI ในการวิจัยและเขียนงานประจำวันด้วย, Perplexity บน GlobalGPT ให้สามารถเข้าถึงได้ภายในพื้นที่ทำงาน AI แบบครบวงจร ซึ่งช่วยลดความจำเป็นในการสลับไปมาระหว่างเครื่องมือต่าง ๆ กระบวนการทำงานของผู้ใช้นั้นแยกต่างหากจากกุญแจผู้พัฒนาและระบบการคิดค่าบริการ API ที่ใช้ในที่นี้.

คำตอบด่วน: ใช้ เร็ว การตั้งค่าล่วงหน้าของเอเจนต์สำหรับคำตอบแรกที่อิงจากเว็บ, อ่าน response.output_text เพื่อหาคำตอบ และอ่าน ผลการค้นหา รายการใน response.output สำหรับแหล่งข้อมูล ให้จับคู่แต่ละตัวชี้ในบรรทัดกับแหล่งข้อมูลตามค่าที่มันส่งคืนมา id. การอ้างอิงหมายความว่า “คำตอบชี้ไปยังผลลัพธ์นี้”; แต่ไม่ได้เป็นการรับประกันว่าหน้าดังกล่าวจะพิสูจน์ทุกข้อกล่าวอ้าง.

ตัวอย่างสถานะ: โครงสร้างคำขอเป็นไปตามเอกสารทางการที่ตรวจสอบเมื่อวันที่ 28 กันยายน 2569 เครื่องมือช่วยอ้างอิงได้ถูกตรวจสอบด้วยข้อมูลตัวอย่างแบบออฟไลน์; ไม่มีการส่งคำขอ API แบบเสียค่าใช้จ่ายใดๆ สำหรับบทเรียนนี้ ข้อมูลต้นฉบับที่แสดงในภาพเป็นตัวอย่างเพื่ออธิบายเท่านั้น.

• คุณควรใช้ API Perplexity ตัวไหน?
• ขั้นตอนที่ 1: รับ API key และติดตั้ง Python
• ขั้นตอนที่ 2: ส่งคำขอแรกที่ต่อดิน
• ขั้นตอนที่ 3: คัดลอกคำตอบและตรวจสอบแหล่งที่มา
• ขั้นตอนที่ 4: ปรับปรุงคำตอบด้วยตัวกรองการค้นหา
• ขั้นตอนที่ 5: บันทึกคำตอบที่ครบถ้วนพร้อมแหล่งข้อมูลที่สามารถคลิกได้
• การสตรีมและผลลัพธ์ที่มีโครงสร้าง
• ค่าใช้จ่ายและข้อผิดพลาดที่พบบ่อย
• การย้ายจากบทเรียน Sonar เวอร์ชันเก่า
• คำถามที่มักถูกถาม

คู่มือ API Perplexity: การเลือก API ที่เหมาะสม

นี่คืออินเทอร์เฟซสำหรับนักพัฒนา ผลิตภัณฑ์แชทอาจจัดรวมฟังก์ชันที่คล้ายกันในรูปแบบที่ต่างกัน; ภาพรวมของเราเกี่ยวกับ คุณสมบัติของ Perplexity อธิบายถึงประสบการณ์ของผู้ใช้.

ของ Perplexity’s คู่มือเริ่มต้นใช้งาน API อย่างรวดเร็วอย่างเป็นทางการ จัดกลุ่มผลิตภัณฑ์สำหรับนักพัฒนาตามงานที่คุณต้องทำ ให้เลือกพื้นผิวที่มีขนาดเล็กที่สุดที่สามารถสร้างข้อมูลที่แอปพลิเคชันของคุณต้องการได้จริง.

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

เกี่ยวกับ Sonar: ปัจจุบัน ภาพรวมการย้ายถิ่น ระบุว่า Sonar Chat Completions ยังคงได้รับการสนับสนุน และแนะนำให้ใช้ Agent สำหรับโครงการใหม่ทั้งหมด ดังนั้น คู่มือนี้จึงใช้ Agent อย่าสรุปว่าการผสานระบบแบบเก่าหยุดทำงานแล้วเพียงเพราะวันที่กำหนดในคู่มือเก่า.

ขั้นตอนที่ 1: รับ API key และติดตั้ง Python

สร้างกุญแจและเตรียมการเรียกเก็บเงิน

เปิดคอนโซล API Perplexity, เลือกหรือสร้างโครงการที่คุณจะใช้ ตั้งค่าการเรียกเก็บเงิน API และสร้างกุญแจ เก็บกุญแจไว้ด้านเซิร์ฟเวอร์ API สำหรับผู้พัฒนาจะถูกเรียกเก็บเงินแยกต่างหากจากการสมัครสมาชิกของผู้ใช้; ตรวจสอบยอดเงินในโครงการของคุณก่อนส่งคำขอ.

ติดตั้ง SDK อย่างเป็นทางการ

python -m venv .venv

# macOS/Linux: ใช้คำสั่งเปิดใช้งานนี้
source .venv/bin/activate

# Windows PowerShell: ใช้คำสั่งนี้แทน
.venv\Scripts\Activate.ps1

python -m pip install --upgrade perplexityai

ใช้ Python 3.10 หรือเวอร์ชันที่ใหม่กว่าสำหรับโค้ดด้านล่างนี้ เปิดใช้งานสภาพแวดล้อมด้วยคำสั่งที่เหมาะสมกับระบบปฏิบัติการของคุณ แล้วติดตั้ง SDK หาก PowerShell ป้องกันการเปิดใช้งาน ให้ใช้ .venv\Scripts\python.exe แทน ไพธอน เพื่อติดตั้งและดำเนินการสคริปต์.

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

ตัวอย่างนี้ใช้คำถามเกี่ยวกับการเขียนโค้ด เพราะข้อกล่าวอ้างในตัวอย่างสามารถตรวจสอบได้จากเอกสารที่มีการอัปเดตอย่างสม่ำเสมอ คู่มือของเราเกี่ยวกับ Perplexity สำหรับการเขียนโค้ด อธิบายว่าการสนับสนุนด้านการวิจัยมีบทบาทอย่างไรเมื่อเทียบกับการทดสอบโค้ดด้วยตัวเอง.

ตั้งค่า API key เป็นตัวแปรสภาพแวดล้อม

# macOS/Linux
export PERPLEXITY_API_KEY="your-key-here"

# Windows PowerShell
$env:PERPLEXITY_API_KEY = "your-key-here"

SDK อ่าน PERPLEXITY_API_KEY เมื่อคุณสร้างไคลเอนต์ อย่าคัดลอกคีย์ไปวางในสมุดบันทึก อย่าส่งคีย์นั้นไปยัง Git หรือส่งไปยังเบราว์เซอร์ หากคุณใช้ไฟล์ .env ในระบบท้องถิ่น ให้เก็บไฟล์นั้นไว้นอกระบบควบคุมเวอร์ชัน และโหลดไฟล์นั้นด้วยไลบรารีตัวแปรสภาพแวดล้อมที่คุณเลือก.

ขั้นตอนที่ 2: ส่งคำขอแรกที่ต่อดิน

คู่มือเริ่มต้นใช้งาน Agent API เอกสาร โพสต์https://api.perplexity.ai/v1/agent. โปรแกรมไคลเอนต์ Python ของมันจะห่อคำขอด้วย client.responses.create(). . เร็ว การตั้งค่าเริ่มต้นจะเปิดใช้งานการค้นหาบนเว็บโดยอัตโนมัติ ซึ่งทำให้ตัวอย่างแรกมีขนาดไม่ใหญ่เกินไป.

from perplexity import Perplexity

client = Perplexity()

question = (
    "โครงการ Python ขนาดเล็กควรใช้สภาพแวดล้อมเสมือน "
    "และจัดการการพึ่งพาอย่างไร?"
)

response = client.responses.create(
    preset="fast",
    input=question,
)

print(response.output_text)

บันทึกโค้ดตัวอย่างเป็น first_request.py, แล้วเรียกใช้ python first_request.py ในเทอร์มินัลเดียวกันที่คุณได้กำหนดคีย์ไว้ การเรียกที่สำเร็จควรแสดงข้อความตอบกลับที่ไม่ว่างเปล่า หากคุณต้องการหลักฐานสำหรับผลลัพธ์ ให้ดำเนินการต่อสู่ขั้นตอนการสกัดข้อมูลต้นฉบับ; ข้อความเพียงอย่างเดียวไม่ถือเป็นการตรวจสอบที่เสร็จสมบูรณ์.

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

คำขอเดียวกันด้วย cURL

curl https://api.perplexity.ai/v1/agent \
  -H "Authorization: Bearer $PERPLEXITY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "preset": "fast",
    "input": "โครงการ Python ขนาดเล็กควรใช้สภาพแวดล้อมเสมือนและจัดการการพึ่งพาอย่างไร?"
  }'

ตัวอย่าง cURL นี้ใช้ไวยากรณ์ Bash สำหรับ macOS/Linux หรือเชลล์ที่เข้ากันได้กับ Bash การรันแต่ละครั้งจะสร้างคำขอที่คิดค่าบริการใหม่หนึ่งครั้ง ให้ใช้ตัวอย่างนี้เฉพาะเมื่อต้องการแยกปัญหาที่จุดปลายทางออกจากปัญหาของ Python เท่านั้น; อย่ารันทุกเวอร์ชันเพียงเพื่อทำตามตัวอย่าง.

โค้ด JavaScript ที่เทียบเท่าด้านเซิร์ฟเวอร์

Node.js 18+ มี รับ, ดังนั้นการทดสอบแบบ smoke test ทางฝั่งเซิร์ฟเวอร์จึงไม่จำเป็นต้องใช้ไลบรารีเพิ่มเติม อ่านข้อมูลดิบ ผลลัพธ์ รายการในคำตอบ JSON; Python SDK ให้ความสะดวกในการ ข้อความผลลัพธ์ อุปกรณ์เสริม.

const res = await fetch("https://api.perplexity.ai/v1/agent", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.PERPLEXITY_API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    preset: "fast",
    input: "How should a small Python project use virtual environments and manage dependencies?"
  })
});
if (!res.ok) throw new Error(`Perplexity HTTP ${res.status}`);
console.log(await res.json());

ขั้นตอนที่ 3: คัดลอกคำตอบและตรวจสอบแหล่งที่มา

คู่มือการอ้างอิงอย่างเป็นทางการ แยกข้อความเล่าเรื่องออกจากบันทึกหลักฐาน แหล่งข้อมูลถูกส่งมาใน ผลลัพธ์ รายการที่มีประเภท ผลการค้นหา. อ่านบทความนั้น ผลลัพธ์ และจับคู่เครื่องหมายอ้างอิงแต่ละอันกับผลลัพธ์ id. ผลลัพธ์มีชื่อและ URL; ให้จัดการค่าที่ขาดก่อนที่จะแสดงผล.

รายละเอียดสุดท้ายนี้สำคัญมาก อย่าสมมติว่า “citation 1” จะเป็นองค์ประกอบแรกในอาร์เรย์เสมอไป หลังจากที่เครื่องมืออื่นเพิ่มรายการเข้าไป สร้างระบบค้นหาตาม ID แล้วจึงกำหนดตำแหน่งของมาร์กเกอร์ที่ปรากฏจริงในคำตอบ.

def field(obj, name, default=None):
    return obj.get(name, default) if isinstance(obj, dict) else getattr(obj, name, default)

def source_index(output):
    sources = {}
    for item in output or []:
    if field(item, "type") != "search_results":
        continue
    for result in field(item, "results", []) or []:
            sid, url = field(result, "id"), field(result, "url")
 if sid is None:
 continue
 key = str(sid)
 if key in sources and field(sources[key], "url") != url:
                raise ValueError(f"URL ที่ขัดแย้งกันสำหรับ source ID {key}")
 sources[key] = result
    return sources

sources = source_index(response.output)
print(sources.get("7"))  # A source ID, not array position 7

สคริปต์ครบถ้วนด้านล่างนี้สามารถระบุได้ [1] และ [web:1], รูปแบบการอ้างอิงที่บันทึกไว้สำหรับค่าตั้งล่วงหน้าทั่วไป ตัวช่วยข้างต้นสามารถจัดการได้ทั้งวัตถุ SDK และพจนานุกรม และจะปฏิเสธ URL ที่ขัดแย้งกันซึ่งถูกกำหนดให้กับ ID เดียวกัน มันจะไม่จัดลำดับผลลัพธ์ใหม่หรือคาดเดาแหล่งที่มาที่ขาดหายไป.

หากต้องการอ่านการอภิปรายอย่างละเอียดเกี่ยวกับคุณภาพการอ้างอิง โปรดดู คู่มือความแม่นยำในการอ้างอิง Perplexity. การอ้างอิงคือบันทึกการตรวจสอบ; แอปพลิเคชันของคุณยังจำเป็นต้องมีนโยบายสำหรับหน้าเว็บที่ล้าสมัย URL ที่ซ้ำกัน และคำกล่าวอ้างที่ไม่ได้รับการสนับสนุน.

ตัวอย่างเช่น หากอาร์เรย์ที่ส่งกลับมาประกอบด้วย ID 2 ตามด้วย ID 7 แล้ว ตัวบ่งชี้ [7] ต้องเชื่อมโยงไปยัง ID 7 หาก URL เดียวกันปรากฏอยู่ใต้ ID 7 และ 9 คุณสามารถแสดง URL นั้นเพียงครั้งเดียวได้ โดยยังคงรักษาทั้งสอง ID ไว้ หาก ID 8 ไม่ปรากฏขึ้นเลย ให้เก็บ [8] ให้แสดงขึ้นและทำเครื่องหมายว่าไม่ตรงกัน.

ขั้นตอนที่ 4: ปรับปรุงคำตอบด้วยตัวกรองการค้นหา

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

response = client.responses.create(
    preset="fast",
    input=(
 "โครงการ Python ขนาดเล็กควรใช้สภาพแวดล้อมเสมือน "
 "และจัดการการพึ่งพาอย่างไร? โปรดอ้างอิงคำแนะนำที่คุณใช้."
    ),
    tools=[
 {
 "type": "web_search",
 "filters": {
 "search_domain_filter": [
 "docs.python.org",
                    "packaging.python.org",
 ]
 },
 }
    ],
)

ตัวกรองนี้อยู่ในส่วนการตั้งค่าเครื่องมือค้นหาบนเว็บ เอกสารการย้ายข้อมูลยังอธิบายด้วยว่า ตัวกรองตามความใหม่ของผลการค้นหา สำหรับคำถามที่ขึ้นอยู่กับความทันเวลา ให้ใช้หลักการ "recency" เมื่อคำถามนั้นขึ้นอยู่กับข้อมูลที่เพิ่งเผยแพร่หรือข่าวล่าสุด; การจำกัดขอบเขตและวันที่อย่างแคบเกินไปอาจทำให้คุณมีหลักฐานไม่เพียงพอ.

หากมีคำถามเกี่ยวกับเวอร์ชันที่ปล่อยออกมาในเดือนที่ผ่านมา ให้เพิ่ม "search_recency_filter": "เดือน" ข้างๆ ตัวกรองโดเมนการค้นหา. อย่าใส่ไว้ในตัวอย่างของสภาพแวดล้อมเสมือน: เอกสารที่เสถียรอาจมีวันที่เผยแพร่ที่เก่ากว่า หากคุณเปลี่ยนจากโมเดลที่กำหนดไว้ล่วงหน้าไปยังโมเดลที่เลือกโดยตรง ให้ระบุเครื่องมือค้นหาบนเว็บอย่างชัดเจน.

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

หากแอปพลิเคชันของคุณต้องการเพียงลิงก์ที่จัดอันดับและสแนปช็อต ให้เรียกใช้ API การค้นหา และดำเนินการสังเคราะห์ด้วยตัวเอง การแยกส่วนนี้สามารถช่วยให้การตรวจสอบและเก็บไว้ในแคชเป็นไปได้ง่ายขึ้น สำหรับการเปรียบเทียบที่กว้างขึ้นกับ Google โปรดดู Perplexity แตกต่างจาก Google อย่างไร.

ขั้นตอนที่ 5: บันทึกคำตอบที่ครบถ้วนพร้อมแหล่งข้อมูลที่สามารถคลิกได้

บันทึกไฟล์ต่อไปนี้ด้วยชื่อ perplexity_tutorial.py. ระบบนี้ทำงานแบบครบวงจร: รวมถึงตัวช่วยแหล่งข้อมูล (source helper), ใช้ตัวกรองโดเมนเอกสาร Python, แปลงเครื่องหมายการอ้างอิงที่ตรงกันเป็นลิงก์, จัดกลุ่ม URL ที่ซ้ำกันโดยไม่สูญเสีย ID และบันทึกคำตอบ SDK ทั้งหมดพร้อมกับ Markdown.

from pathlib import Path
from collections import defaultdict
from urllib.parse import urlsplit
import json
import re

QUESTION = (
    "How should a small Python project use virtual environments "
    "and manage dependencies?"
)
# Supports the documented [1] and [web:1] forms in prose answers.
CITATION_RE = re.compile(r"(?<!!)\[(?:web:)?(\d+)\](?!\()")

def field(obj, name, default=None):
    return obj.get(name, default) if isinstance(obj, dict) else getattr(obj, name, default)

def source_index(output):
    sources = {}
    for item in output or []:
        if field(item, "type") != "search_results":
            continue
        for result in field(item, "results", []) or []:
            sid, url = field(result, "id"), field(result, "url")
            if sid is None:
                continue
            key = str(sid)
            if key in sources and field(sources[key], "url") != url:
                raise ValueError(f"Conflicting URLs for source ID {key}")
            sources[key] = result
    return sources

def safe_url(value):
    if not isinstance(value, str):
        return None
    parsed = urlsplit(value)
    if parsed.scheme not in ("http", "https") or not parsed.netloc:
        return None
    # Protect a Markdown angle-bracket destination.
    return value.replace("<", "%3C").replace(">", "%3E").replace(" ", "%20")

def md_label(value):
    return re.sub(r"([\\\[\]<>])", r"\\\1", str(value).replace("\n", " "))

def export_markdown(answer, output, question=QUESTION):
    sources = source_index(output)
    cited = list(dict.fromkeys(CITATION_RE.findall(answer)))
    missing = [
        sid for sid in cited
        if sid not in sources or not safe_url(field(sources[sid], "url"))
    ]
    def link(match):
        sid = match.group(1)
        url = safe_url(field(sources.get(sid, {}), "url"))
        return f"[{match.group(0)[1:-1]}](<{url}>)" if url else match.group(0)

    # Keep every ID when the same URL appears under different IDs.
    grouped = defaultdict(list)
    titles = {}
    for sid in cited:
        source = sources.get(sid, {})
        url = safe_url(field(source, "url"))
        if url:
            grouped[url].append(sid)
            titles.setdefault(url, field(source, "title") or url)

    lines = ["# Source-grounded answer", "", question, "",
             CITATION_RE.sub(link, answer), "", "## Cited sources", ""]
    for url, ids in grouped.items():
        lines.append(f"- IDs {', '.join(ids)}: [{md_label(titles[url])}](<{url}>)")
    if missing:
        lines.append("- Unmatched or unusable source IDs: " + ", ".join(missing))
    if not cited:
        lines.append("- No recognized inline citations; evidence not verified.")
    lines.extend(["", "Source links require review; matching IDs does not verify claims."])
    return "\n".join(lines) + "\n"

def main():
    from perplexity import Perplexity
    response = Perplexity().responses.create(
        preset="fast",
        input=QUESTION,
        tools=[{"type": "web_search", "filters": {
            "search_domain_filter": ["docs.python.org", "packaging.python.org"]
        }}],
    )
    answer = response.output_text or ""
    if not answer.strip():
        raise RuntimeError("No answer text returned; inspect response status and errors.")
    Path("perplexity-response.json").write_text(
        response.model_dump_json(indent=2), encoding="utf-8"
    )
    Path("perplexity-answer.md").write_text(
        export_markdown(answer, response.output), encoding="utf-8"
    )
    print("Saved perplexity-answer.md and perplexity-response.json")

if __name__ == "__main__":
    main()

วิ่ง python perplexity_tutorial.py จากโฟลเดอร์โครงการของคุณ มันจะเขียน perplexity-answer.md และ perplexity-response.json ที่นั่น โดยแทนที่ไฟล์เดิมที่มีชื่อเดียวกันด้วยไฟล์ใหม่ Markdown ประกอบด้วยคำถาม คำตอบที่เชื่อมโยง แหล่งอ้างอิง และ ID ที่ไม่ตรงกันทั้งหมด ส่วน JSON เก็บผลลัพธ์ที่ส่งคืนมาและข้อมูลการใช้งานไว้เพื่อใช้ในการวิเคราะห์.

ตัววิเคราะห์นี้มุ่งเน้นไปที่รูปแบบที่มีเครื่องหมายเดียวตามที่ระบุไว้ในเอกสารสำหรับข้อความธรรมดา มันไม่ใช่ตัววิเคราะห์ Markdown แบบเต็มรูปแบบ: หากแอปพลิเคชันของคุณต้องการ Markdown แบบอิสระ ตัวอย่างโค้ด หรือการอ้างอิง เช่น [1,2], เพิ่มตัวแสดงผลที่เข้าใจไวยากรณ์และชุดทดสอบสำหรับรูปแบบนั้น อย่าตีความเครื่องหมายที่ไม่คุ้นเคยใหม่โดยไม่แจ้งเตือน.

ตรวจสอบว่าหน้าเว็บที่ลิงก์ไปนั้นรองรับคำตอบหรือไม่

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

เพิ่มข้อมูลแบบสตรีมมิ่งหรือข้อมูลที่มีโครงสร้างเมื่อจำเป็น

สตรีมมิ่ง

การสตรีมช่วยลดความล่าช้าที่ผู้ใช้รู้สึกได้สำหรับอินเทอร์เฟซการแชท คู่มือการย้ายระบบของเอเจนต์ได้บันทึกเหตุการณ์ความแตกต่างของข้อความ เช่น response.output_text.delta. ให้แสดงผลข้อมูลเดลตาเหล่านั้นทันทีที่รับมา แต่ให้เก็บรายการคำตอบสุดท้ายไว้ด้วย เพื่อให้ UI ของคุณสามารถแสดงแหล่งที่มาได้หลังจากคำตอบเสร็จสิ้นแล้ว การส่งข้อมูลข้อความแบบสตรีมเพียงอย่างเดียวไม่ถือเป็นรายชื่อแหล่งที่มา.

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

stream = client.responses.create(
    preset="fast", input=question, stream=True
)
for event in stream:
    if event.type == "response.output_text.delta":
    print(event.delta, end="", flush=True)

ผลลัพธ์ที่มีโครงสร้าง

ใช้การตอบสนองแบบมีโครงสร้างเมื่อโค้ดในขั้นตอนต่อไปต้องการฟิลด์ เช่น คำตอบ, หมายเหตุเกี่ยวกับความมั่นใจ และ คำถามเพิ่มเติม. ให้เก็บ ID แหล่งข้อมูลไว้ในฟิลด์แยกต่างหาก หรือเก็บผลลัพธ์ต้นฉบับจาก Agent ไว้ เพื่อไม่ให้สคีมาของคุณซ่อนหลักฐานไว้ ตรวจสอบความถูกต้องของสคีมาบนกรณีทดสอบของคุณเองก่อนที่จะนำไปใช้ในเวิร์กโฟลว์.

ข้อมูลอ้างอิงการย้ายข้อมูลยังคงอยู่ รูปแบบการตอบกลับ กับ type: "json_schema" เพื่อสร้างผลลัพธ์ที่มีโครงสร้าง กำหนดฟิลด์ที่จำเป็นและห้ามใช้คุณสมบัติที่ไม่คาดคิดเมื่อเหมาะสม การตรวจสอบความถูกต้องของสคีมาเน้นที่รูปแบบ ไม่ใช่ความถูกต้อง: ID ของแหล่งข้อมูลยังคงต้องสามารถเชื่อมโยงไปยังระเบียนที่ส่งคืนจริงได้ และป้ายความมั่นใจที่เขียนโดยโมเดลไม่ใช่การวัดความแม่นยำ.

ค่าใช้จ่ายของ API Perplexity และข้อผิดพลาดที่พบบ่อย

หน้าราคาอย่างเป็นทางการของ Perplexity, ตรวจสอบเมื่อวันที่ 28 กันยายน 2569, แยกโทเค็นแบบ Agent ออกจากคำสั่งเรียกใช้เครื่องมือ ต่อไปนี้คือค่าบริการเครื่องมือ/การค้นหาของ USD. The เร็ว การตั้งค่าล่วงหน้าของเอเจนต์และ search_type: "fast" เป็นตัวเลือกการตั้งค่าที่แตกต่างกัน; อย่าสรุปอัตราการค้นหาจากชื่อการตั้งค่าล่วงหน้า.

ตัวอย่าง: ค่าใช้จ่ายสำหรับการเรียกใช้การค้นหาบนเว็บตามมาตรฐาน 1,000 ครั้ง พร้อมกับการดึง URL 1,000 ครั้ง $3.00 ในค่าเครื่องมือ ($2.50 + $0.50), ก่อนที่จะรวมค่าโทเคนของโมเดลหรือค่าใช้จ่ายอื่น ๆ นี่เป็นปริมาณงานที่คาดการณ์ไว้ ไม่ใช่ค่าใช้จ่ายที่วัดได้จริงสำหรับบทเรียนนี้ การร้องขอจากเอเจนต์หนึ่งครั้งอาจเรียกใช้เครื่องมือหลายตัวได้ หากมีข้อมูลให้ตรวจสอบ ค่าใช้จ่ายตามการใช้งาน ค่าใช้จ่ายรวม บนคำตอบที่เสร็จสิ้นแล้ว.

API การค้นหาจะคิดค่าบริการสำหรับคำขอที่สำเร็จ รวมถึงคำขอที่ไม่ให้ผลลัพธ์ใดๆ ด้วย; ราคาคำขอนี้ไม่รวมค่าโทเคนเพิ่มเติม ส่วนค่าใช้จ่ายของเอเจนต์ขึ้นอยู่กับโทเคนของโมเดลและเครื่องมือต่างๆ โปรดแยกหน่วยการคิดค่าบริการเหล่านี้ออกจากกันเมื่อเปรียบเทียบเวิร์กโฟลว์ที่มีคำตอบกับเวิร์กโฟลว์ที่ใช้การค้นหาเท่านั้น.

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

การย้ายจากบทเรียน Sonar เวอร์ชันเก่า

ผลการค้นหาหลายแห่งยังคงแสดงรูปแบบ Chat Completions แบบเก่า คู่มือการย้ายข้อมูลของ Agent ใช้การแมปแนวคิดแบบตรง หากคุณกำลังเปรียบเทียบป้ายกำกับของโมเดลผู้บริโภคกับค่าตั้งล่วงหน้าของ API บทความอธิบายของเราเกี่ยวกับ LLM Perplexity ใช้ ให้ข้อมูลบริบท แต่ไม่สามารถแทนที่เอกสารคู่มือของ Agent API ได้.

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

คำถามที่มักถูกถาม

API Perplexity เป็นบริการฟรีหรือไม่?

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

ผมจำเป็นต้องใช้ Perplexity Pro เพื่อใช้ API หรือไม่?

การเข้าถึง API และแผน Pro สำหรับผู้ใช้ทั่วไป เป็นผลิตภัณฑ์ที่แยกกัน สร้างข้อมูลรับรอง API และตรวจสอบการเรียกเก็บเงิน API สำหรับบัญชีผู้พัฒนาที่คุณวางแผนจะใช้.

ควรใช้ Agent API หรือ Search API ดีกว่า?

เลือก "Agent" เมื่อคุณต้องการคำตอบที่สมบูรณ์และอิงจากข้อมูลจริง พร้อมแหล่งที่มา เลือก "Search" เมื่อแอปพลิเคชันของคุณควรมีฟังก์ชันการจัดอันดับ การกรอง และการสังเคราะห์ข้อมูล คุณสามารถรวม "Search" กับโมเดลของคุณเองได้ หากต้องการควบคุมอย่างเคร่งครัดในทุกขั้นตอนของการสร้างคำตอบ.

สามารถเรียกใช้ Perplexity จาก JavaScript ได้หรือไม่?

ใช่ครับ ใช้ตัวอย่าง Node.js ด้านเซิร์ฟเวอร์ข้างต้น หรือ JavaScript SDK อย่างเป็นทางการ เก็บคีย์ไว้บนเซิร์ฟเวอร์ เมื่ออ่าน JSON แบบดิบ ให้ตรวจสอบรายการผลลัพธ์ที่ระบุประเภทข้อมูล และใช้กฎการแมป source-ID ที่เดียวกัน.

การอ้างอิงแบบ Perplexity นั้นรับประกันว่าจะถูกต้องหรือไม่?

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

ทำไมตัววิเคราะห์ของฉันไม่พบแหล่งข้อมูลเลย?

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

GlobalGPT สามารถแทนที่ API key ของ Perplexity ได้หรือไม่?

GlobalGPT เป็นพื้นที่ทำงาน AI แบบครบวงจรสำหรับการใช้งาน AI ในชีวิตประจำวัน การสมัครสมาชิกและการเข้าถึงโมเดลของ GlobalGPT แยกต่างหากจากบัญชีผู้พัฒนา Perplexity, คีย์ API และเครดิต API; คู่มือ Python นี้ใช้บัญชีผู้พัฒนาดังกล่าว.

รายการตรวจสอบก่อนเปิดตัวที่ใช้งานได้จริง

• สร้างกุญแจด้านเซิร์ฟเวอร์และยืนยันการเรียกเก็บเงิน API.
• ใช้เวอร์ชันขั้นต่ำ เร็ว โปรดตรวจสอบก่อนที่จะเพิ่มตัวกรองหรือเริ่มสตรีม.
• เก็บคำตอบทั้งหมดไว้ ไม่ใช่เพียงข้อความคำตอบที่แสดงอยู่เท่านั้น.
• จับคู่เครื่องหมายอ้างอิงกับ ID แหล่งที่มาที่ได้รับการส่งคืน และทำเครื่องหมายไว้สำหรับเครื่องหมายที่ไม่ได้จับคู่.
• ตรวจสอบหน้าเว็บที่อ้างอิงเพื่อตรวจสอบความถูกต้องของข้อมูล ความทันสมัย และ URL ที่ซ้ำกัน.
• โปรดตรวจสอบอีกครั้งเกี่ยวกับตัวแทนที่ทำงานอยู่จริง ราคา และเอกสารการย้ายข้อมูล ก่อนที่จะดำเนินการติดตั้ง.

ตอนนี้คุณมีรูปแบบหลักสำหรับการบูรณาการ API Perplexity ที่เชื่อถือได้แล้ว: ตั้งคำถามที่ชัดเจน, ให้ Agent API ค้นหา, เก็บคำตอบและหลักฐานไว้ด้วยกัน, และทำให้การอ้างอิงทุกครั้งสามารถตรวจสอบได้ จากจุดนี้ ให้เพิ่มระบบแคช, การลองใหม่ และกฎการตรวจสอบของคุณเองในกระบวนการทำงานที่ใช้ source-ID เดียวกัน.