Perplexity AI
The complete guide

What is Perplexity AI?

Perplexity AI is an AI-based search engine that delivers direct answers with source citations, in real time. Unlike ChatGPT or Claude, which rely on knowledge learned up to a certain date, Perplexity searches the web right now and synthesizes the results into a coherent answer with links for every claim.

The company was founded in 2022 by Aravind Srinivas (formerly OpenAI and Google DeepMind), Denis Yarats (formerly Meta AI), Johnny Ho and Andy Konwinski. Within two years they reached more than15 million monthly active users and raised hundreds of millions of dollars, including investment from Jeff Bezos and NVIDIA.

The product works as a combination of Search Engine and LLM: it runs multiple search queries simultaneously, reads the web pages, and then feeds the content to a language model that produces a summarized answer. The result is a fundamentally different experience from regular search — instead of a list of links, you get an answer.

The difference from Google Search

Google Search returns a list of links — you have to visit each site and filter the information yourself. Perplexity does that work for you: it reads the sites, synthesizes the information, and presents one consolidated answer with a source index you can verify. Instead of 10 open tabs — one answer.

The difference from ChatGPT

ChatGPT (without Web Search) works from knowledge learned up to a cutoff date — it doesn't know what happened this month. Even ChatGPT with Web Search works differently: Perplexity is built from the ground up for search, shows sentence-level citations, and is architecturally tuned for processing web results. ChatGPT excels at writing and creation; Perplexity excels at search and fact-checking.

Pricing

Perplexity's interface

Perplexity's interface is made up of several main areas worth knowing. Unlike Google, which everyone knows, Perplexity presents a hybrid experience between a search engine and an AI conversation.

The main interface components

• Search Bar: The main search box — where you enter your question. You can use natural language, not just keywords.
• Focus Mode Selector: A button that lets you choose the search source before sending (Web, Academic, YouTube, Reddit, Writing).
• Pro Search Toggle: Enabling deep search — turns Quick Search into a multi-step analysis.
• Answer Panel: The summarized answer with numbered citations. Each number in brackets is a link to a source.
• Sources Panel: The list of sources that were read — clicking opens the original page.
• Follow-up Questions: Follow-up questions the AI suggests for deeper exploration.
• Spaces: Personal workspaces with history and documents.
• History: All previous searches for quick retrieval.

Focus Modes — focused search by source

One of Perplexity's most powerful features. Instead of searching the whole internet, Focus Modes let you narrow to a specific source type — which significantly improves answer quality for focused questions.

Pro Search — deep, staged analysis

Pro Search is Perplexity's premium product — not just a quick search, but a multi-step research process. While Quick Search searches and shows an answer within 5 seconds, Pro Search takes 15-30 seconds and does much more.

What happens behind the scenes

Quick Search vs Pro Search — a direct comparison

Prompt tips for Pro Search

• Start with"Compare X to Y" — Pro Search excels at complex comparisons
• Ask for "Summarize all the perspectives" — get a multi-sided analysis
• Specify "from the last 3 months" to filter for recent results only
• Ask for "as a structured report" to get organized output with headings
• Questions multi-dimensional — "what causes X, and what are the implications for Y" — works excellently

Spaces (Collections) — a personal Knowledge Base

Spaces is a feature that lets you create a dedicated workspace for a project. Inside a Space you can upload files (PDF, Word, CSV, text), set fixed system instructions, and save conversation history. All conversations in a Space share the same context.

Creating a useful Space — step by step

Use Cases for Spaces

• Company Knowledge Base: Upload HR documents, procedures, and FAQs — employees ask and get answers from the internal material
• Research Project: All the articles, data and notes in one place — combined analysis with up-to-date search
• Content Strategy: Brand voice, target audience, competitors — every content question with the right context
• Legal Review: Contracts, regulations, rulings — legal questions with context specific to the industry
• Team sharing: Spaces can be shared with team members on Pro — everyone works from the same knowledge base

Perplexity API — integration in code

Perplexity's API is compatible with OpenAI's format — meaning you can adapt existing code with a minimal change to two parameters: the base URL and the model name. The API provides access to the Sonar models built for real-time web search.

A basic code example — Python

from openai import OpenAI

client = OpenAI(
    api_key="pplx-...",          # the API key from perplexity.ai/settings
    base_url="https://api.perplexity.ai"
)

response = client.chat.completions.create(
    model="llama-3.1-sonar-large-128k-online",
    messages=[
        {
            "role": "system",
            "content": "Answer with sources"
        },
        {
            "role": "user",
            "content": "What are the new developments in AI this week?"
        }
    ]
)

print(response.choices[0].message.content)
print(response.citations)  # sources!

Advanced example — Streaming + Citations

from openai import OpenAI

client = OpenAI(
    api_key="pplx-...",
    base_url="https://api.perplexity.ai"
)

