# Bing Search Scraper & Rank Tracker (`aerodynamic_tripod/bing-search-scraper-rank-tracker`) Actor

Scrape Bing SERPs, track keyword rankings, compare competitors, monitor visibility, and extract organic results, ads, featured snippets, sitelinks, related searches, and PAA data.

- **URL**: https://apify.com/aerodynamic\_tripod/bing-search-scraper-rank-tracker.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

## 🔎 Bing Search Scraper & Rank Tracker

**Bing Search Scraper & Rank Tracker** lets you collect **structured Bing SERP data**, track domain rankings, compare competitors, and monitor search visibility across multiple keywords.

Built for **SEO agencies, marketers, developers, researchers, and rank-tracking workflows**, the Actor goes beyond basic title + URL scraping.

Use it to:

- 🎯 **Track target-domain rankings:** find where your website ranks for each Bing keyword
- 📈 **Monitor rank movement:** compare current and previous positions across runs
- 🥊 **Compare competitors:** check competitor positions for the same keywords
- 📊 **Measure domain visibility:** summarize ranking performance across multiple queries
- 🔎 **Collect organic Bing results:** position, page, title, URL, and snippet
- 💰 **Extract sponsored results:** keep ads separate from organic rankings
- ⭐ **Collect SERP features:** sitelinks, featured snippets, related searches, and question elements when Bing exposes them
- 🌍 **Search different Bing markets:** use market codes such as `en-US`, `en-GB`, or `de-DE`
- 📄 **Scrape multiple result pages:** process from 1 to 10 Bing pages per query
- ⚡ **Automate SEO workflows:** export structured results through Apify Dataset, API, integrations, or downstream applications

***

### 📦 What data does Bing Search Scraper & Rank Tracker extract?

| | |
| --- | --- |
| 🔍 **Search query** | 🎯 **Target domain** |
| 🏆 **Organic position** | 📄 **Result page** |
| 📝 **Result title** | 🔗 **Result URL** |
| 📃 **Snippet** | ✅ **SERP quality status** |
| 📈 **Current target rank** | ⏮ **Previous target rank** |
| ↕️ **Rank change** | 🏷 **Ranking status** |
| 🔗 **Target ranking URL** | 🕒 **Checked timestamp** |
| 💰 **Sponsored results / ads** | 🔗 **Sitelinks** |
| ⭐ **Featured snippets** | 🔎 **Related searches** |
| ❓ **Question / answer elements** | 🥊 **Competitor rankings** |
| 📊 **Domain visibility summary** | 🌍 **Bing market** |

> **SERP features are returned only when Bing exposes them for the requested query.** The Actor does not fabricate ads, sitelinks, snippets, related searches, or question data.

***

## 🚀 Features

Bing Search Scraper & Rank Tracker is designed for **SEO monitoring, competitor intelligence, and structured Bing SERP collection**.

- **Multiple search queries:** process many keywords in one Actor run
- **1–10 Bing result pages per query**
- **Target-domain rank checker**
- **Historical rank comparison between runs**
- **Previous rank, current rank, and rank change**
- **Competitor-domain ranking comparison**
- **Domain visibility score across multiple keywords**
- **Organic result positions**
- **Organic vs sponsored classification**
- **Sponsored / advertisement extraction**
- **Sitelink extraction when available**
- **Featured snippet extraction when available**
- **Related search extraction when available**
- **People Also Ask / question extraction when available**
- **Market targeting using Bing market codes**
- **SERP quality validation**
- **Structured SEO-ready Dataset output**
- **Apify API and automation compatible**

***

## ⬇️ Input

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

The current input fields are:

```text
queries
targetDomain
competitorDomains
pages
projectKey
market
```

***

### 🔎 Search queries

Add one or more Bing keywords you want to process.

Example:

```text
apify web scraping
web scraping api
best scraping tools
```

Each query is processed independently.

Example use cases:

```text
brand keywords
commercial keywords
competitor keywords
SEO tracking keywords
research queries
```

The same target and competitor domains are checked against each query.

***

### 🎯 Target domain

Enter the domain whose Bing position you want to track.

Example:

```text
apify.com
```

You can enter a root domain without a protocol.

Good:

```text
apify.com
```

You do not need:

```text
https://apify.com/
```

The Actor checks the organic Bing results and returns the best observed matching position.

Subdomains belonging to the target domain can also be matched.

Example:

```text
Target:
apify.com

Matching result:
docs.apify.com
```

***

### 🥊 Competitor domains

Optionally add competitor domains.

Example:

```text
use-apify.com
scraperapi.com
brightdata.com
```

For every query, the Actor checks each competitor against the same organic results used for the target domain.

Example output:

```text
apify.com        → Position 1
use-apify.com    → Position 3
scraperapi.com   → Not ranked
```

Competitor rankings do **not** replace the target-domain rank.

They are returned separately so you can compare the SERP directly.

***

### 📄 Pages

Set how many Bing result pages should be processed for each query.

```text
Minimum: 1
Default: 1
Maximum: 10
```

Example:

```text
pages: 1
```

checks only the requested first-page ranking range.

Example:

```text
pages: 5
```

searches deeper into Bing for the target and competitor domains.

More pages can improve rank coverage for domains that do not appear near the top of the SERP.

> The requested page count controls the result pages included in the final normalized output.

***

### 🗂 Project key

`projectKey` separates independent rank-history projects.

Default:

```text
default
```

Example:

```text
client-acme
```

or:

```text
roofing-campaign-miami
```

This is useful when you track the same keyword or domain for multiple campaigns.

For example:

```text
Project A:
client-alpha

Project B:
client-beta
```

Rank history from those projects remains logically separated.

***

### 🌍 Bing market

Choose the Bing market used for the search.

Default:

```text
en-US
```

Examples:

```text
en-US
en-GB
de-DE
fr-FR
```

The market affects Bing's search context and can influence the returned SERP.

Rankings may differ between markets.

***

## 🧪 Example input

```json
{
  "queries": [
    "apify web scraping",
    "web scraping api"
  ],
  "targetDomain": "apify.com",
  "competitorDomains": [
    "use-apify.com",
    "scraperapi.com"
  ],
  "pages": 2,
  "projectKey": "seo-campaign",
  "market": "en-US"
}
```

***

## ⬆️ Output

Results are stored in the Actor's default **Apify Dataset**.

You can access them from:

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

For normal query records, each Dataset row contains the complete normalized SERP and rank-tracking result for one search query.

When multiple queries are processed, the Actor can also add a separate:

```text
visibility_summary
```

record containing aggregate domain visibility information.

***

## 📊 Example query result

```json
{
  "valid": true,
  "qualityStatus": "passed",
  "query": "what is artificial intelligence",
  "targetDomain": "ibm.com",
  "organicResults": [
    {
      "position": 1,
      "page": 1,
      "title": "What Is Artificial Intelligence (AI)? | IBM",
      "url": "https://www.ibm.com/think/topics/artificial-intelligence",
      "snippet": "Artificial intelligence (AI) is technology that enables computers and machines..."
    },
    {
      "position": 2,
      "page": 1,
      "title": "Artificial intelligence | Definition, Examples, Types",
      "url": "https://www.britannica.com/technology/artificial-intelligence",
      "snippet": "Artificial intelligence is the ability of a computer..."
    }
  ],
  "previousRank": null,
  "currentRank": 1,
  "rankChange": null,
  "status": "newly_ranked",
  "rankingUrl": "https://www.ibm.com/think/topics/artificial-intelligence",
  "checkedAt": "2026-09-07T07:38:45.238Z",
  "ads": [],
  "sitelinks": [],
  "featuredSnippets": [],
  "relatedSearches": [],
  "questions": [],
  "competitorRankings": [
    {
      "domain": "wikipedia.org",
      "position": 4,
      "rankingUrl": "https://en.wikipedia.org/wiki/Artificial_intelligence",
      "status": "ranked"
    },
    {
      "domain": "microsoft.com",
      "position": null,
      "rankingUrl": null,
      "status": "not_ranked"
    }
  ]
}
```

***

## 🏆 Organic ranking

Each organic result contains an observed Bing position.

Example:

```text
Position 1 → ibm.com
Position 2 → britannica.com
Position 3 → coursera.org
Position 4 → wikipedia.org
```

