Skip to content
Dev ResourcesChecked against both vendors' docs, November 15, 2026

Search Feeds for Agents: Perplexity's Search API and Exa Monitors Instead of Scraping

Two ways to give an agent fresh web results without scraping a results page. Perplexity's Search API answers when you ask, from $1 per 1,000 requests. Exa Monitors v2 runs a search on a schedule and calls your webhook with only what is new, at $2 per 1,000 runs. The requests, the webhook check, and the arithmetic for a small product, from both vendors' docs.

Ask when you need it · or get called when it changes
Two search feeds an agent can use without scraping a results page.
AI AgentsSearch APIPerplexityExaWebhooksWeb SearchAutomationMonitoringTutorial
Cost
From $1 per 1,000 requests (Perplexity) or $2 per 1,000 runs (Exa)
Time
~40 min
Steps
6
Stack
Perplexity Search API · Exa Monitors v2 · a webhook endpoint
What you'll get
  • ✓When an agent should pull search results and when it should be pushed them
  • ✓The Perplexity Search API request, its filters, and what comes back
  • ✓How Perplexity bills: per request, with up to five queries in one
  • ✓An Exa monitor that runs on a schedule and posts only new results to your webhook
  • ✓The signature check for that webhook, and a JSON schema for the output
  • ✓Monthly cost for three small setups, worked out
Share

An agent that watches the web for you needs search results it can read. The usual first attempt is to drive a browser to a results page and parse it, which breaks on the next layout change and gets blocked on the one after. Two APIs now do the same job for a dollar or two per thousand calls: Perplexity opened its search index as a Search API, and Exa cut Monitors, its scheduled search, from $15 to $2 per 1,000 runs on October 29, 2026.

They solve different halves of the problem. This guide shows the request for each, the webhook on the Exa side, and what a small setup costs in a month.

What was run for this guide, and what was not
Nothing was run. There was no Perplexity or Exa API key on the machine this was written on, so every request, response shape and price below is taken from Perplexity's and Exa's own docs as read on November 15, 2026, and each step is marked "From the docs, not run here". The cost table is arithmetic on the published prices. Run the first request yourself before you build on it.
Step 1 of 6
3 min

Pick pull or push

At a glance
Pull
Perplexity Search API
Push
Exa Monitors v2
Rule
Who starts the search?

The choice is about who starts the search:

  • Pull. The agent is in the middle of a task and needs results now: check a claim, find the source of a number, look up a competitor's pricing page. That is a search API call. You get ranked results with page text, and no generated answer.
  • Push. You want to know when something appears: a new mention of your product, a competitor's launch, a thread asking for a tool like yours. That is a monitor. It runs the same search on a schedule, remembers what it already sent, and calls your webhook with only what is new.

You can fake push with pull: run the search hourly and keep your own list of URLs you have seen. That works, and it is what a monitor replaces. Step 6 has the cost of each.

Step 2 of 6
8 min

Pull: one request to Perplexity's Search API

At a glance
Endpoint
POST api.perplexity.ai/search
Auth
Bearer key
Returns
Ranked results, no answer

From the docs, not run here

One POST with a bearer key. Keep the key in an environment variable:

Terminal
curl -X POST 'https://api.perplexity.ai/search' \
  -H "Authorization: Bearer $PERPLEXITY_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "query": "launch platforms for indie products",
    "max_results": 5,
    "search_type": "fast",
    "search_domain_filter": ["-reddit.com"]
  }' | jq

The request fields, from the quickstart:

FieldWhat it takes
queryA string, or an array of up to 5 strings. Each one is searched on its own
max_results1 to 20, default 10
search_type"fast" for lower latency and the lower price
search_domain_filterUp to 20 domains. Allow ("science.org") or deny ("-reddit.com"), not both in one request
search_language_filterUp to 20 ISO 639-1 codes, such as "en"
countryAn ISO 3166-1 alpha-2 code, such as "US"

What comes back:

Response
{
  "id": "...",
  "results": [
    {
      "title": "...",
      "url": "https://...",
      "snippet": "page text, may be empty",
      "date": "2026-11-12",
      "last_updated": null
    }
  ]
}

The snippet is text from the page, and it can be empty. date and last_updated can be null, so do not sort on them without a fallback.

