# Perplexity AI Search & Multi-Turn Chat API (`dev00/perplexity-ai-search-api`) Actor

Perform real-time AI web search, verified citations, trust scores, and multi-turn conversational chat threads with search focus filtering.

- **URL**: https://apify.com/dev00/perplexity-ai-search-api.md
- **Developed by:** [dev00](https://apify.com/dev00) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 ai web search & reasoning queries

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 🤖 Perplexity AI Search & Multi-Turn Chat Scraper (Live Citations & Trust Scores)

> 🚀 **The #1 Most Complete, Low-Latency Real-Time Perplexity AI Web Search, Structured Citations, Trust Scores, Multi-Turn Conversation Memory & Search Focus Filtering Actor on Apify.**

Looking for instant AI reasoning backed by real-time web citations, domain trust levels, and conversational thread memory without paying $20/user/month for individual subscriptions or navigating rate limits?

The **Perplexity AI Search & Multi-Turn Chat Scraper** combines live web indexing with state-of-the-art conversational AI models to deliver structured answers backed by verified source citations, publication snippets, domain trust scores, and conversational thread memory.

Pass the returned `context_uuid` into subsequent requests to maintain context across multi-turn conversational chat threads (`is_followup: true`).

***

### 🌟 Institutional Comparison: Why Choose Perplexity AI Scraper?

| Market Feature | Official Perplexity API | Tavily AI Search | Exa.ai Search | 🤖 Perplexity AI Scraper |
| :--- | :---: | :---: | :---: | :---: |
| **Pricing per 1k Searches** | 💸 $5.00 + Token Markup ($6–$14) | 💸 $8.00 – $16.00 | 💸 $5.00 – $15.00 | ⚡ **Pay-Per-Event ($0.003 / search)** |
| **Real-Time Web Citations** | ✅ Yes | ✅ Yes | ⚠️ Snippets Only | ✅ **Live Verified URLs & Trust Scores** |
| **Multi-Turn Thread Memory** | ⚠️ Custom Setup | ❌ No Memory | ❌ No Memory | ✅ **Built-in `context_uuid` Memory** |
| **Search Focus Modes** | ⚠️ Limited | ⚠️ General / News | ⚠️ Auto Only | ✅ **Internet, Academic, Writing, YouTube, Reddit** |
| **AI Model Selection** | ⚠️ Sonar Only | ❌ Fixed LLM | ❌ Fixed LLM | ✅ **Turbo, Sonar, GPT-4o, Claude 3.5 Sonnet** |
| **Sub-100ms Autocomplete** | ❌ No | ❌ No | ❌ No | ✅ **Sub-100ms Instant Suggest Mode** |
| **Domain Trust Ratings** | ❌ No | ❌ No | ❌ No | ✅ **1-3 Domain Trust Scores & Reasons** |

***

### ⚡ Comprehensive Feature Breakdown

#### 1. 🔍 Real-Time AI Web Search & Live Citations (`AI_SEARCH`)

Submit any natural language question or research prompt to get a comprehensive, factual AI answer with direct clickable web citations, source titles, publication snippets, and trust ratings.

#### 2. 💬 Multi-Turn Conversation Thread Memory (`context_uuid`)

Pass the `context_uuid` returned from your initial request into follow-up requests to continue chatting seamlessly within the same conversational context (`is_followup: true`). No database or state management needed on your end.

#### 3. 🎯 Search Focus Filtering (`focus`)

Target your query to specific domains and knowledge bases:

- **`internet`**: Global public web pages (Default).
- **`academic`**: Scholarly articles, arXiv, PubMed, and peer-reviewed journals.
- **`writing`**: Direct text and code generation without web browsing.
- **`youtube`**: Search video transcripts and timestamped descriptions.
- **`reddit`**: Search real community discussions and opinions on Reddit.

#### 4. ⚡ AI Model Selection (`model`)

Select your preferred AI reasoning engine:

- **`turbo`**: Ultra-fast real-time concise synthesis model.
- **`sonar`**: Deep web reasoning with dense citations.
- **`gpt4o`**: OpenAI GPT-4o multimodal reasoning with web browsing.
- **`claude35sonnet`**: Anthropic Claude 3.5 Sonnet advanced comprehension.

#### 5. 🔍 Instant Autocomplete & Search Suggestions (`SUGGEST`)

Switch `mode` to `SUGGEST` to get sub-100ms keyword autocomplete and live navigation suggestions for search bars and input widgets.

***

### 📥 Input Parameters & Schema

| Parameter | Type | Required | Default | Options / Valid Values | Description |
| :--- | :---: | :---: | :---: | :--- | :--- |
| `mode` | `string` | No | `AI_SEARCH` | `AI_SEARCH`, `SUGGEST` | **Primary Operation Mode**: Full AI search & reasoning or instant keyword autocomplete. |
| `query` | `string` | **Yes** | — | Any search query or prompt | The question or research prompt to search and answer. |
| `focus` | `string` | No | `internet` | `internet`, `academic`, `writing`, `youtube`, `reddit` | Target domain or knowledge base for search indexing. |
| `model` | `string` | No | `turbo` | `turbo`, `sonar`, `gpt4o`, `claude35sonnet` | Preferred AI reasoning model. |
| `context_uuid` | `string` | No | `null` | UUID string (e.g. `3b180c85-...`) | Pass previous context\_uuid to continue the conversation in the same thread. |

***

### 📥 Input Examples

#### Example 1: Basic AI Web Search & Citations

```json
{
  "mode": "AI_SEARCH",
  "query": "What is Quantum Computing? Explain briefly.",
  "focus": "internet",
  "model": "turbo"
}
```

#### Example 2: Academic Paper Research (arXiv / PubMed)

```json
{
  "mode": "AI_SEARCH",
  "query": "Recent breakthroughs in room-temperature superconductors",
  "focus": "academic",
  "model": "sonar"
}
```

#### Example 3: Multi-Turn Conversational Follow-Up (Same Thread)

```json
{
  "mode": "AI_SEARCH",
  "query": "What are the primary applications in cryptography?",
  "context_uuid": "3b180c85-11bf-4e76-9908-0fc0c2ac47cc",
  "model": "turbo"
}
```

#### Example 4: Instant Keyword Autocomplete

```json
{
  "mode": "SUGGEST",
  "query": "Artificial Intelligence"
}
```

***

### 📤 Output Dataset Examples

#### 1. Real-Time AI Search with Live Web Citations:

```json
{
  "mode": "AI_SEARCH_RESULT",
  "success": true,
  "query": "What is Quantum Computing? Explain briefly.",
  "context_uuid": "3b180c85-11bf-4e76-9908-0fc0c2ac47cc",
  "backend_uuid": "7e760172-2526-4dbd-a1c5-9f04b8805f52",
  "is_followup": false,
  "model": "turbo",
  "search_focus": "internet",
  "answer": "Quantum computing is a multidisciplinary field comprising aspects of computer science, physics, and mathematics that utilizes quantum mechanics to solve complex problems faster than classical computers. Rather than using traditional bits (which represent either a 0 or a 1), quantum computers encode information using quantum bits, or qubits, which can exist in a multidimensional state of superposition and entanglement.",
  "sources_count": 8,
  "sources": [
    {
      "title": "Quantum Computing Fundamentals - IBM Research",
      "url": "https://www.ibm.com/quantum/what-is-quantum-computing",
      "snippet": "Quantum computing is a rapidly-emerging technology that harnesses the laws of quantum mechanics to solve problems too complex for classical computers.",
      "trust_level": 2,
      "trust_description": "High authority technological source"
    },
    {
      "title": "What is Quantum Computing? - MIT Technology Review",
      "url": "https://www.technologyreview.com/topic/quantum-computing/",
      "snippet": "An introduction to quantum systems, qubits, and quantum supremacy.",
      "trust_level": 3,
      "trust_description": "Top-tier academic & technology publication"
    }
  ],
  "related_queries_count": 3,
  "related_queries": [
    "How do quantum computers differ from classical computers?",
    "What are the practical applications of quantum computing in 2026?",
    "What are the leading quantum computing companies?"
  ]
}
```

***

### 💻 Multi-Language Code Integration Suite

#### Python (`apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "mode": "AI_SEARCH",
    "query": "What are the key advancements in AI models in 2026?",
    "focus": "internet",
    "model": "turbo"
}