The Actor preserves ranking order so it can determine the position of your target and competitor domains.

Example:

```text
Target domain:
ibm.com

currentRank:
1
```

If the target does not appear within the requested result depth:

```json
{
  "currentRank": null,
  "rankingUrl": null,
  "status": "not_ranked"
}
```

> A missing rank means the domain was not observed in the SERP depth collected during that run. It does not mean the domain can never rank elsewhere in Bing.

***

## 📈 Rank tracking

One of the main differences between this Actor and a basic Bing scraper is **persistent rank comparison**.

For every target-domain query, the Actor can compare the current ranking with the previous stored ranking for the same project.

Important fields:

```text
previousRank
currentRank
rankChange
status
rankingUrl
checkedAt
```

Example:

```text
Previous rank: 8
Current rank: 5
Rank change: +3
```

This allows the Actor to function as both:

```text
Bing SERP scraper
+
Bing rank tracker
```

***

### 🆕 Newly ranked domains

If there is no previous ranking and the domain is found in the new SERP, the output can show:

```json
{
  "previousRank": null,
  "currentRank": 1,
  "status": "newly_ranked"
}
```

***

### 🚫 Not ranked

If the target does not appear in the collected organic results:

```json
{
  "currentRank": null,
  "rankingUrl": null,
  "status": "not_ranked"
}
```

Deeper `pages` values can be useful when checking domains that rank below page 1.

***

## 🥊 Competitor ranking comparison

Add competitors using:

```text
competitorDomains
```

For every query, the Actor returns:

```text
domain
position
rankingUrl
status
```

Example:

```json
{
  "competitorRankings": [
    {
      "domain": "wikipedia.org",
      "position": 4,
      "rankingUrl": "https://en.wikipedia.org/wiki/Artificial_intelligence",
      "status": "ranked"
    },
    {
      "domain": "microsoft.com",
      "position": null,
      "rankingUrl": null,
      "status": "not_ranked"
    }
  ]
}
```

This makes it possible to answer questions such as:

```text
Who outranks us?
Which competitor appears most often?
Which competitors do not rank?
How large is the ranking gap?
Which domains dominate our keyword set?
```

***

## 📊 Domain visibility score

When multiple keywords are processed, the Actor can generate a separate visibility summary.

The score rewards stronger organic positions.

For each ranked keyword, the contribution is based on:

```text
100 / organic position
```

Examples:

```text
Position 1  → 100
Position 2  → 50
Position 4  → 25
Position 10 → 10
Not ranked  → 0
```

The final visibility score is averaged across the complete keyword set.

This means domains that:

```text
rank more often
+
rank closer to position 1
```

receive stronger visibility scores.

***

### 📊 Example visibility summary

```json
{
  "type": "visibility_summary",
  "totalQueries": 2,
  "domains": [
    {
      "domain": "apify.com",
      "role": "target",
      "rankedQueries": 2,
      "totalQueries": 2,
      "averagePosition": 2,
      "visibilityScore": 66.67
    },
    {
      "domain": "use-apify.com",
      "role": "competitor",
      "rankedQueries": 1,
      "totalQueries": 2,
      "averagePosition": 2,
      "visibilityScore": 25
    }
  ]
}
```

Useful fields include:

```text
domain
role
rankedQueries
totalQueries
averagePosition
visibilityScore
```

> `averagePosition` is calculated from queries where the domain ranked. The visibility score also accounts for queries where the domain did not rank.

***

## 💰 Sponsored results

Sponsored Bing results are returned separately from organic rankings.

Example:

```json
{
  "ads": [
    {
      "page": 1,
      "title": "Sponsored result",
      "url": "https://example.com/",
      "snippet": "Sponsored description"
    }
  ]
}
```

Ads do **not** receive organic ranking positions in the target-domain rank checker.

This helps keep:

```text
Organic SEO visibility
```

separate from:

```text
Paid search visibility
```

***

## 🔗 Sitelinks

When Bing exposes sitelinks below an organic result, the Actor can return them separately.

Example:

```json
{
  "sitelinks": [
    {
      "page": 1,
      "parentTitle": "Example result",
      "parentUrl": "https://example.com/",
      "title": "Pricing",
      "url": "https://example.com/pricing"
    }
  ]
}
```

