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.
Pick pull or push
- 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.
Pull: one request to Perplexity's Search API
- 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:
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"]
}' | jqThe request fields, from the quickstart:
| Field | What it takes |
|---|---|
| query | A string, or an array of up to 5 strings. Each one is searched on its own |
| max_results | 1 to 20, default 10 |
| search_type | "fast" for lower latency and the lower price |
| search_domain_filter | Up to 20 domains. Allow ("science.org") or deny ("-reddit.com"), not both in one request |
| search_language_filter | Up to 20 ISO 639-1 codes, such as "en" |
| country | An ISO 3166-1 alpha-2 code, such as "US" |
What comes back:
{
"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.
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.Batch queries and choose a search type
- 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:
{
"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"
}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.
Push: create an Exa monitor
- 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).
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"]
}
}'searchtakesquery,numResults,includeDomainsorexcludeDomains, andcontents. The quickstart says no other Search options are accepted.trigger.periodis one duration:1h,6h,1dor7dare the examples given, and the minimum is one hour. Leavetriggerout for a monitor you only run by hand.metadatais echoed back in every webhook delivery, which is how you route a result to the right product or user.webhook.urlmust be HTTPS, and redirects are not followed.
You do not have to wait a day to see whether it works:
# 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.
Receive the webhook and check its signature
- 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:
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 */ }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.
Ask for JSON, then do the arithmetic
- 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:
"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:
| Setup | Arithmetic | Per month |
|---|---|---|
| Perplexity, fast: 10 queries every hour, batched 5 per request | 2 requests × 24 × 30 = 1,440 requests at $1 per 1,000 | $1.44 |
| Perplexity, standard: the same 1,440 requests | 1,440 at $5 per 1,000 | $7.20 |
| Exa: 10 monitors, once a day | 10 × 30 = 300 runs at $2 per 1,000 | $0.60 |
| Exa: 10 monitors, every hour | 10 × 24 × 30 = 7,200 runs at $2 per 1,000 | $14.40 |
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
includeDomainsfor 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
- Perplexity, Search API quickstart and Pricing
- Exa, Introducing Monitors v2, October 29, 2026
- Exa, Monitors quickstart
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.