# AI Chat Endpoint: See Geotargeted LLM Answers and Sources


Massive's AI chat endpoint returns the answer ChatGPT, Gemini, or Perplexity gives to a prompt, as asked from a real device in the country, region, or city you pick. One `GET` request returns the completion, the sources the model cited, and, for ChatGPT, the search queries it ran to build the answer.

That matters because AI answers are no longer a niche channel. About half of U.S. adults now use AI chatbots, and about four in ten use them to search for information, according to [Pew Research Center's 2026 survey](https://www.pewresearch.org/internet/2026/06/17/americans-and-ai-2026-chatbots-smart-devices-and-views-on-impact/) of 5,119 adults. If a growing share of lookups end in a chatbot, teams need a reliable way to see what that chatbot says.

> **Key Takeaways**
>
> - The AI chat endpoint (`/ai`) is one of three endpoints in Massive's Web Render API, next to [Browsing](https://docs.joinmassive.com/web-render/browser) and [Search](https://docs.joinmassive.com/web-render/search).
> - Three models: ChatGPT (the default), Gemini, and Perplexity.
> - Responses include the completion, its sources, any ads, and, for ChatGPT, the `fanouts` array of queries the model searched.
> - Geotargeting goes down to the city, because chatbots localize their answers to where the asker appears to be.
> - Async mode plus callbacks handles large batches.

## What the AI chat endpoint returns

The AI chat endpoint lives at `https://render.joinmassive.com/ai` and accepts a prompt of up to 2,047 characters. You choose the model with `model=chatgpt`, `model=gemini`, or `model=perplexity`, and the location with any combination of `country`, `subdivision`, and `city`. Output comes back as structured `json` (the default) or as `rendered` HTML.

The JSON response splits the conversation into parts you can parse separately:

| Field | What it holds | Models |
|-------|---------------|--------|
| `completion` | Rendered HTML of the model's answer | ChatGPT, Gemini, Perplexity |
| `sources` | Rendered HTML of the cited sources, if any | ChatGPT, Gemini, Perplexity |
| `ads` | Rendered HTML of any ads shown in the conversation | ChatGPT, Gemini, Perplexity |
| `html` | The full conversation page | ChatGPT, Gemini, Perplexity |
| `fanouts` | Array of the search queries the model ran | ChatGPT only |
| `sse` | Server-sent events JSON behind the conversation | ChatGPT only |

Every response also echoes back the `country`, `subdivision`, `city`, and `device` it ran with. That makes each row self-describing when you store thousands of them. The full field list is in the [AI chat docs](https://docs.joinmassive.com/web-render/ai).

## A worked example: one prompt from Portland

Here is the request the Massive docs use to show the endpoint. It asks ChatGPT for basketball shoe recommendations from a device in Portland:

```shell
curl -H "Authorization: Bearer $MASSIVE_TOKEN" \
'https://render.joinmassive.com/ai'\
'?prompt=best+basketball+shoes+for+2026'\
'&country=us'\
'&city=Portland'
```

The documented response includes the answer and sources as HTML, plus this `fanouts` array:

```json
"fanouts": [
  "best basketball shoes 2026",
  "top rated basketball shoes 2026 reviews",
  "best performance basketball shoes 2026",
  "best basketball shoes for guards 2026",
  "best basketball shoes for wide feet 2026",
  "best outdoor basketball shoes 2026",
  "most popular basketball shoes 2026"
]
```

Read that list as a brand team would. The model did not only search the question it was asked. It split the question into seven narrower searches, including guards, wide feet, and outdoor courts. A shoe brand that never ranks for "wide feet" has no chance of being cited in that slice of the answer, however strong its general page is.

## Why do AI chat answers change by location?

Chatbots localize. OpenAI's own [ChatGPT search help article](https://help.openai.com/en/articles/9237897-chatgpt-search) says ChatGPT may estimate a user's general location from their IP address. It can then rewrite a prompt like "good restaurants near me" into a search for restaurants in that city.

The effect shows up beyond local queries. A study by Whitebox, [reported by Ynetnews](https://www.ynetnews.com/tech-and-digital/article/skilyoscwx), sent identical prompts to ChatGPT from Israel, the United States, Turkey, and Spain. It found "broadly similar but not identical answers," with the model adapting tone and framing to the user's location and language. (Whitebox tracks how brands and countries appear in AI answers, so location effects are central to its own business.)

We have seen the same thing in our own testing. In a June 2026 study run through this endpoint, we sent 270 localized queries to ChatGPT, Gemini, and Copilot from five countries. (The endpoint's current models are ChatGPT, Gemini, and Perplexity.) Gemini refused gambling questions asked from UK and German locations while answering them freely elsewhere. A brand's rank moved by up to two places depending only on which assistant we asked. The full results are in [AI Brand Visibility: AI Plays Favorites, It Won't Trash You](https://www.joinmassive.com/blog/ai-brand-visibility-ai-plays-favorites-it-wont-trash-you).

In other words: one answer checked from one office is a sample of one.

Massive routes each prompt through a real consumer device on its [residential network](https://docs.joinmassive.com/residential/introduction), which spans 195+ countries. The chatbot sees an ordinary local user, not a data center. Leave `country` unset and the docs note that a random country is used, so set it on every request you plan to compare over time.

You can also emulate a phone or tablet. Call the `/ai/devices` resource for the list of supported device names, then pass one as `device`. Without it, you get the default desktop completion.

## Fanouts: how ChatGPT built its answer

Fanouts are the part of the response we'd point a new user to first. A completion shows you the answer. Fanouts show you the research path behind it.

That is useful in three concrete ways:

1. **Content gaps.** Each fanout is a query you rank for or you don't.
2. **Model evaluation.** If you grade an LLM's answers, fanouts separate two failure modes that look identical in the completion: the model reasoned badly over good results, or it searched for the wrong thing and never saw the good results at all.
3. **Change tracking.** Fanouts can change between runs, so last month's list may not be this month's brief.

A simple way to put the third use to work:

- Pick 20 to 50 prompts your buyers actually ask, and fix the `country` and `city` for each.
- Run them weekly with `expiration=0` so no cached answer hides a change.
- Save each run's `fanouts` array, then compare it to last week's as a set: new queries, dropped queries, unchanged.
- Treat a new fanout as a content question. Do you have a page that answers it?

Because fanouts are plain strings, that comparison is a few lines of code in any language. No HTML parsing required.

One limit to plan around: the docs mark `fanouts` and `sse` as ChatGPT only, and note that only some models expose these queries. For Gemini and Perplexity you still get the completion, sources, and ads, but not the search path.

## Running AI chat prompts at scale

Live completions average several seconds, per the docs. The endpoint allows up to 3 minutes per call because some conversations need retries. For one-off checks, the default sync mode is fine. For monitoring hundreds or thousands of prompts, use async.

Add `mode=async` and the API returns a job ID right away. Pass that ID back with `GET /ai?id=...` to collect the completion, or get a `retrieving` or `failed` status. Instead of polling, you can set `callback` to an HTTPS URL or an Amazon SQS queue, and Massive notifies it when the completion is ready. The [scheduling docs](https://docs.joinmassive.com/web-render/scheduling) cover both patterns.

Caching needs one decision. By default, a completion is cached for one day. Set `expiration=0`, as in the tracking recipe above, whenever a cached answer could hide a change.

## Who uses the AI chat endpoint

Massive doesn't build AI brand-monitoring dashboards. The AI chat endpoint is the infrastructure layer underneath them. Generative engine optimization (GEO) and answer engine optimization (AEO) platforms need geo coverage, device emulation, and clean source and fanout data before they can build analytics. Massive handles that layer so their teams can spend time on the analysis their customers pay for.

A fair question for any of those platforms is whether an API answer matches what a person sees in the app. We tested it: across 30 brand categories, `/ai` with `model=gemini` produced a statistically indistinguishable brand ranking from the signed-in Gemini app on 26 of 30 topics, about as consistent as the app is with itself run to run. Method and caveats are in [Are API-Based AI Calls a Good Proxy for What Your Users Actually See?](https://www.joinmassive.com/blog/are-api-based-ai-calls-a-good-proxy-for-what-your-users-actually-see)

Two other groups use the same data:

- **LLM evaluation teams**, who need the live answer a model gives today, not a cached snapshot, as the thing being graded.
- **RAG and agent builders**, who compare what a frontier model says against their own pipeline's output. Our guide to [LLM grounding with live web data](https://www.joinmassive.com/blog/llm-grounding-with-live-web-data-a-practical-guide) covers that pattern, and [how to give AI agents live web access](https://www.joinmassive.com/blog/how-to-give-ai-agents-live-web-access) covers the Browsing and Search side.

For the wider market shift behind this demand, see our [State of the Web Data Industry report](https://www.joinmassive.com/blog/state-of-the-web-data-industry-2026).

## Frequently Asked Questions

### Which models does the AI chat endpoint support?

ChatGPT, Gemini, and Perplexity. ChatGPT is the default when you don't pass a `model` parameter.

### What are fanouts in the AI chat endpoint?

Fanouts are the search queries ChatGPT ran to build its answer, returned as an array in the JSON response. They are available for ChatGPT only.

### Can I see what an AI chatbot says in a specific city?

Yes. Set `country`, and optionally `subdivision` and `city`, on the request. The prompt is sent from a real consumer device in that location, so the chatbot localizes its answer as it would for a local user.

### Does Massive replace an AEO or AI brand-monitoring platform?

No. Massive supplies the request infrastructure: locations, devices, and structured completions, sources, and fanouts. AEO platforms build their dashboards and analysis on top of it.

### How do I run thousands of AI chat prompts without holding connections open?

Use `mode=async` to queue each prompt and collect results by job ID, or set `callback` to an HTTPS URL or Amazon SQS queue to be notified when each completion is ready.

## The takeaway

What ChatGPT, Gemini, or Perplexity says about your brand depends on who asks and from where. With `/ai` you can ask from any city on a real device and keep the full record: answer, sources, ads, and, for ChatGPT, every search the model ran. Start with the [AI chat docs](https://docs.joinmassive.com/web-render/ai). Massive's security and compliance record is on the [Massive Trust Center](https://trust.joinmassive.com), and more about the team is on our [about page](https://www.joinmassive.com/about-us).