Sitelinks are not guaranteed to appear for every query.

If Bing does not expose them:

```json
{
  "sitelinks": []
}
```

***

## ⭐ Featured snippets

When Bing exposes a featured answer element, the Actor can normalize it into:

```text
page
title
url
text
```

Example:

```json
{
  "featuredSnippets": [
    {
      "page": 1,
      "title": "Artificial intelligence",
      "url": "https://example.com/article",
      "text": "Artificial intelligence refers to..."
    }
  ]
}
```

If no featured snippet appears:

```json
{
  "featuredSnippets": []
}
```

***

## 🔎 Related searches

Bing may expose related-search suggestions.

When available, the Actor returns:

```text
page
text
url
```

Example:

```json
{
  "relatedSearches": [
    {
      "page": 1,
      "text": "best web scraping tools",
      "url": "https://www.bing.com/search?q=best+web+scraping+tools"
    }
  ]
}
```

Related searches can be useful for:

```text
Keyword expansion
Content planning
Topic research
SEO research
Search-intent discovery
```

***

## ❓ Questions / People Also Ask

When Bing exposes question elements, the Actor can normalize:

```text
page
question
answer
url
```

Example:

```json
{
  "questions": [
    {
      "page": 1,
      "question": "What is web scraping?",
      "answer": "Web scraping extracts structured information from websites.",
      "url": "https://example.com/web-scraping"
    }
  ]
}
```

When Bing does not provide a question block:

```json
{
  "questions": []
}
```

The Actor does **not generate its own answers**.

Question and answer data must originate from the Bing SERP data available during the search.

***

## ✅ SERP quality validation

The Actor includes result validation before treating a SERP as valid rank-tracking data.

Example fields:

```json
{
  "valid": true,
  "qualityStatus": "passed"
}
```

This is designed to reduce the risk of treating unrelated or degraded search responses as valid ranking data.

***

## 📄 Pagination

You can request:

```text
1–10 Bing pages per query
```

Example:

```json
{
  "pages": 3
}
```

The Actor normalizes organic positions across the requested result depth.

For SEO tracking, this allows deeper checks when the target domain does not appear on page 1.

> More pages increase the amount of SERP data processed and can increase run time and cost.

***

## 🔍 Multiple keywords

Bulk query mode is useful for SEO campaigns.

Example:

```text
best web scraping tools
web scraping api
browser automation platform
data extraction software
```

For each query, the Actor independently returns:

```text
Organic SERP
Target rank
Rank history
Competitor rankings
SERP features
Timestamp
```

When more than one query is processed, the results can also be summarized into domain visibility metrics.

***

## 🗂 Rank-history projects

The `projectKey` lets you separate rank history.

Example:

```text
client-a
client-b
internal-brand
campaign-september
```

Suppose both clients track:

```text
best scraping api
```

Using separate project keys prevents one campaign's previous rank from becoming another campaign's comparison baseline.

***

## 🌍 Market-specific tracking

Bing rankings can vary by market.

Examples:

```text
en-US
en-GB
de-DE
fr-FR
```

This makes the Actor useful for:

```text
International SEO
Market-specific SERP research
Regional competitor comparisons
Localized keyword monitoring
```

> `market` changes Bing's search context. It should not be interpreted as precise GPS-level localization.

***

## ⚡ SEO Rank Overview

The default Dataset includes an **SEO Rank Overview** view with the most useful tracking columns:

```text
Query
Target Domain
Current Rank
Previous Rank
Rank Change
Status
Checked At
Quality
```

This gives SEO teams a fast overview without opening the full JSON result.

The **All fields** view remains available for the complete SERP data.

***

## 🔌 API & integrations

Bing Search Scraper & Rank Tracker can be used programmatically through the **Apify API**.

You can connect results to workflows such as:

- Google Sheets
- Make
- Zapier
- CRMs
- Internal APIs
- Data warehouses
- SEO dashboards
- Reporting systems
- AI agents
- MCP workflows
- Scheduled rank-monitoring pipelines

Each Actor run stores structured results in the default Apify Dataset.

***

## 💡 Example use cases