This is not the Agent API
Fields such as model, instructions, tools and max_output_tokens belong to Perplexity's Agent API and are not valid in a Search request. If you want Perplexity to search and write the answer, that is a different endpoint with a different price.
Step 3 of 6
5 min

Batch queries and choose a search type

At a glance
Standard
$5 per 1,000 requests
Fast
$1 per 1,000 requests
Per request
Up to 5 queries

From the docs, not run here

Three rules on Perplexity's pricing page decide what you pay:

  • You are billed per successful request, not per query. An array of up to five queries in one request is one billing unit.
  • Fast Search is a fifth of the price. "search_type": "fast" is $1 per 1,000 requests against $5 for standard. There are no token charges on top of either.
  • Failed requests are free. Invalid, rate-limited and failed requests are not billed.

So five related searches go in one body:

Request body
{
  "query": [
    "\"Nick Launches\" review",
    "product hunt alternatives 2026",
    "free startup directories dofollow",
    "where to launch a SaaS for free",
    "launch platform for indie builders"
  ],
  "max_results": 5,
  "search_type": "fast"
}
Batching saves money, not rate limit
A five-query request is one billing unit, but the quickstart says rate limiting counts each query, so it uses five rate-limit units. Batching cuts the bill by up to five times. It does not let you send five times as many searches per minute.

Perplexity's docs describe Fast Search only as lower latency and lower cost. They do not publish how its results differ from standard. Run both on five of your own queries and compare before you switch a production agent to the cheap one.

Step 4 of 6
8 min

Push: create an Exa monitor

At a glance
Endpoint
POST api.exa.ai/monitors
Shortest interval
1 hour
Price
$2 per 1,000 runs

From the docs, not run here

A monitor is a search, a schedule and a webhook. Exa describes each run as three stages: retrieve (a search of its index over a time window matched to the schedule), judge (drop pages it has already seen, then check what is left for relevance, source legitimacy, new information and event timing), and compose (a short summary, or JSON in a shape you define).

Terminal
curl -s -X POST "https://api.exa.ai/monitors" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $EXA_API_KEY" \
  -d '{
    "name": "Mentions of my product",
    "search": {
      "query": "new articles, lists or forum threads that mention Nick Launches",
      "numResults": 10,
      "excludeDomains": ["nicklaunches.com"]
    },
    "trigger": { "type": "interval", "period": "1d" },
    "metadata": { "product": "nicklaunches" },
    "webhook": {
      "url": "https://example.com/webhooks/exa",
      "events": ["monitor.run.completed"]
    }
  }'
  • search takes query, numResults, includeDomains or excludeDomains, and contents. The quickstart says no other Search options are accepted.
  • trigger.period is one duration: 1h, 6h, 1d or 7d are the examples given, and the minimum is one hour. Leave trigger out for a monitor you only run by hand.
  • metadata is echoed back in every webhook delivery, which is how you route a result to the right product or user.
  • webhook.url must be HTTPS, and redirects are not followed.

You do not have to wait a day to see whether it works:

Terminal
# Run it now instead of waiting for the schedule
curl -s -X POST "https://api.exa.ai/monitors/$MONITOR_ID/trigger" \
  -H "Authorization: Bearer $EXA_API_KEY"

# Read the runs
curl -s "https://api.exa.ai/monitors/$MONITOR_ID/runs?limit=5" \
  -H "Authorization: Bearer $EXA_API_KEY"

A run moves through pending, running, then completed, failed or cancelled. output is null until it completes.

Write the query as a description, not keywords
The judge stage decides what counts as new and relevant from your query, so say what you want to be told about: "new articles, lists or forum threads that mention Nick Launches" gives it more to judge with than the product name alone.
Step 5 of 6
10 min

Receive the webhook and check its signature

At a glance
Event
monitor.run.completed
Header
Exa-Signature
Check
HMAC-SHA256

From the docs, not run here

Each delivery is an event with id, type, createdAt and a data object: the run id, monitorId, status, output (with results, content and grounding), failReason and your metadata. If you leave events out of the monitor, you also get lifecycle and run-created events, so name the one you want.

Anyone can POST to a public URL, so check that the call came from Exa before your agent acts on it. The header has the form t=<timestamp>,v1=<signature>, and the signature is an HMAC-SHA256 over the timestamp, a dot, and the raw request body, keyed with the monitor's webhookSecret:

