# Yahoo SERP (`s-r/yahoo-serp`) Actor

- **URL**: https://apify.com/s-r/yahoo-serp.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** Marketing, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Yahoo SERP Scraper: Yahoo Search API for Organic Rankings

A Yahoo search API that returns clean, structured organic results for any query
and language. This SERP scraper walks up to 10 Yahoo result pages per run and
gives you rank, title, destination URL, displayed URL, source name, snippet,
publish date, and sitelinks for every result, plus the "Also Try" related
searches Yahoo shows at the bottom of page one.

Unlike most SERP APIs, this one accepts search operators. `site:`, `inurl:` and
`filetype:` all work, which makes it the practical way to enumerate which pages
of a domain are actually indexed.

### What you get

- **Organic results, ranked 1..N** across every page you request, deduplicated
  on destination URL and renumbered so rank is absolute, not per-page
- **Real destination URLs**. Yahoo wraps every link in an `r.search.yahoo.com`
  redirect; those are decoded back to the clean target before you see them
- **Sitelinks**, the deeplinks Yahoo attaches to strong brand results, as a
  list of `{title, url}` pairs. A single Nike result carries 20+ of them
- **Publish dates** split into their own field instead of glued to the front of
  the snippet, so date filtering does not need a regex on your side
- **Source name** (`ShoppingScraper`, `bol.com`, `Apify`) as Yahoo renders it,
  separate from the breadcrumb URL
- **Related searches** from Yahoo's "Also Try" block, stored on the run record
- **Search operator support**: `site:example.com`, `inurl:blog`,
  `filetype:pdf`, and combinations of them
- **Language localization** via a 2-letter code, so `nl` returns the Dutch
  result set rather than the US one

### Why scrape Yahoo search

Yahoo still answers a meaningful slice of desktop search, and its index is
Bing-derived but not identical. Result order, snippet wording, and which pages
surface at all differ enough that it is a genuine second opinion rather than a
copy. If you track rankings on one engine only, you are measuring one
algorithm's opinion of your site. Adding Yahoo costs almost nothing and catches
the case where a page ranks fine on Google and is invisible everywhere else.

The bigger reason is operators. Google and most Google-backed SERP APIs refuse
`site:` queries outright or serve a block page for them, which means the
question "which pages of this domain are indexed" has no clean API answer. Yahoo
honours the operator. Point this actor at `site:yourdomain.com` with `pages: 10`
and you get back a deduplicated list of indexed URLs you can feed into a crawler,
a content audit, or a redirect check. The same trick works on profile pages
(`site:instagram.com/handle`), on PDFs (`site:gov.uk filetype:pdf`), and on
subsections (`site:docs.example.com inurl:api`).

Yahoo is also a grounding source that AI assistants and privacy-focused browsers
still consult. If you are auditing where a brand shows up across the search
landscape rather than just on Google, leaving Yahoo out leaves a hole in the
picture.

### Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `q` | string | yes | (none) | Search query. Operators supported: `site:`, `inurl:`, `filetype:` |
| `lang` | string | no | `en` | 2-letter language code (`en`, `nl`, `de`, `fr`, `es`, `it`, ...). Yahoo localizes by language, not country |
| `pages` | integer | no | `1` | Result pages to walk, 1–10, fetched concurrently. Each adds roughly 7–11 results |
| `limit` | integer | no | `10` | Maximum results returned across all pages after deduplication, 1–100 |
| `retries` | integer | no | `3` | Retry attempts per page, 1–6 |

Example input:

```json
{
  "q": "site:shoppingscraper.com",
  "lang": "en",
  "pages": 3,
  "limit": 30,
  "retries": 3
}
```

### Output

One dataset row per organic result:

```json
{
  "rank": 2,
  "title": "Price scraper - Extract prices, availability from any url/EAN",
  "url": "https://apify.com/s-r/price-scraper---extract-prices-availability-from-any-url",
  "displayed_url": "https://apify.com › s-r › price-scraper---extract-prices",
  "source": "Apify",
  "snippet": "This universal actor extracts prices from ANY e-commerce site in seconds.",
  "date": "",
  "sitelinks": [
    { "title": "Pricing", "url": "https://apify.com/pricing" }
  ],
  "q": "price scraper api",
  "lang": "en",
  "fetched_in_seconds": 2.41
}
```