# Streaming response — shows text in real time
with client.chat.completions.stream(
    model="sonar-large-online",
    messages=[
        {"role": "user", "content": "What is the state of the real-estate market in Israel in 2026?"}
    ]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

# after completion — get the citations
final = stream.get_final_completion()
if hasattr(final, 'citations'):
    print("\n\n--- sources ---")
    for i, url in enumerate(final.citations, 1):
        print(f"  [{i}] {url}")

The models available in the API

10 practical use cases

Perplexity excels at scenarios requiring up-to-date, verified information with sources. Here are 10 ways to make your life easier.

Perplexity vs ChatGPT Search vs Grok DeepSearch

The three leading AI Search tools today — all search the web in real time, but with fundamentally different approaches. Here is the honest comparison.

When to choose each tool

• Perplexity: Research, fact-checking, academic questions, search requiring sentence-level citations
• ChatGPT Search: When you want a combination of search + writing + code in the same conversation; Projects with memory
• Grok DeepSearch: Searching X/Twitter, who said what on social media, a real-time social pulse

Tips and tricks

Multi-Step questions

Instead of a long, complex question, break it into steps: first ask "what's the background of X?", get an answer, then ask "how does that affect Y?". The context is kept in the conversation and you'll get a deeper analysis than one big question.

Specify a date range

Add "from the last 3 months" or "published after January 2026" to filter out old results. Perplexity respects time instructions relatively well.

Ask for a specific format

Perplexity responds well to format requests: "as a comparison table", "in bullet points", "as a numbered list with pros and cons". Combined with Pro Search it yields structured reports that are nearly ready to publish.

Academic Mode for medical and scientific questions

For any question requiring evidence — ask in Academic Mode. Perplexity will refer to peer-reviewed scientific sources rather than blogs. Result: more reliable answers with citations you can review.

Follow-up Questions — explore in depth

Always look at the Related Questions shown at the bottom. Perplexity identifies dimensions you didn't ask about — one click expands the research. Good conversations in Perplexity are usually 5-10 short questions, not one long question.

Export and sharing

Every answer can be Copied in various formats (Markdown, plain text). Spaces can be shared on Pro. Pages can be shared as a public page. Excellent for sharing research with colleagues.

4 practical projects

# daily_brief.py
import requests, json

def get_daily_brief(topics=["AI", "cybersecurity", "startup"]):
    url = "https://api.perplexity.ai/chat/completions"
    headers = {"Authorization": "Bearer pplx-...", "Content-Type": "application/json"}

    query = f"Give me the 5 most important news items on {', '.join(topics)} from the last 24 hours. English, bullet points."

    data = {
        "model": "sonar-large-online",
        "messages": [{"role": "user", "content": query}]
    }

    r = requests.post(url, headers=headers, json=data)
    return r.json()["choices"][0]["message"]["content"]

if __name__ == "__main__":
    brief = get_daily_brief()
    print(brief)
    # add sending to Slack/email here

# research_report.py
from openai import OpenAI
from docx import Document  # pip install python-docx

def research_topic(query: str, output_file="report.docx"):
    client = OpenAI(api_key="pplx-...", base_url="https://api.perplexity.ai")

    response = client.chat.completions.create(
        model="sonar-huge-online",  # the deepest
        messages=[
            {"role": "system", "content": "Write a detailed research report with headings and subheadings."},
            {"role": "user", "content": query}
        ]
    )

    content = response.choices[0].message.content
    citations = getattr(response, 'citations', [])

    # save to Word
    doc = Document()
    doc.add_heading(query, 0)
    doc.add_paragraph(content)

    if citations:
        doc.add_heading("Sources", 1)
        for i, url in enumerate(citations, 1):
            doc.add_paragraph(f"[{i}] {url}")

    doc.save(output_file)
    print(f"Report saved: {output_file}")

# example
research_topic("What are the trends in AI agents in 2026?")

# competitor_monitor.py
from openai import OpenAI

COMPETITORS = ["Competitor A", "Competitor B", "Competitor C"]

def check_competitor(name: str) -> dict:
    client = OpenAI(api_key="pplx-...", base_url="https://api.perplexity.ai")

    response = client.chat.completions.create(
        model="sonar-large-online",
        messages=[{
            "role": "user",
            "content": f"""Check what's new at {name} in the last week:
            1. New product launches
            2. Pricing changes
            3. Management team changes
            4. Strategic moves
            Answer in English, bullet points."""
        }]
    )

    return {
        "name": name,
        "update": response.choices[0].message.content,
        "sources": getattr(response, 'citations', [])
    }

# run on all competitors
results = [check_competitor(c) for c in COMPETITORS]
for r in results:
    print(f"\n=== {r['name']} ===")
    print(r['update'])

# research_agent.py
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from openai import OpenAI

@tool
def perplexity_search(query: str) -> str:
    """Search for up-to-date information on the web with citations. Use when you need information that changes."""
    client = OpenAI(api_key="pplx-...", base_url="https://api.perplexity.ai")
    response = client.chat.completions.create(
        model="sonar-large-online",
        messages=[{"role": "user", "content": query}]
    )
    content = response.choices[0].message.content
    citations = getattr(response, 'citations', [])
    return f"{content}\n\nSources: {', '.join(citations[:3])}"

# main LLM — Claude or GPT-4o
llm = ChatOpenAI(model="gpt-4o", temperature=0)

# Agent with Perplexity as a tool
tools = [perplexity_search]
agent = create_openai_tools_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

result = executor.invoke({"input": "Write me a report on the Israeli SaaS market in 2026"})
print(result["output"])

Cheat sheet — Quick Reference

Choosing a Focus Mode

Effective question templates

API models — when to use each one

• sonar-small-online — high-volume search, fast answers, minimal cost ($0.20/1M tokens)
• sonar-large-online — sweet spot for most needs ($1/1M tokens) — 127K context
• sonar-huge-online — deep analysis, long documents ($5/1M tokens)
• sonar-reasoning — questions requiring multi-step thinking + search ($5/1M tokens)

Pro Tips from the field

• Always specify the language: "Answer in Hebrew" — Perplexity's default is English
• Spaces with a System Prompt: Set it once — "you are a market analyst, answer in English" — and spend less effort on every question
• Click the citations: Always verify at least one source in every critical answer
• Smart follow-up: Ask "what wasn't said?" to discover dimensions the algorithm omitted
• Pages for sharing: Create a Page from the answer to share with colleagues — it looks professional and ready