verify-exa.mjs
import { createHmac, timingSafeEqual } from "node:crypto";

// Exa-Signature: t=<timestamp>,v1=<signature>
// The signature is an HMAC-SHA256 over "<timestamp>.<raw request body>",
// keyed with the monitor's webhookSecret.
export function isFromExa(rawBody, header, webhookSecret) {
    const parts = Object.fromEntries(header.split(",").map((p) => p.split("=")));
    if (!parts.t || !parts.v1) return false;

    // Hex output is an assumption: the quickstart does not show the encoding.
    const expected = createHmac("sha256", webhookSecret).update(`${parts.t}.${rawBody}`).digest("hex");

    const a = Buffer.from(expected);
    const b = Buffer.from(parts.v1);
    return a.length === b.length && timingSafeEqual(a, b);
}

// In the handler: read the RAW body before any JSON parsing.
// const raw = await request.text();
// if (!isFromExa(raw, request.headers.get("exa-signature") ?? "", process.env.EXA_WEBHOOK_SECRET)) {
//     return new Response("bad signature", { status: 401 });
// }
// const event = JSON.parse(raw);
// if (event.type === "monitor.run.completed") { /* event.data.output */ }
Two things that break signature checks
Verify against the raw body, before your framework parses and re-serializes the JSON, or the bytes will not match. And the code above assumes a hex digest, which the quickstart does not state: if the first real delivery fails the check, compare against a base64 digest before you suspect the secret.

What the agent does next is yours to decide. A safe first version writes the new results to a table and sends you a message. Let it post or reply on its own only after you have read a week of what it would have done.

Step 6 of 6
6 min

Ask for JSON, then do the arithmetic

At a glance
Default output
Text summary
With a schema
Your JSON shape
Sources
output.grounding

From the docs, not run here

Without a schema, a run returns a text summary in output.content. Add an outputSchema to the monitor and it returns JSON in your shape, which is easier for an agent to act on than prose:

Monitor field
"outputSchema": {
  "type": "object",
  "properties": {
    "mentions": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "site": { "type": "string" },
          "url": { "type": "string" },
          "what_it_says": { "type": "string" }
        }
      }
    }
  },
  "required": ["mentions"]
}

Citations and confidence are not part of your schema. Exa returns them separately in output.grounding, so keep that next to the JSON when you store a run.

What four small setups cost in a 30-day month, on the published prices:

SetupArithmeticPer month
Perplexity, fast: 10 queries every hour, batched 5 per request2 requests × 24 × 30 = 1,440 requests at $1 per 1,000$1.44
Perplexity, standard: the same 1,440 requests1,440 at $5 per 1,000$7.20
Exa: 10 monitors, once a day10 × 30 = 300 runs at $2 per 1,000$0.60
Exa: 10 monitors, every hour10 × 24 × 30 = 7,200 runs at $2 per 1,000$14.40
The price is not the whole comparison
Hourly polling through Perplexity is cheaper per call than an hourly Exa monitor, but you then own the list of seen URLs, the "is this actually new" judgment and the summary, which usually means a model call per batch. A daily monitor at 60 cents a month for ten topics does that part for you. Poll when you need the raw results. Monitor when you only want to hear about changes.

Which one for which job

  • Research inside a task (verify a price, find a source): Perplexity Search API, fast search type, batched.
  • Brand and competitor mentions: an Exa monitor per topic, once a day, with a schema.
  • Lead threads ("looking for a tool that..."): an Exa monitor every hour or six, with includeDomains for the forums you care about.
  • A site that blocks crawlers: neither will read it for you. Both search an index, and a page that is not in the index is not in the results.

From the docs, not run here

All of it. In particular, these are stated by the vendors and not checked here:

  • Latency of either API, and how Fast Search results differ from standard
  • How well Exa's judge stage filters repeats on a real topic over several weeks
  • The digest encoding of the Exa webhook signature
  • Rate limits and usage tiers on either side, which both vendors document on separate pages
  • Free credits for new accounts, which neither pricing page mentioned

Sources

Disclaimer: Nick Launches is not affiliated with Perplexity or Exa. Read on November 15, 2026; prices and fields change. No request was sent for this guide, and the monthly figures are arithmetic on the published prices, not a bill.

Share

Get the weekly recap

New dev-resource guides, top launches, and what's worth a look. One email a week.