## Run the Actor and wait for it to finish
run = client.actor("dev00/perplexity-ai-search-api").call(run_input=run_input)

## Fetch and print Actor results from the run's dataset
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"Answer:\n{item['answer']}\n")
    print(f"Citations Count: {item['sources_count']}")
    for s in item['sources']:
        print(f" - [{s['title']}]({s['url']})")
```

#### JavaScript / Node.js (`apify-client`):

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
    token: 'YOUR_APIFY_TOKEN',
});

const input = {
    mode: "AI_SEARCH",
    query: "Compare Vector Databases: Pinecone vs Milvus vs Qdrant",
    focus: "internet",
    model: "claude35sonnet"
};

const run = await client.actor("dev00/perplexity-ai-search-api").call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log("AI Answer:", items[0].answer);
console.log("Sources:", items[0].sources);
```

***

### 💰 Pay-Per-Event (PPR) Pricing

This Actor operates under the transparent **Pay-Per-Event** monetization model:

- **Price**: **$0.003 per AI search query / conversation turn** ($3.00 per 1,000 queries).
- **No Monthly Minimums**: Only pay for the exact volume of AI searches you execute.
- **Includes Multi-Turn Thread Memory**: Zero additional charge for continuing conversation threads via `context_uuid`.

***

### 🎯 High-Growth Industry Use Cases

