Six Data Sources Every AI Shopping and Deal-Finding Agent Needs

A tour of the six Serply endpoints that turn a shopping agent from a search wrapper into something that actually finds you a good deal.

Profile picture of Serply
Serply
Six data streams feeding into a single AI shopping agent

Most “AI shopping assistant” demos do one thing: they call a search API, paste the top five links into a prompt, and let the model summarize them. That’s fine for “what’s a good espresso machine,” and it falls apart the moment someone asks “is this actually a good price” or “should I wait for a sale” or “is there one available near me today.”

Answering those questions takes more than search. It takes pricing data, marketplace listings, a timing signal, and sometimes the raw page content itself — because snippets lie by omission. Here are six data sources we’ve found agents actually need, all reachable from Serply’s API, and how they fit together.

1. Google Search — for research, reviews, and “is this even good”

Before an agent recommends a product, it needs context a marketplace listing won’t give you: independent reviews, comparison articles, recall notices, “this model has a known issue” threads. That’s what plain web search is for.

const res = await fetch(
  'https://api.serply.io/v1/search/q=best+espresso+machine+under+500',
  { headers: { 'X-Api-Key': process.env.SERPLY_API_KEY } }
);
const { results, total, answer } = await res.json();
// results: [{ title, link, description }, ...]

The response is a flat { results, total, answer } object — no nested pagination logic to parse. answer is populated when Google surfaces a direct answer box; otherwise it’s null and you fall back to results. For an agent, this is the “read the room” step: figure out what’s actually worth comparing before pulling pricing data on any of it. Full parameter reference is in the Google Search docs.

2. Amazon product search — pricing, ratings, and Prime status

Once the agent has candidate products, it needs numbers: price, rating, review volume, whether it’s Prime-eligible, whether it’s a sponsored placement dressed up as an organic result.

const res = await fetch(
  'https://api.serply.io/v1/product/search/q=espresso+machine',
  { headers: { 'X-Api-Key': process.env.SERPLY_API_KEY } }
);
const { products } = await res.json();
// each: { link, asin, title, price, rating_stars, review_count,
//         prime, is_sponsor, bestseller, extras: [...] }

is_sponsor matters more than it looks — an agent that blindly trusts real_position will recommend whoever paid for placement. Filter sponsored listings out (or flag them) before ranking. extras often carries shipping and stock-status strings (“Only 3 left in stock”) that are genuinely useful for urgency framing, but they’re free-text, not structured fields, so treat them as a hint rather than something to parse rigidly. Details in the Google Product docs.

3. eBay search — deals, auctions, and the used market

Amazon gives you new-in-box pricing. eBay gives you the rest of the market: used units, auctions ending soon, sellers taking best offers. For a deal-finding agent this is often where the actual deal is.

The eBay endpoint accepts friendly filter aliases on top of raw eBay parameters, so an agent doesn’t need to know eBay’s internal query syntax:

const q = [
  'q=espresso machine',
  'min_price=100',
  'max_price=300',
  'condition=used',
  'buy_now=1',
  'sort=price_asc',
].join('&');

const res = await fetch(
  `https://api.serply.io/v1/ebay/search/${encodeURIComponent(q)}`,
  { headers: { 'X-Api-Key': process.env.SERPLY_API_KEY } }
);
const { results } = await res.json();
// each: { title, link, position, result_type,
//         metadata: { price, was_price, condition, seller, seller_feedback, attributes } }

min_price/max_price map to eBay’s _udlo/_udhi, buy_now=1 maps to LH_BIN=1, condition=used maps to LH_ItemCondition=3000, and sort=price_asc maps to _sop=15 — you can also pass eBay’s raw parameter names directly if you need something not aliased. One gotcha worth hardcoding a comment about: the total field in the response is currently always 0 regardless of actual match count — use results.length, not total, if your agent needs a count. Full alias table in the eBay docs.

