# Yahoo Search Scraper (`aerodynamic_tripod/yahoo-search-scraper`) Actor

Scrape Yahoo organic search results and track target-domain rankings by query, country, and language. Extract titles, URLs, domains, snippets, positions, and rank summaries with automatic pagination and retries.

- **URL**: https://apify.com/aerodynamic\_tripod/yahoo-search-scraper.md
- **Developed by:** [SearchShark Tools](https://apify.com/aerodynamic_tripod) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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 Search Scraper & Rank Tracker

**Yahoo Search Scraper & Rank Tracker** lets you extract **organic Yahoo search results** and track the **observed ranking of target domains** for multiple search queries.

Collect **titles, URLs, domains, snippets, search positions, country context, language context, and target-domain ranks** without manually checking Yahoo Search.

- 🎯 **Track target-domain rankings:** see where your website or competitor appears for each search query
- 🔎 **Scrape organic Yahoo results:** collect titles, URLs, domains, snippets, and observed search positions
- 🌍 **Search regional Yahoo versions:** use supported country and language contexts
- 📊 **Analyze competitors:** compare where multiple domains appear for the same keyword
- 📄 **Automatic pagination:** continue through Yahoo results until the requested result limit is reached
- 🛡 **Retry and recovery handling:** temporary Yahoo errors and suspicious empty result pages are handled automatically
- 🇯🇵 **Yahoo Japan support:** includes dedicated parsing and session recovery for Yahoo Japan
- ⚡ **HTTP-first architecture:** normal searches do not require expensive browser automation
- 🔌 **Automation ready:** export structured results through Apify Dataset, API, integrations, or downstream applications

***

### 📦 What data does Yahoo Search Scraper extract?

#### 🔎 Organic search results

| | |
| --- | --- |
| 🔍 **Search query** | 🏆 **Observed rank** |
| 📝 **Result title** | 🌐 **Result URL** |
| 🔗 **Displayed URL** | 🏷 **Domain** |
| 📄 **Snippet** | 📃 **Yahoo result page** |
| 🌍 **Country context** | 🗣 **Language context** |
| 🎯 **Target-domain match** | 🔗 **Matched target domain** |
| 🔎 **Yahoo source URL** | 🕒 **Capture timestamp** |

#### 🎯 Target-domain rank results

| | |
| --- | --- |
| 🔍 **Search query** | 🎯 **Target domain** |
| 🏆 **Current observed rank** | ✅ **Found / not found** |
| 🔗 **Matched URL** | 📊 **Checked results** |
| 🌍 **Country context** | 🗣 **Language context** |
| 📌 **Rank status** | 🛡 **Scrape status** |
| ⚠️ **Error information** | 🕒 **Capture timestamp** |

> **Missing fields are returned as `null`.** The Actor does **not invent rankings or search-result data** that Yahoo did not return.

***

## 🚀 Features

Yahoo Search Scraper & Rank Tracker is designed for **SEO monitoring, competitor research, search intelligence, and automated Yahoo SERP collection**.

- **Multiple queries:** search several keywords in one Actor run
- **Multiple target domains:** track several websites against the same queries
- **Up to 100 organic results per query**
- **Observed Yahoo ranking:** preserve the real position returned during the scrape
- **Country selection:** request supported regional Yahoo search contexts
- **Language selection:** control the requested language context
- **Target-domain matching:** root domains and their subdomains can be recognized as matches
- **Automatic pagination:** fetch additional result pages when necessary
- **Duplicate protection:** repeated URLs are not counted twice
- **Yahoo redirect resolution:** converts Yahoo redirect links into destination URLs
- **Clean result titles:** extracts the actual search-result title instead of Yahoo wrapper text
- **Clean displayed URLs:** generates readable domain and path information
- **Retry handling:** temporary HTTP failures are retried automatically
- **Cookie/session handling:** Yahoo session cookies are maintained across pagination requests
- **Yahoo Japan recovery:** suspicious empty Yahoo Japan responses can trigger fresh-session retries
- **Partial failure protection:** already collected results remain available if a later page fails
- **Separate rank summaries:** target-domain rankings are stored separately from organic results
- **API-friendly output:** predictable structured fields for automation
- **HTTP-first scraping:** browser automation is not required for normal searches

***

## ⬇️ Input

You can configure Yahoo Search Scraper directly from the **Apify Console** or send the input programmatically through the **Apify API**.

***

### 🔎 Queries

Enter one or more search queries.

Example:

```text
OpenAI
ChatGPT
artificial intelligence
```

**Each query is searched independently.**

For example:

```text
OpenAI
ChatGPT
```

creates two separate Yahoo search contexts.

***

### 🎯 Target domains

Add domains that you want to track in Yahoo search results.

Example:

```text
openai.com
chatgpt.com
```

The Actor checks every collected organic result against your target domains.

#### Subdomains are included

For example, when the target domain is:

```text
openai.com
```

these can also count as matches:

```text
openai.com
platform.openai.com
developers.openai.com
academy.openai.com
```

This makes domain-level rank tracking more useful when a company uses several subdomains.

Target domains are optional.

If no target domain is provided, the Actor can still collect normal Yahoo organic search results.

***

### 🌍 Country

Choose the Yahoo search country context.

The current input supports:

```text
United States
United Kingdom
Philippines
Canada
Australia
India
Singapore
Germany
France
Spain
Italy
Japan
Brazil
```

The Actor uses the appropriate Yahoo search host or regional search context when available.

Examples include:

```text
search.yahoo.com
uk.search.yahoo.com
ph.search.yahoo.com
es.search.yahoo.com
search.yahoo.co.jp
```

> Search results may still vary because Yahoo can personalize, localize, reorder, or temporarily change its result pages.

***

### 🗣 Language

Choose the requested search language.

Supported options include:

```text
English
Spanish
German
French
Italian
Portuguese
Japanese
```

For the best regional consistency, use a language that matches the selected country.

Examples:

```text
US + en
ES + es
JP + ja
DE + de
FR + fr
```

***

### 🔢 Maximum results per query

Set the maximum number of unique organic results to collect for **each query**.

```text
Minimum: 1
Default: 50
Maximum: 100
```

For example:

```text
Queries:
OpenAI
ChatGPT

Maximum results per query:
20
```

can return up to:

```text
20 OpenAI search results
+
20 ChatGPT search results
=
40 organic result rows
```

The requested amount is a **maximum, not a guarantee**.

Yahoo may expose fewer usable organic search results for a query or region.

The Actor does **not fabricate additional results** just to reach the requested number.

***

### 🛡 Safe Search

Choose how Yahoo Safe Search should be requested.

Available modes:

```text
strict
moderate
off
```

The default is:

```text
moderate
```

***

### ⏱ Request delay

Control the delay between Yahoo search requests.

The default configuration uses:

```text
5000 ms
```

A delay helps reduce request bursts and improves reliability because Yahoo may temporarily reject requests that are sent too quickly.

***

### 🧪 Example input

```json
{
  "queries": [
    "OpenAI",
    "ChatGPT"
  ],
  "targetDomains": [
    "openai.com",
    "chatgpt.com"
  ],
  "country": "US",
  "language": "en",
  "maxResultsPerQuery": 20,
  "safeSearch": "moderate",
  "requestDelayMs": 5000
}
```

***

## ⬆️ Output

Yahoo Search Scraper produces **two structured result types**.

***

### 🔎 Organic Search Results

Organic Yahoo results are stored in the Actor's default **Apify Dataset**.

You can access them from:

```text
Output
Storage
Apify API
Integrations
Export
```

Each Dataset row represents **one Yahoo organic search result for one query**.

***

### 📊 Example organic result

```json
{
  "recordType": "organic_result",
  "query": "OpenAI",
  "country": "US",
  "language": "en",
  "page": 1,
  "position": 1,
  "title": "OpenAI | Research & Deployment",
  "url": "https://openai.com/",
  "displayUrl": "openai.com",
  "domain": "openai.com",
  "snippet": "We believe our research will eventually lead to artificial general intelligence...",
  "isTargetDomain": true,
  "matchedTargetDomain": "openai.com",
  "sourceUrl": "https://search.yahoo.com/search?p=OpenAI...",
  "usedFallback": false,
  "capturedAt": "2026-09-04T10:20:18.000Z"
}
```

***

## 🎯 Target Domain Ranks

Target-domain summaries are available in the **Target Domain Ranks** Dataset view.

Instead of searching through every organic result manually, this output summarizes the position of every requested target domain.

Example:

```text
Query: OpenAI
Target Domain: openai.com
Found: Yes
Current Rank: 1
Matched URL: https://openai.com/
Checked Results: 20
```

Another example:

```text
Query: artificial intelligence
Target Domain: chatgpt.com
Found: No
Current Rank: null
Checked Results: 20
```

***

### 📊 Example target rank result

```json
{
  "query": "OpenAI",
  "targetDomain": "openai.com",
  "rankStatus": "found",
  "scrapeStatus": "success",
  "found": true,
  "currentRank": 1,
  "matchedUrl": "https://openai.com/",
  "checkedResults": 20,
  "country": "US",
  "language": "en",
  "errorMessage": null,
  "capturedAt": "2026-09-04T10:20:18.000Z"
}
```

***

## 🏆 Observed Yahoo rank

One of the most useful fields returned by the Actor is:

```text
position
```

For target-domain summaries:

```text
currentRank
```

These represent the **observed Yahoo search position during that specific scrape**.

For example:

```text
OpenAI → openai.com → Rank 1
OpenAI → chatgpt.com → Rank 3
ChatGPT → chatgpt.com → Rank 1
```

Rankings are based only on the organic results collected during the Actor run.

If:

```text
maxResultsPerQuery = 20
```

and a target domain does not appear inside those 20 collected results, the Actor reports:

```text
found: false
currentRank: null
```

This means:

> **The target was not found inside the checked result range.**

It does **not necessarily mean the domain does not appear anywhere in Yahoo Search**.

***

### ⚠️ Rankings can change

Yahoo search positions can vary because of:

```text
Country
Language
Yahoo regional host
Time
Search index changes
Result personalization
Temporary Yahoo experiments
```

For that reason, `position` and `currentRank` should be understood as:

> **Observed Yahoo ranking at the time of the scrape.**

They are not permanent universal rankings.

***

## 🌍 Regional Yahoo search

The Actor supports multiple Yahoo search environments.

This is important because the same query can return different results depending on the selected country.

For example:

```text
Query: OpenAI
Country: US
```

may produce a different order than:

```text
Query: OpenAI
Country: ES
```

or:

```text
Query: OpenAI
Country: JP
```

This allows the Actor to be used for **regional SEO research and international search analysis**.

***

## 🇯🇵 Yahoo Japan support

Yahoo Japan uses a substantially different search-result structure from many other Yahoo regions.

The Actor includes **dedicated Yahoo Japan parsing and recovery logic**.

It can extract Yahoo Japan organic results such as:

```text
Title
URL
Domain
Snippet
Observed position
```

Yahoo Japan may occasionally return a page containing:

```text
Knowledge panels
Realtime results
Related searches
AI content
```

without normal organic web results.

When this happens, the Actor can:

```text
Detect the suspicious response
Reset Yahoo session cookies
Start a fresh search session
Warm the new session when necessary
Retry the requested page
Preserve previously collected results
```

If a later Yahoo Japan page continues returning no usable organic results after recovery attempts, the query can be marked:

```text
partial
```

instead of discarding results that were already collected successfully.

***

## 📄 Pagination

Yahoo Search Scraper automatically requests additional result pages when more results are needed.

The search stops when:

- 🎯 **Maximum unique results are reached**
- 📭 **Yahoo exposes no additional usable organic results**
- 🆕 **No new unique results are discovered**
- ⚠️ **Recovery attempts are exhausted**
- 🛡 **Defensive pagination limits are reached**

The Actor does not generate fake results simply to reach the requested maximum.

***

## 🧹 Duplicate protection

Results are deduplicated within each query.

The primary identity signal is the resolved result URL.

For example, if Yahoo exposes the same destination more than once during pagination, the Actor does not repeatedly count that URL as a new organic result.

This protects ranking output from obvious repeated-result pollution.

***

## 🔗 Yahoo redirect resolution

Yahoo can wrap destination URLs inside tracking or redirect links.

The Actor resolves supported Yahoo redirect URLs into the actual destination.

Instead of returning only a Yahoo tracking link, output can contain:

```text
https://openai.com/
```

rather than an unreadable Yahoo redirect URL.

***

## 🧼 Clean result titles

Yahoo result markup differs between regional sites.

The Actor uses dedicated title extraction logic so output contains actual titles such as:

```text
OpenAI | Research & Deployment
ChatGPT: Chat, Work, Create & Code with AI
OpenAI - Wikipedia
```

instead of accidentally returning entire search-result blocks.

***

## ⚡ Performance

Yahoo Search Scraper uses an **HTTP-first architecture**.

Instead of launching a full browser for standard search requests, it retrieves Yahoo search HTML directly.

This generally provides:

```text
Faster startup
Lower memory use
Lower browser overhead
Lower compute requirements
Simpler API automation
```

***

## 🛡 Reliability

Yahoo can occasionally return temporary errors or unusual result pages.

The Actor includes several reliability protections.

#### Temporary HTTP errors

Failed Yahoo requests can be retried automatically with increasing delays.

Example:

```text
Retry 1
Wait
Retry 2
Wait longer
Retry 3
```

***

### 🍪 Session cookies

Yahoo cookies are maintained during a query.

This is especially useful for pagination because Yahoo may expect later result pages to continue from the same search session.

***

### 🔄 Fresh-session recovery

For regional Yahoo responses that unexpectedly contain no usable organic results, the Actor can reset its Yahoo session and try again.

This is particularly important for **Yahoo Japan**.

***

### 🟡 Partial results

Suppose the Actor successfully collects:

```text
Page 1
Page 2
```

but Yahoo repeatedly fails to provide a usable:

```text
Page 3
```

The Actor can preserve the results already collected and mark the scrape:

```text
scrapeStatus: "partial"
```

This is safer than pretending the scrape was fully complete.

***

### 🔴 Scrape failure

If Yahoo does not provide any usable organic results after recovery attempts, rank output can report:

```text
rankStatus: "scrape_failed"
scrapeStatus: "scrape_failed"
```

This prevents a failed scrape from being incorrectly reported as:

```text
not_found
```

A real:

```text
not_found
```

should mean Yahoo results were successfully checked but the requested target domain was not present inside the checked range.

***

## 🔌 API & integrations

Yahoo Search Scraper can be used programmatically through the **Apify API**.

You can connect the results to workflows such as:

- Google Sheets
- Make
- Zapier
- CRMs
- SEO dashboards
- Internal APIs
- Data warehouses
- Rank-monitoring systems
- AI agents
- MCP workflows

Both organic results and target-domain summaries are stored as structured data suitable for downstream applications.

***

## 💡 Example use cases

### 🎯 SEO rank checking

Search:

```text
best AI assistant
AI chatbot
artificial intelligence
```

Target domains:

```text
example.com
competitor.com
```

Use the Target Domain Ranks output to compare observed Yahoo positions.

***

### 📊 Competitor research

Track several competing domains:

```text
competitor-a.com
competitor-b.com
competitor-c.com
```

against queries such as:

```text
best CRM
CRM software
sales automation
```

Analyze which competitor appears first for each query.

***

### 🌍 International SEO

Run the same keyword in different regional search contexts.

For example:

```text
US + English
ES + Spanish
JP + Japanese
```

Then compare how rankings and URLs differ by region.

***

### 🔎 Yahoo SERP data collection

You do not need to provide target domains.

The Actor can also be used simply to collect organic Yahoo search results including:

```text
Rank
Title
URL
Domain
Snippet
Country
Language
Timestamp
```

***

## ⚠️ Current limitations

The current version focuses on **Yahoo organic web results and current target-domain ranking**.

It does **not currently provide**:

```text
Historical rank charts
Scheduled rank history storage
Keyword search volume
Paid advertisement extraction
Image search results
Video search results
News search results
People-also-ask extraction
Automatic competitor discovery
Guaranteed fixed Yahoo rankings
Unlimited pagination
Browser fingerprint simulation
CAPTCHA bypassing
```

Historical tracking can be built separately by scheduling repeated Actor runs and storing snapshots over time.

***

## ❓ FAQ

### How does Yahoo Search Scraper work?

The Actor:

```text
Builds the regional Yahoo search request
Fetches the Yahoo result page
Maintains the search session
Parses organic web results
Resolves destination URLs
Extracts titles and snippets
Tracks observed positions
Matches target domains
Automatically paginates
Stores organic results
Stores target-rank summaries
```

***

### How many results can I scrape?

The current maximum is:

```text
100 organic results per query
```

Yahoo may expose fewer usable results.

The maximum is therefore a **collection limit, not a guarantee**.

***

### Can I search multiple keywords?

**Yes.**

Example:

```text
OpenAI
ChatGPT
artificial intelligence
```

Each query is searched independently.

***

### Can I track multiple domains?

**Yes.**

Example:

```text
openai.com
chatgpt.com
```

The Actor creates a ranking summary for every:

```text
Query × Target Domain
```

combination.

For example:

```text
3 queries
×
2 target domains
=
6 target-rank summary rows
```

***

### Are subdomains included?

**Yes.**

If the target is:

```text
openai.com
```

a result from:

```text
platform.openai.com
```

can count as a match.

***

### Why is currentRank sometimes null?

There are two important situations.

#### Target genuinely not found

```text
rankStatus: "not_found"
scrapeStatus: "success"
```

Yahoo was successfully checked, but the target was not found inside the collected result range.

#### Scrape could not be completed

```text
scrapeStatus: "scrape_failed"
```

Yahoo did not provide usable organic results after the Actor's recovery attempts.

These situations are intentionally kept separate.

***

### What does partial mean?

Example:

```text
scrapeStatus: "partial"
```

means the Actor collected valid results but could not complete all requested Yahoo pages.

The successfully collected data is still returned.

***

### Why can rankings change between runs?

Yahoo results can change over time.

They can also vary because of:

```text
Country
Language
Yahoo region
Search index updates
Personalization
Temporary experiments
Result availability
```

For this reason, the Actor reports **observed ranking**, not a guaranteed permanent ranking.

***

### Does Yahoo Japan work?

**Yes.**

Yahoo Japan uses different result markup, so the Actor has dedicated Yahoo Japan parsing and fresh-session recovery.

Yahoo Japan can occasionally expose fewer usable web results than expected, so some runs may finish with fewer results or a partial status.

***

### Can I use the scraper without target domains?

**Yes.**

Leave target domains empty if you only want normal Yahoo organic search results.

***

### Can I export the results?

**Yes.**

Apify Dataset results can be exported in supported formats such as:

```text
JSON
CSV
Excel
XML
HTML
```

***

### Can I use Yahoo Search Scraper through an API?

**Yes.**

The Actor can be started through the **Apify API**, and results can be consumed programmatically.

This makes it suitable for:

```text
SEO dashboards
Automated rank checks
Competitor monitoring
Data pipelines
Internal tools
AI agents
Scheduled workflows
```

***

### Is browser automation required?

**Not for the normal search workflow.**

Yahoo Search Scraper uses an HTTP-first architecture.

This reduces browser overhead and keeps standard scraping requests lightweight.

***

## 🧭 Recommended workflow

For reliable rank checks, use a clear combination of:

```text
Specific query
Correct country
Matching language
Real target domain
Reasonable result limit
```

Example:

```text
Query:
best AI chatbot

Target domains:
example.com
competitor.com

Country:
US

Language:
en

Maximum results:
50
```

For international SEO, run separate regional searches instead of assuming one Yahoo result page represents every country.

***

## 💬 Feedback & support

Found a bug or have a feature request?

Use the Actor's **Issues** tab on Apify.

Useful future additions may include:

```text
Historical rank tracking
Scheduled rank snapshots
Rank-change calculations
Additional Yahoo regions
SERP feature extraction
News search
Image search
Video search
Additional SEO metrics
```

***

### 🚀 Yahoo search data without the manual checking

Enter your **queries**, add optional **target domains**, choose a **country and language**, run the Actor, and receive **structured Yahoo organic search results and observed domain rankings** ready for **SEO research, competitor analysis, APIs, and automation**.

# Actor input Schema

## `queries` (type: `array`):

Enter one or more Yahoo search keywords. Duplicate queries will be removed automatically.

## `targetDomains` (type: `array`):

Optional domains to rank-check across the search queries. Enter domains such as example.com without https://.

## `country` (type: `string`):

Yahoo Search market used for localization.

## `language` (type: `string`):

Preferred Yahoo Search result language.

## `maxResultsPerQuery` (type: `integer`):

Maximum number of organic Yahoo results to collect for each search query.

## `safeSearch` (type: `string`):

Yahoo Safe Search filtering level.

## `requestDelayMs` (type: `integer`):

Delay between Yahoo requests in milliseconds. A safer default reduces temporary Yahoo 500 errors during bulk runs.

## Actor input object example

```json
{
  "queries": [
    "OpenAI",
    "best gaming laptop"
  ],
  "targetDomains": [
    "openai.com"
  ],
  "country": "US",
  "language": "en",
  "maxResultsPerQuery": 50,
  "safeSearch": "moderate",
  "requestDelayMs": 5000
}
```

# Actor output Schema

## `organicResults` (type: `string`):

No description

## `targetRanks` (type: `string`):

No description

# 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 = {
    "queries": [
        "OpenAI",
        "best gaming laptop"
    ],
    "targetDomains": [
        "openai.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("aerodynamic_tripod/yahoo-search-scraper").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 = {
    "queries": [
        "OpenAI",
        "best gaming laptop",
    ],
    "targetDomains": ["openai.com"],
}

# Run the Actor and wait for it to finish
run = client.actor("aerodynamic_tripod/yahoo-search-scraper").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 '{
  "queries": [
    "OpenAI",
    "best gaming laptop"
  ],
  "targetDomains": [
    "openai.com"
  ]
}' |
apify call aerodynamic_tripod/yahoo-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/g8qHZj8JyiJKEMWnt/builds/llcJLW3Zl0OPAfadh/openapi.json