### 🎯 SEO rank tracking

Track keywords such as:

```text
best web scraping tool
web scraping api
browser automation
```

Target:

```text
example.com
```

Monitor:

```text
Current position
Previous position
Rank change
Ranking URL
Ranking status
```

***

### 🥊 Competitor monitoring

Target:

```text
yourdomain.com
```

Competitors:

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

Analyze:

```text
Which domain ranks highest
Which competitors rank consistently
Which competitors are absent
Average competitor position
Visibility differences
```

***

### 📊 Keyword visibility reporting

Run a portfolio of keywords and compare:

```text
Your domain
Competitor A
Competitor B
Competitor C
```

Use the visibility summary to identify which domain has the strongest Bing presence across the keyword set.

***

### 🔎 SERP research

Collect:

```text
Organic results
Ads
Featured snippets
Sitelinks
Related searches
Question elements
```

Use this for:

```text
Content research
Search-intent analysis
Competitive research
SERP feature monitoring
Keyword expansion
```

***

### 🌍 International SEO

Run the same keyword set using different Bing markets.

Example:

```text
en-US
en-GB
```

Compare how rankings and competitors differ across search markets.

***

## 🛡 Reliability

Bing SERPs are dynamic.

Results can vary because of:

```text
Time
Market
Bing ranking updates
Search context
Available SERP features
Temporary Bing response changes
```

The Actor therefore:

- validates SERP quality
- stores observed timestamps
- keeps organic rankings separate from advertisements
- does not invent missing SERP features
- records `null` when ranking values are unavailable
- returns empty arrays when optional feature groups are absent

Historical rank tracking reflects **observed Bing rankings from Actor runs**, not a permanent universal ranking.

***

## ⚠️ Current limitations

The current version focuses on **Bing web SERP scraping and SEO rank intelligence**.

It does not currently provide:

```text
Google rankings
Yahoo rankings
Bing Maps business scraping
GPS-level local rank grids
Image Search scraping
Video Search scraping
News Search scraping
Full webpage content crawling
Backlink analysis
Keyword search-volume estimates
Keyword difficulty estimates
Automatic AI-generated SEO recommendations
```

These are separate use cases from the current Bing web-search workflow.

***

### ⚠️ Optional SERP features

Bing does not expose every SERP feature on every query.

Therefore these arrays may legitimately be empty:

```text
ads
sitelinks
featuredSnippets
relatedSearches
questions
```

An empty array does not automatically indicate a scraper failure.

For example:

```json
{
  "questions": []
}
```

means no supported question record was observed for that result set.

***

## ❓ FAQ

### How does Bing Search Scraper & Rank Tracker work?

The Actor processes your Bing search queries and collects normalized organic results.

It then:

```text
Collects organic rankings
Validates the SERP
Finds your target domain
Checks competitor domains
Loads previous rank history
Calculates rank movement
Extracts supported SERP features
Stores the new ranking state
Creates structured Dataset output
Calculates visibility when multiple queries are used
```

***

### Can I track multiple keywords?

**Yes.**

Add multiple values to:

```text
queries
```

Each query is processed independently.

***

### Can I track competitors?

**Yes.**

Add domains to:

```text
competitorDomains
```

The Actor checks them against the same organic SERP as your target domain.

***

### How many Bing pages can I scrape?

The current supported range is:

```text
Minimum: 1
Default: 1
Maximum: 10
```

***

### What happens if my domain does not rank?

The Actor returns:

```json
{
  "currentRank": null,
  "rankingUrl": null,
  "status": "not_ranked"
}
```

This means the domain was not observed within the collected SERP depth.

***

### What does `previousRank` mean?

`previousRank` is the stored position from an earlier compatible rank-tracking run for the same logical project/query/domain history.

It allows you to compare past and current Bing positions.

***

### What does `projectKey` do?

It separates rank-history campaigns.

Example:

```text
client-a
client-b
```

This prevents different SEO projects from sharing the same historical ranking state.

***

### What is the visibility score?

The visibility score summarizes how strongly a domain ranks across a group of keywords.

Higher rankings contribute more.

Example:

```text
Position 1 → 100
Position 2 → 50
Position 5 → 20
Not ranked → 0
```

