Node.js AI Visibility API

Query the raw answers ChatGPT, Perplexity, Google AI Overviews, Google AI Mode, Copilot and Gemini actually return — from Node.js, with the fetch that ships in the runtime. No Puppeteer, no browser pool, no dependency to install: one POST, and the answer text, citations and sources arrive as clean JSON your code can act on.

Call the AI Visibility API from Node.js

POST to https://api.agentgeo.org/v1/fetches with your ag_live_ key as a bearer token and the engines you want in the surfaces array. Node 20+ ships fetch natively, so the entire integration is standard library — no axios, no SDK, no node_modules at all.

// Node 20+ — native fetch, zero dependencies. Run as ESM for top-level await.
const resp = await fetch("https://api.agentgeo.org/v1/fetches", {
  method: "POST",
  headers: {
    "Authorization": "Bearer ag_live_your_key_here",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: "best running shoes for flat feet",
    surfaces: ["chatgpt"], // chatgpt | perplexity | gemini | google_ai_overview | copilot
  }),
});
if (!resp.ok) throw new Error(`AgentGEO ${resp.status}: ${await resp.text()}`);
const run = await resp.json();

for (const answer of run.answers) {
  console.log(answer.surfaceKey, "→", answer.answerText);
  for (const src of answer.sources) { // cited sources, in order
    console.log(" ", src.position, src.title, src.url);
  }
}

What comes back is plain JSON — no DOM, no cleanup pass:

{
  "id": "run_84c1f2ab91d3",
  "query": "best running shoes",
  "surfaces": ["chatgpt"],
  "status": "completed",
  "recordsDelivered": 1,
  "creditsCharged": 1,
  "answers": [
    {
      "surfaceKey": "chatgpt",
      "answerText": "For most runners, top picks include ...",
      "sources": [
        { "title": "Best Running Shoes", "url": "https://example.com/guide", "position": 1 }
      ]
    }
  ]
}

Fanning one query across every engine is a Promise.all away — one request per surface key, then print who cites what:

const SURFACES = ["chatgpt", "perplexity", "gemini", "google_ai_overview", "google_ai_mode", "copilot"];

async function fetchAnswers(query, surface) {
  const resp = await fetch("https://api.agentgeo.org/v1/fetches", {
    method: "POST",
    headers: {
      "Authorization": "Bearer ag_live_your_key_here",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ query, surfaces: [surface] }),
  });
  if (!resp.ok) throw new Error(`AgentGEO ${resp.status}`);
  return resp.json();
}

// One query, six engines, in parallel
const runs = await Promise.all(
  SURFACES.map((s) => fetchAnswers("best running shoes for flat feet", s))
);

// Who cites what — the raw material for any share-of-voice metric
for (const run of runs) {
  for (const answer of run.answers) {
    console.log(answer.surfaceKey, "cites:", answer.sources.map((src) => src.url));
  }
}

What the Node.js API gives you

AgentGEO is a thin answer-access layer, not another closed dashboard. The API delivers the raw material; your Node service, worker or cron job (or your users' AI agent) does the analysis.

• Six engines, one contract — ChatGPT, Perplexity, Google AI Overviews, Google AI Mode, Copilot and Gemini behind the same request/response shape, so covering a new engine is one more string in the surfaces array.
• Citations and sources, structured — every answer carries sources[] with title, url and position, ready to store, rank or diff. No cheerio, no regexing links out of markup.
• Managed-scraper engine, maintained for you — answers come through supported access paths, so there is no Chromium to babysit, no stealth plugin to update and no IP ban to recover from at 2 a.m.
• Provider metadata — surfaceKey and providerFields ride along on every response, keeping your dataset auditable as the underlying models change.
• MCP connection, too — the same data is exposed over MCP via the agentgeo-mcp npm package, so Claude Code, Cursor, Codex or any MCP client can pull answers and run the analysis itself.
• Usage-based billing with a spend cap — free tier with no credit card, then subscription plus overage. Priced by usage, never per seat.

Common problems with DIY answer-scraping in Node.js

The default instinct in Node is to reach for Puppeteer or Playwright, drive ChatGPT or Perplexity headlessly, and pull answers out of the DOM. It works in a demo on Tuesday and becomes an ops project by the following sprint.

• Puppeteer/Playwright farms. Every tracked query runs a real Chromium instance — hundreds of MB apiece — so a modest keyword set turns into a browser farm with its own memory graphs, restarts and crash handling.
• Stealth-plugin cat-and-mouse. puppeteer-extra-plugin-stealth works until fingerprinting updates, then you're pinning forks and chasing GitHub issues just to stay logged in — work that ships zero product.
• Selectors break on their deploys, not yours. cheerio and DOM queries bind to hashed, ever-shifting class names; ChatGPT ships a frontend change and your extraction starts returning nulls in production with no failing test.
• Proxy rotation and pool orchestration. Residential proxies, retries, backoff and p-queue concurrency caps across six engines — a distributed-systems side quest bolted onto a marketing metric.
• Headless Chrome doesn't fit serverless. Chromium blows past Lambda's bundle limits, so you maintain @sparticuz/chromium builds and slow cold starts — or give up and run a persistent browser fleet.

Prefer MCP? Same data, no glue code

Everything the REST endpoint returns is also exposed over MCP. If the consumer is an AI agent rather than a Node service — Claude Code, Cursor, Codex or any MCP client — install the agentgeo-mcp package from npm and the agent fetches answers and runs the GEO analysis itself:

claude mcp add agentgeo -- npx -y agentgeo-mcp --key ag_live_your_key_here

Who builds on this

Mostly product engineers adding AI-visibility tracking to an existing SaaS — a nightly worker that fans a keyword set across six engines and writes citations to Postgres is an afternoon of Node — plus agencies white-labeling GEO/AEO reporting for clients. If you evaluated closed dashboards like Profound and wanted the data underneath them, or you were about to scrape ChatGPT yourself, this is the layer to build on.