The run's key-value store also carries a `summary` record with `itemCount`,
`errorCount`, `pagesRequested`, `pagesFetched`, and `relatedSearches` (the "Also
Try" suggestions). Any per-page failures land in a separate `errors` record with
a code and a redacted message.

### Use cases

**Index enumeration for technical SEO audits.** You inherit a site and nobody
can tell you how many pages are live, let alone indexed. Run
`site:thedomain.com` with `pages: 10` and you get a deduplicated URL list in one
call. Diff it against the sitemap and the orphan pages, the forgotten staging
subdomain, and the thin tag archives all fall out immediately. Add
`inurl:` to narrow to a section, or `filetype:pdf` to find the documents nobody
remembered were public.

**Cross-engine rank tracking.** Marketing teams that report a single Google
position are reporting one data point. Running the same keyword set through this
Yahoo SERP scraper alongside a Bing and DuckDuckGo scraper produces a per-engine
ranking matrix. Where the engines disagree sharply on a keyword, that usually
points at a technical problem specific to one crawler rather than at a content
problem, which is a far cheaper thing to fix.

**Competitive discovery in a second index.** Yahoo surfaces different domains
than Google for the same commercial query, particularly older, established sites
that Google has demoted. Pulling the top 30 for your money keywords on both
engines and diffing the domain lists gives you a competitor set your Google-only
research never showed you, which matters when you are choosing link targets or
sizing a market.

**Grounding-source auditing for AI visibility.** AI assistants and privacy
browsers pull from more than one index. If you are tracking whether a brand gets
cited by AI tools, you need to know whether the brand is even present in the
indexes those tools consult. A Yahoo search API call per brand term is the
cheapest way to answer that for this slice of the landscape.

### How it compares

| | This actor | scrapeai/yahoo-search-scraper | scraper-engine/yahoo-scraper | bhansalisoft/yahoo-search-results-scraper |
|---|---|---|---|---|
| Price per 1k results | **$2.10** | $2.99 | $4.99 | $10.00 |
| Search operators (`site:`, `inurl:`) | yes | not documented | not documented | not documented |
| Sitelinks extracted | yes | no | no | no |
| Publish date as its own field | yes | no | no | no |
| Related searches | yes | no | no | no |
| Multi-page concurrent fetch | up to 10 | n/a | n/a | n/a |

Prices verified against the Apify API on 2026-08-31. What the others have that
we do not: nothing we found, though the two tiered-pricing Yahoo actors
(`datascraperes`, `delectable_incubator`) may work out cheaper at very high
volume, since their rates are not published as a flat number. Compare at your own
expected volume before switching.

### Pricing

$0.0021 per organic result returned, plus a $0.0005 fee per run. A default run
returning 10 results costs about $0.022. All pricing is pay-per-event: you only
pay for results you receive. No per-compute-unit charges.

### Limits and gotchas

- **Yahoo returns 7–11 results per page**, not a fixed 10. Asking for
  `limit: 10` with `pages: 1` will often return 7. Request more pages than you
  think you need and cap with `limit`.
- **`lang` is a language, not a country.** Yahoo localizes through
  `vl=lang_<code>` and has no separate geo parameter, so `nl` gets you Dutch
  results, not results restricted to the Netherlands.
- **Deeper pages block more often.** A page that fails all its retries yields no
  rows rather than failing the whole run; check `pagesFetched` against
  `pagesRequested` in the `summary` record to see whether you got everything.
- **Deduplication is on destination URL.** Overlapping pages are collapsed, so a
  3-page run can legitimately return fewer than 21 rows.
- **`count` is results returned, not index size.** A `site:` query returning 40
  URLs does not mean the domain has exactly 40 indexed pages.
- **Yahoo's index skews older and thinner than Google's.** Use it to find URLs
  and as a second opinion; do not make Google ranking claims from Yahoo data.
- **Cold start adds roughly 2 seconds** for the container pull before the first
  request goes out.

### FAQ

**Is there a free Yahoo search API?** Yahoo shut down its official BOSS search
API years ago and has no public replacement. Scraping the SERP is the only
remaining path to programmatic Yahoo results.

**Can I use a Yahoo search API from Python?** Yes. Call this actor through the
Apify Python client, or hit the Actor run endpoint directly and read the
dataset. Output is plain JSON rows.

**Does Yahoo search still exist?** Yes. Yahoo Search runs on a Bing-derived
index with its own ranking layer and its own presentation, which is why results
differ from Bing's.

**What is the Yahoo search API pricing here?** $0.0021 per result plus $0.0005
per run, billed per event. Nothing is charged for compute time.

**Can I run a `site:` query to list indexed pages?** Yes, and it is the main
reason to pick Yahoo over a Google-backed SERP API. `site:`, `inurl:` and
`filetype:` all work, including combined.

### Related Actors

- [Bing SERP](https://apify.com/s-r/bing-serp), the same output shape against Bing's index
- [DuckDuckGo SERP](https://apify.com/s-r/duckduckgo-serp), privacy-engine organic results
- [Google Keywords](https://apify.com/s-r/google-keywords), for volume, CPC, and difficulty on the keywords you find here

# Actor input Schema

## `q` (type: `string`):

Search query. Search operators are supported: site:example.com, inurl:blog, filetype:pdf.

## `lang` (type: `string`):

2-letter language code used to localize results (en, nl, de, fr, es, it, ...). Yahoo localizes by language, not by country.

## `pages` (type: `integer`):

Result pages to walk, fetched concurrently. Each page adds roughly 7-11 results.

## `limit` (type: `integer`):

Maximum organic results to return across all pages, after deduplication (1-100).

## `retries` (type: `integer`):

Retry attempts per page, each with a rotated browser fingerprint (1-6).

## Actor input object example

```json
{
  "q": "site:apify.com inurl:blog",
  "lang": "en",
  "pages": 1,
  "limit": 10,
  "retries": 3
}
```

# Actor output Schema

## `results` (type: `string`):

One row per organic Yahoo result, ranked 1..N across every fetched page.

## `summary` (type: `string`):

itemCount, errorCount, pagesRequested, pagesFetched and the Also Try related searches.

## `errors` (type: `string`):

Per-page failures with a code and a redacted message. Absent when the run had none.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "q": "apify",
    "lang": "en",
    "pages": 1,
    "limit": 10,
    "retries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/yahoo-serp").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "q": "apify",
    "lang": "en",
    "pages": 1,
    "limit": 10,
    "retries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("s-r/yahoo-serp").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "q": "apify",
  "lang": "en",
  "pages": 1,
  "limit": 10,
  "retries": 3
}' |
apify call s-r/yahoo-serp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/yahoo-serp"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/0aRTqDHcK6JG0OFhb/builds/GsZBfD5zYlXKUzSLE/openapi.json