The score is averaged across the complete query set.

***

### Why are some SERP feature arrays empty?

Because Bing does not expose every SERP feature for every search.

For example:

```json
{
  "featuredSnippets": [],
  "relatedSearches": [],
  "questions": []
}
```

can be a completely valid result.

***

### Does the Actor generate missing questions or answers with AI?

**No.**

The Actor does not fabricate PAA/question data.

If Bing does not expose it, the array remains empty.

***

### Can I use the Actor through an API?

**Yes.**

Apify Actors can be started through the Apify API, and Dataset results can be retrieved programmatically.

This makes the Actor suitable for:

```text
Rank dashboards
Scheduled reports
SEO monitoring
Competitor alerts
Data pipelines
Internal tools
Automations
```

***

### Can I export the results?

**Yes.**

Apify Dataset supports exports such as:

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

***

### Can I schedule rank checks?

**Yes.**

You can use Apify scheduling to run the Actor repeatedly.

For example:

```text
Daily
Weekly
Monthly
```

Repeated runs can build useful rank-history comparisons over time.

***

### Is this a Bing Maps scraper?

**No.**

This Actor focuses on **Bing web search results and SEO rankings**.

For Bing Maps business/location scraping, use a dedicated Bing Maps Actor.

***

## 🧭 Recommended SEO workflow

A useful workflow is:

```text
1. Create a stable projectKey
2. Add your important SEO keywords
3. Add your target domain
4. Add the most important competitors
5. Choose the Bing market
6. Select enough pages for your tracking depth
7. Run the Actor
8. Review SEO Rank Overview
9. Export or integrate the Dataset
10. Repeat on a schedule to monitor ranking changes
```

For example:

```json
{
  "queries": [
    "best scraping api",
    "web scraping platform",
    "browser automation tool",
    "data extraction software"
  ],
  "targetDomain": "example.com",
  "competitorDomains": [
    "competitor-a.com",
    "competitor-b.com"
  ],
  "pages": 3,
  "projectKey": "main-seo-project",
  "market": "en-US"
}
```

***

## 💬 Feedback & support

Found a bug or have a feature request?

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

Useful future additions may include:

```text
Additional Bing search verticals
More SERP feature types
More advanced visibility reporting
Ranking alerts
Historical trend reports
CSV-oriented summary views
Additional market controls
```

***

## 🚀 Bing SEO intelligence without manually checking search results

Enter your keywords, target domain, competitors, market, and search depth.

Run the Actor and receive **structured Bing SERP data, domain rankings, competitor positions, historical rank comparisons, visibility metrics, and SERP features** ready for:

```text
SEO monitoring
Competitor research
Reporting
APIs
Dashboards
Automation
Data analysis
```

**Bing Search Scraper & Rank Tracker turns Bing search results into structured SEO intelligence.**

# Actor input Schema

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

Bing search queries to process.

## `targetDomain` (type: `string`):

Domain whose Bing ranking you want to track.

## `competitorDomains` (type: `array`):

Optional competitor domains to compare against the target domain in Bing organic rankings.

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

Number of Bing result pages to process per query.

## `projectKey` (type: `string`):

Used to separate rank-history projects.

## `market` (type: `string`):

Bing market and locale, such as en-US, en-GB, or de-DE.

## Actor input object example

```json
{
  "queries": [
    "apify web scraping"
  ],
  "targetDomain": "apify.com",
  "pages": 1,
  "projectKey": "default",
  "market": "en-US"
}
```

# Actor output Schema

## `results` (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": [
        "apify web scraping"
    ],
    "targetDomain": "apify.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("aerodynamic_tripod/bing-search-scraper-rank-tracker").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": ["apify web scraping"],
    "targetDomain": "apify.com",
}

# Run the Actor and wait for it to finish
run = client.actor("aerodynamic_tripod/bing-search-scraper-rank-tracker").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": [
    "apify web scraping"
  ],
  "targetDomain": "apify.com"
}' |
apify call aerodynamic_tripod/bing-search-scraper-rank-tracker --silent --output-dataset

```

## MCP server setup

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

```

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/OkSlueod4GVyzGKPd/builds/bdCitJzvS8OmjreeH/openapi.json