Perplexity on DNotifier: Setup Guide

Part of a series on running AI workflows across model providers — this one's about the provider built around live search, not just another language model.

Most of the providers in this series are model vendors first — you're picking a language model and hoping it knows enough about the world to answer well. Perplexity flips that. It's built around a live search layer, and the model sits on top of it. When you connect Perplexity to DNotifier, you're not just adding another model option to a dropdown — you're adding the one path in your stack that can answer questions about this morning's news.

That distinction matters for how you'll actually use it, so it's worth understanding before you touch the setup screen.

What you're actually connecting

Perplexity's API is built around a family of "Sonar" models, and every one of them does something the other providers in this series generally don't do by default: it runs real web searches as part of generating the answer, then cites where the information came from. Ask GPT or Claude a question and you get an answer shaped by training data. Ask Perplexity and you get an answer shaped by training data plus whatever it just found on the live web, with sources attached.

DNotifier's own documentation describes it plainly: Perplexity is "the one you reach for when the answer should lean on current web context." That's a useful mental model. It's not a general-purpose replacement for your other connected providers — it's the one you route to specifically when freshness and sourcing matter more than raw reasoning depth.

Step 1: Connect Perplexity in the DNotifier portal

In the dashboard: Projects → AI Studio → Providers → Perplexity. Enter your Perplexity API key (or use DNotifier's subscription billing if you'd rather not manage a separate key), save, and the provider is live.

This is the same lightweight setup as OpenAI, Anthropic, Gemini, and Hugging Face — no AWS-style IAM roles, no account-boundary configuration. If you've connected any other provider in this series already, this will feel familiar.

Perplexity sits differently in your stack than a pure model provider — the search step happens before the model ever writes a word.

Step 2: Install the SDK

npm install @dnotifier-realtime/dnotifier

Step 3: Make your first search-grounded call

const notifier = new DNotifier({ apiKey: process.env.DNOTIFIER_API_KEY });

const response = await notifier.sendAI({
  senderId: USER_ID,
  provider: "perplexity",
  model: "sonar-pro",
  message: {
    messages: [
      { role: "user", content: "What are the latest updates to the EU AI Act enforcement timeline? Mention sources." }
    ]
  },
  saveHistory: true,
});

Notice the explicit "Mention sources" instruction. Perplexity can return citations, but asking for them directly in your prompt makes the behavior more consistent — worth building into any system prompt where sourcing matters to your users.

A pattern worth knowing: research, then write

DNotifier's documentation highlights a specific two-step pattern that's worth adopting directly: use Perplexity to gather current, sourced information, then hand that output to a second agent — often Claude or GPT — to refine it into final, polished output. Perplexity is genuinely good at "what's true and current right now," and noticeably less optimized for "write this in our brand voice." Splitting those two jobs across two providers plays to each one's strength instead of asking one model to be excellent at both.

const researchAgent = DNotifier.defineAgent({
  name: "researchAgent",
  provider: "perplexity",
  model: "sonar-pro",
  async run(ctx) {
    return await ctx.sendAI({
      message: { messages: [{ role: "user", content: `Research: ${ctx.input}. Mention sources.` }] },
    });
  },
});

const writerAgent = DNotifier.defineAgent({
  name: "writerAgent",
  provider: "anthropic",
  model: "claude-sonnet-4-5",
  async run(ctx) {
    return await ctx.sendAI({
      message: { messages: [{ role: "user", content: `Turn this research into a clear, well-organized summary for our team: ${ctx.state.research}` }] },
    });
  },
});

A workflow chaining these two agents, with ctx.state carrying the research output forward, gives you current facts and polished delivery from a single request — without either model doing a job it's not built for.

Two agents, two jobs: one finds and sources the facts, the other shapes them into something people actually want to read.

A use case that shows why this matters

A compliance team at a mid-sized fintech company was fielding recurring internal questions like "did anything change with this regulation this month?" Their existing assistant, built on a single general-purpose model, gave confident-sounding answers that were sometimes six months out of date — the model simply didn't know about a rule change from three weeks ago. Routing that specific question type through a Perplexity research step first, then a writing step second, fixed the staleness problem without touching anything else in their workflow. The rest of their assistant's answers — the ones that didn't depend on current events — kept using their existing provider unchanged.

One thing to flag now, before it matters

Perplexity is in the middle of retiring its Sonar chat-completions API in favor of a new Agent API — full details in the next two articles in this series. As of today, the model string above (sonar-pro) is current and working. If you're setting this up close to or after the transition date, check DNotifier's AI Studio provider settings for the current supported model list before assuming this exact code snippet still applies unchanged.

Frequently asked questions

Does DNotifier support all four Sonar models?

DNotifier's documentation shows sonar and sonar-pro as the models used in its own examples. Check your AI Studio provider settings for the full current list, since Perplexity's own model lineup is actively changing (see the next two articles).

Can I use Perplexity alongside my other connected providers?

Yes — this is true of every provider in this series. A single Workflow can route one step to Perplexity for current-events grounding and another step to any other connected provider for everything else.

Do I need to ask for citations, or are they automatic?

Citations can come back automatically, but explicitly prompting for them ("mention sources," "cite where this came from") produces more consistent results. Build that instruction into your system prompt rather than relying on default behavior.

Is Perplexity a replacement for DNotifier's built-in knowledge base?

No, and it's a genuinely different tool for a genuinely different job — Perplexity searches the live public web, DNotifier's knowledge base searches documents you've uploaded. Live Citations vs. Your Own RAG covers exactly when to reach for which.

The Bottom Line

Next in this series: what actually makes Perplexity a different kind of provider than everything else in this batch, and why "search-grounded" is a meaningfully different pitch than "another model API."

Read part two: What Makes Perplexity Different?. Explore dnotifier.com.