1. **AI Agents & Autonomous Research Assistants**: Connect directly to AI agent frameworks (LangChain, LlamaIndex, AutoGPT, CrewAI) for real-time web verification and live citation synthesis.
2. **Customer Support & Conversational Chatbots**: Power customer-facing chatbots with up-to-date product knowledge and conversational thread memory (`context_uuid`).
3. **Academic & Technical Research Tools**: Search across scholarly papers (arXiv, PubMed) and summarize dense peer-reviewed literature.
4. **Market Sentiment & Reddit Opinion Mining**: Extract real consumer feedback, product reviews, and community sentiment using the `focus="reddit"` mode.
5. **Video Intelligence & Lecture Extraction**: Pull summarized insights and timestamps from YouTube video transcripts using `focus="youtube"`.

***

### ❓ Frequently Asked Questions (FAQ)

##### Q: How does conversational thread memory work?

When you run the Actor, the output includes a `context_uuid`. Simply pass this `context_uuid` into your subsequent Actor runs, and the engine automatically links the conversation context together (`is_followup: true`).

##### Q: How does this differ from standard LLMs like ChatGPT?

Standard LLMs suffer from fixed training cutoff dates and lack citations. This Actor performs live web queries in real-time and returns structured citations with URLs, snippets, and trust scores.

##### Q: What are the differences between the Search Focus modes?

- `internet`: General global web pages.
- `academic`: Scholarly articles, arXiv, PubMed, and journals.
- `writing`: Direct text/code generation without web search.
- `youtube`: Video transcripts and timestamps.
- `reddit`: User discussions and community sentiment on Reddit.

***

### 🏷️ Keywords & SEO Tags

`perplexity ai api, perplexity scraper, ai search api, real time web citations, live web search api, conversational ai api, multi turn chat memory, claude 3.5 sonnet api, gpt 4o web search, academic paper search api, reddit discussions scraper, youtube transcript search, automated ai research, llm web search gateway, tavily alternative, exa alternative, brave search alternative, serper alternative, perplexity actor, apify perplexity scraper, rag search api, ai citations generator, live facts verification api, web reasoning api, deep research scraper`

# Actor input Schema

## `mode` (type: `string`):

Select the primary operational mode: Real-time AI Web Search & Multi-Turn Chat or Instant Keyword Autocomplete.

## `query` (type: `string`):

Enter any search question, research query, or conversation prompt.

## `focus` (type: `string`):

Filter search across specific domain sources.

## `model` (type: `string`):

Select AI model preference for reasoning and synthesis.

## `context_uuid` (type: `string`):

Pass context\_uuid from a previous response to continue chatting seamlessly in the exact same conversation thread.

## Actor input object example

```json
{
  "mode": "AI_SEARCH",
  "query": "What is Quantum Computing? Explain briefly.",
  "focus": "internet",
  "model": "turbo"
}
```

# Actor output Schema

## `results` (type: `string`):

Direct link to the dataset items containing AI answers and citations

## `keyValueStoreResult` (type: `string`):

Direct link to the key-value store output record

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "query": "What is Quantum Computing? Explain briefly."
};

// Run the Actor and wait for it to finish
const run = await client.actor("dev00/perplexity-ai-search-api").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "query": "What is Quantum Computing? Explain briefly." }

# Run the Actor and wait for it to finish
run = client.actor("dev00/perplexity-ai-search-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "What is Quantum Computing? Explain briefly."
}' |
apify call dev00/perplexity-ai-search-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dev00/perplexity-ai-search-api"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/RH9G9OgzGFa64nH2A/builds/1Ophec20iCm3NkBlw/openapi.json