4. Google Trends — is this a good time to buy, or should you wait

Price alone doesn’t tell you about timing. If search interest in a product category is spiking (holiday season, a viral review, a new model announcement), prices tend to firm up. If interest is falling, a patient buyer often does better waiting a few weeks.

Serply exposes trend data through /v1/trends/{query} and a more specific /v1/trend/interest_over_time/{query}. We’d rather not guess at exact field names here — check the current response shape against Serply’s reference before wiring up field access in production, since this is one of the newer endpoints and worth confirming directly:

const res = await fetch(
  'https://api.serply.io/v1/trend/interest_over_time/q=espresso+machine',
  { headers: { 'X-Api-Key': process.env.SERPLY_API_KEY } }
);
const trendData = await res.json();
// inspect the shape once against your own account before hardcoding field paths

Conceptually, feed the trend series to the agent as a simple signal — rising, flat, or falling interest over the recent window — rather than trying to have the LLM reason over raw numeric arrays. A one-line summary (“interest in this category is up 40% over the last 30 days”) is far more useful in a prompt than a JSON blob of data points.

5. Google Maps — local stock and pickup options

Sometimes the best deal isn’t online at all — it’s the store two miles away with same-day pickup and no shipping wait. The Maps endpoint is the odd one out in Serply’s API: instead of packing everything into the URL path, it takes ordinary query parameters after a ?.

const query = encodeURIComponent('espresso machine store near Chicago, IL');
const res = await fetch(
  `https://api.serply.io/v1/maps/search/${query}?num=10&gl=us`,
  { headers: { 'X-Api-Key': process.env.SERPLY_API_KEY } }
);
const { places } = await res.json();
// each: { name, address, rating, review_count, phone, website,
//         latitude, longitude, categories, opening_hours }

Note two things that trip people up: X-Proxy-Location and X-User-Agent aren’t supported here (there’s no proxy hop for this endpoint — use gl/hl for locale instead), and responses are cached for 10 minutes, so a cached hit won’t cost you a credit if a user re-runs a nearby search. Full field list in the Google Maps docs.

6. The Request endpoint — when the listing snippet isn’t enough

Search snippets and marketplace summaries only go so far. Sometimes the agent needs the actual product page — full spec sheet, all the customer reviews, a comparison chart buried three sections down. That’s what the /v1/request endpoint is for: it scrapes a URL server-side, with captcha bypass, and can hand back either raw HTML or markdown.

const res = await fetch('https://api.serply.io/v1/request', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Api-Key': process.env.SERPLY_API_KEY,
  },
  body: JSON.stringify({
    url: 'https://example.com/products/espresso-machine-x1',
    response_type: 'markdown',
  }),
});

const markdown = await res.text(); // plain markdown -- not JSON for this response_type

For an agent, response_type: "markdown" is almost always the right call over "full" — it strips nav bars, ads, and script tags down to the content an LLM actually needs, which means fewer tokens and less noise in context. If you do need the raw HTML (say, to parse a specific data attribute), response_type: "full" returns it wrapped as { "data": "<html>...</html>" }. Full details, including this exact response-shape distinction, are in the Request docs.

Putting it together

A reasonably complete shopping agent might chain these like this: run a Google Search to shortlist products worth considering, pull Amazon and eBay pricing for each to find the actual best price (filtering out sponsored Amazon listings and ignoring eBay’s unreliable total count), check Trends to decide whether now is a good time to buy, check Maps if the user wants local pickup, and fall back to the Request endpoint to scrape a specific product page whenever the agent needs detail a snippet can’t provide.

None of these calls are exotic — they’re all plain HTTP requests behind one X-Api-Key. The interesting part isn’t the API surface, it’s the orchestration: knowing which source answers which question, and not asking an LLM to hallucinate an answer that a two-line fetch call could’ve gotten right. Start with Serply’s docs and wire up whichever two or three of these your agent actually needs — you don’t have to use all six on day one.