# Bing Images Scraper (`parsebird/bing-images-scraper`) Actor

Scrape Bing Images search results: full-size image URLs, thumbnails, source pages, titles, descriptions, width, height and media IDs. Filter by size, type, color, license, layout and date. Export JSON, CSV or Excel.

- **URL**: https://apify.com/parsebird/bing-images-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.49 / 1,000 images

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### Bing Images Scraper

Bing Images Scraper extracts image search results from [Bing Images](https://www.bing.com/images): full-size image URLs, thumbnails, source pages, titles, width, height and Bing media IDs for any search query.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Run many queries at once, apply Bing's own size, type, color, license, layout, date and people filters, and collect up to 1,000 unique images per query, which is about twice what a single Bing search shows.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

```
Use the Apify actor "parsebird/bing-images-scraper" via the ApifyClient to scrape Bing Images search results. Example: client.actor("parsebird/bing-images-scraper").call(run_input={"queries": ["golden retriever puppies", "beagle puppies"], "maxResults": 100, "safeSearch": "Moderate", "imageSize": "Large", "imageType": "photo"}). Inputs: queries (array of strings; blank and duplicate values removed; takes precedence over query), query (string, optional single query used when queries is empty; if both are empty the actor searches "cute puppies"), maxResults (integer per query, default 100, 1-1000), safeSearch (string, default "Moderate"; Off, Moderate, Strict), imageSize ("" = all, Small, Medium, Large, Wallpaper), imageType ("" = all, photo, clipart, linedrawing, animatedgif, transparent), color ("" = all, ColorOnly, Monochrome, Black, Blue, Brown, Gray, Green, Orange, Pink, Purple, Red, Teal, White, Yellow), license ("" = all, Any, Public, Share, ShareCommercially, Modify, ModifyCommercially), aspectRatio ("" = all, square, wide, tall), freshness ("" = all, day, week, month, year), people ("" = all, faces, portrait), proxyConfiguration (object, default Apify Proxy). Output per image: imageUrl, thumbnailUrl, sourceUrl, sourceDomain, title, description, mediaId, width, height, aspectRatio, query, position, bingUrl. Pricing: pay per image. Full API spec: https://apify.com/parsebird/bing-images-scraper/api. Get an API token at https://console.apify.com/settings/integrations.
```

### What is Bing Images Scraper?

**Bing Images Scraper** is a scraping tool and **Bing Image Search API alternative** that turns Bing image search results into structured data. For every image it returns the **direct link to the full-size image file**, the Bing thumbnail, the **web page where the image was found**, the title and description, the original **width and height in pixels**, and Bing's media ID for deduplication.

The easiest way to try it: open the Actor, keep the prefilled query `golden retriever puppies` and click **Start**. You get 50 images in a few seconds.

### What can Bing Images Scraper do?

- 🔎 **Many queries in one run**: enter a list of searches and get all results in one dataset, each row tagged with its `query` and `position`
- 🖼️ **Full-size image URLs**, not only thumbnails, plus the source page and its domain
- 📐 **Image dimensions**: original width, height and aspect ratio for each image, so you can drop small images without downloading them
- 🎛️ **All Bing Images filters**: size, type (photo, clipart, line drawing, animated GIF, transparent), color, license, layout, date and people
- 🛡️ **SafeSearch**: Off, Moderate or Strict, the same levels as on Bing
- 📈 **Up to 1,000 images per query**: one Bing search shows about 500 images. When you ask for more, the Actor adds images from Bing's filtered result lists for the same query and removes duplicates by media ID
- ⚙️ Runs on Apify: [schedule](https://docs.apify.com/platform/schedules) recurring runs, call it through the [API](https://docs.apify.com/api/v2), connect it to [integrations](https://apify.com/integrations) like Google Sheets, Slack, Zapier or Make, and export results as JSON, CSV, Excel, XML or HTML

### What data can you extract from Bing Images?

| Field | Description |
|-------|-------------|
| `imageUrl` | Full-resolution image URL (direct link to the image file on its host) |
| `thumbnailUrl` | Bing CDN thumbnail URL |
| `sourceUrl` | URL of the web page where the image appears |
| `sourceDomain` | Domain of the source page, as Bing shows it |
| `title` | Image title, usually the title of the source page |
| `description` | Image description as Bing shows it (often the same as the title) |
| `mediaId` | Bing's internal media ID, useful for deduplication |
| `width`, `height` | Original image size in pixels |
| `aspectRatio` | Width divided by height, rounded to four decimal places |
| `query` | The search query that produced this image |
| `position` | Result position for that query, starting at 1 |
| `bingUrl` | Link to the image's Bing detail view |

### How to scrape Bing Images

1. Open [Bing Images Scraper](https://apify.com/parsebird/bing-images-scraper) in Apify Console.
2. Enter one or more searches in **Search queries**, for example `golden retriever puppies`.
3. Set **Max images per query**.
4. Optionally pick filters: SafeSearch, image size, type, color, license, layout, date or people.
5. Click **Start** and wait for the run to finish.
6. Download the images from the **Output** tab as JSON, CSV, Excel, XML or HTML, or read them with the API.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `queries` | array | No | `[]` | Searches to run one after another. Blank and duplicate values are removed. Takes precedence over `query` |
| `query` | string | No | `cute puppies` when both query fields are empty | Single search query, used when `queries` is empty |
| `maxResults` | integer | No | `100` | Maximum images per query (1-1,000) |
| `safeSearch` | string | No | `Moderate` | `Off`, `Moderate` or `Strict` |
| `imageSize` | string | No | `""` (all) | `Small`, `Medium`, `Large`, `Wallpaper` |
| `imageType` | string | No | `""` (all) | `photo`, `clipart`, `linedrawing`, `animatedgif`, `transparent` |
| `color` | string | No | `""` (all) | `ColorOnly`, `Monochrome`, `Black`, `Blue`, `Brown`, `Gray`, `Green`, `Orange`, `Pink`, `Purple`, `Red`, `Teal`, `White`, `Yellow` |
| `license` | string | No | `""` (all) | `Any`, `Public`, `Share`, `ShareCommercially`, `Modify`, `ModifyCommercially` |
| `aspectRatio` | string | No | `""` (all) | `square`, `wide`, `tall` |
| `freshness` | string | No | `""` (all) | `day`, `week`, `month`, `year` |
| `people` | string | No | `""` (all) | `faces` or `portrait` (head and shoulders) |
| `proxyConfiguration` | object | No | Apify Proxy | Proxy settings. The default works for most runs |

**Single query**

```json
{
  "query": "golden retriever puppies",
  "maxResults": 100,
  "safeSearch": "Moderate",
  "imageSize": "Large",
  "imageType": "photo",
  "color": "",
  "license": ""
}
```

**Several queries in one dataset**

`maxResults` is a per-query limit, so this run can return up to 300 rows:

```json
{
  "queries": ["golden retriever puppies", "labrador puppies", "beagle puppies"],
  "maxResults": 100,
  "safeSearch": "Moderate"
}
```

#### License filter values

The license values follow the License menu on Bing Images:

| Value | Bing label |
|-------|-----------|
| `Any` | All Creative Commons |
| `Public` | Public domain |
| `Share` | Free to share and use |
| `ShareCommercially` | Free to share and use commercially |
| `Modify` | Free to modify, share and use |
| `ModifyCommercially` | Free to modify, share and use commercially |

Bing assigns these labels automatically. Always check the license on the source page before you reuse an image.

### Output example

```json
{
  "imageUrl": "https://thehappypuppysite.com/wp-content/uploads/2017/12/puppy3.jpg",
  "thumbnailUrl": "https://ts2.mm.bing.net/th?id=OIP.Vv-z2g6YyvXlFaozpcldpAHaIW&pid=15.1",
  "sourceUrl": "https://thehappypuppysite.com/pictures-of-golden-retrievers/",
  "sourceDomain": "thehappypuppysite.com",
  "title": "Pictures Of Golden Retrievers - Golden Retriever Photo Gallery",
  "description": "Pictures Of Golden Retrievers - Golden Retriever Photo Gallery",
  "mediaId": "C7CCEB7D60D67C0992C2E3E14AD933F51374ACE7",
  "width": 1200,
  "height": 1352,
  "aspectRatio": 0.8876,
  "query": "golden retriever puppies",
  "position": 1,
  "bingUrl": "https://www.bing.com/images/search?view=detailV2&ccid=Vv%2bz2g6Y&id=C7CCEB7D60D67C0992C2E3E14AD933F51374ACE7&thid=OIP.Vv-z2g6YyvXlFaozpcldpAHaIW&mediaurl=https%3a%2f%2fthehappypuppysite.com%2fwp-content%2fuploads%2f2017%2f12%2fpuppy3.jpg&cdnurl=https%3a%2f%2fth.bing.com%2fth%2fid%2fR.56ffb3da0e98caf5e515aa33a5c95da4%3frik%3d56x0E%252fUz2Urh4w%26pid%3dImgRaw%26r%3d0&exph=1352&expw=1200&q=golden+retriever+puppies&FORM=IRPRST&ck=CDEFA883931CFF982F173EC3B0C40595&selectedIndex=0&itb=0&adlt=moderate"
}
```

When Bing doesn't give a value, the field is `null` (numbers) or an empty string (text).

### Use Bing Images Scraper from Python or JavaScript

Install the client with `pip install apify-client` or `npm install apify-client`, and get your API token from [Apify Console](https://console.apify.com/settings/integrations).

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")

run = client.actor("parsebird/bing-images-scraper").call(run_input={
    "queries": ["modern kitchen interior", "scandinavian living room"],
    "maxResults": 200,
    "imageSize": "Wallpaper",
    "aspectRatio": "wide",
})

for image in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(image["width"], image["height"], image["imageUrl"])
```

**JavaScript**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<APIFY_TOKEN>' });

const run = await client.actor('parsebird/bing-images-scraper').call({
    queries: ['oak tree'],
    maxResults: 100,
    license: 'Public',
    safeSearch: 'Strict',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((img) => console.log(img.position, img.sourceDomain, img.imageUrl));
```

### Use cases

- **Machine learning datasets**: collect labeled images per keyword to train or test image classifiers, with dimensions to filter out small images first.
- **Content and design research**: find visual references, mood boards and stock-style images by color, layout or type.
- **Brand and product monitoring**: track which sites show images of your products or logo, and where they rank for a keyword.
- **SEO and image ranking**: see which domains rank in Bing Images for your target keywords, and at which positions.
- **Open-license image sourcing**: start from Bing's public domain or Creative Commons filters, then confirm the license on the source page.
- **Reverse lookups at scale**: the `sourceUrl` and `sourceDomain` fields show which pages publish images for a topic.

### How it works

1. The Actor runs each query on Bing Images with your SafeSearch level and filters, the same way the Bing Images results page does.
2. It reads the result grid page by page and saves every image as soon as it is parsed.
3. Bing shows about 500 images for one search. If you asked for more, the Actor continues with Bing's own filtered result lists for the same query (image sizes, layouts, types and colors you haven't already set) and skips images it has already saved.
4. The run moves to the next query when it reaches **Max images per query** or when Bing has no more results, and stops early if your spending limit is reached.

### How much does it cost to scrape Bing Images?

Bing Images Scraper uses pay-per-event pricing. You pay for each image saved to the dataset. Platform usage (compute and proxy) is included in the event price, so it isn't billed separately.

| Event | Free | Bronze | Silver | Gold |
|-------|------|--------|--------|------|
| Image scraped | $2.99 / 1,000 | $2.49 / 1,000 | $1.99 / 1,000 | **$1.49 / 1,000** |

One saved image is one charge. At Free plan prices, the prefilled run of 50 images costs about $0.15, 100 images cost about $0.30 and 1,000 images cost $2.99. To control spending, use **Max images per query**. The run also stops when it reaches the maximum cost per run you set in Apify Console.

### Is it legal to scrape Bing Images?

Bing Images Scraper only collects search results that Bing shows publicly to any visitor. It doesn't log in and doesn't access private data. The images themselves belong to their owners and are hosted on third-party websites. Bing's license filter is a starting point, not a guarantee, so check the rights on the source page before you reuse, publish or train on an image. If results include personal data, such as photos of people, make sure your use complies with laws like the GDPR. For more background, read Apify's article [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

### Other image scrapers from ParseBird

| Actor | What it does |
|-------|--------------|
| [Startpage Images Scraper](https://apify.com/parsebird/startpage-images-scraper) | Image search results from Startpage, with region and language filters |
| [Unsplash Image Scraper](https://apify.com/parsebird/unsplash-image-scraper) | Free high-resolution photos from Unsplash |
| [Pexels Stock Image Scraper](https://apify.com/parsebird/pexels-stock-image-scraper) | Stock photos and metadata from Pexels |
| [Pixabay Image Scraper](https://apify.com/parsebird/pixabay-image-scraper) | Royalty-free images from Pixabay |
| [Pinterest Image Downloader](https://apify.com/parsebird/pinterest-image-downloader) | Original-size images from Pinterest pins |
| [Image Resizer API](https://apify.com/parsebird/image-resizer-api) | Resize and convert images in bulk |

### FAQ

**Do I need a Bing or Microsoft API key?**
No. The Actor reads the same public results the Bing Images website shows, so you don't need an Azure account or a Bing Search API subscription.

**How many images can I get per query?**
Up to 1,000. A single Bing image search shows about 500 images. Above that, the Actor adds images from Bing's filtered result lists for the same query. Very specific queries, or queries with several filters, can have fewer results than you ask for. The run then saves everything Bing has.

**Are positions the same as on Bing?**
For the first ~500 images, `position` follows Bing's order for your query and filters. Images collected after that come from Bing's filtered lists, so their positions show the order in which they were collected.

**Why do some filters seem to have no effect together?**
The Actor sends your filters to Bing exactly as the website does, but Bing doesn't apply every combination strictly. In our tests, Bing mostly ignored the **Layout** filter when it was combined with **Date**. Use fewer filters, or filter on `width`, `height` and `aspectRatio` after the run.

**Why is `description` often the same as `title`?**
Bing usually shows the source page title as the image description. The Actor returns both as Bing provides them.

**Does the Actor download the image files?**
No. It returns direct image URLs. To save the files, download them from `imageUrl`, or use `thumbnailUrl` for small previews served by Bing.

**Can I schedule or automate runs?**
Yes. Create a [schedule](https://docs.apify.com/platform/schedules) in Apify Console, call the Actor through the [API](https://apify.com/parsebird/bing-images-scraper/api), or send results to Google Sheets, Slack, Zapier or Make with [integrations](https://apify.com/integrations).

**Something isn't working. What should I do?**
Open an issue on the [Issues tab](https://apify.com/parsebird/bing-images-scraper/issues) with the input you used. We read every report.

# Changelog

This Actor's version history is a separate document: https://apify.com/parsebird/bing-images-scraper/changelog.md

# Actor input Schema

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

Enter one or more Bing Images searches. Each query is scraped up to Max images per query. Blank lines and duplicates are removed. When this list has queries, the single Search query field below is ignored.

## `query` (type: `string`):

Optional single query, used only when Search queries is empty. If both are empty, the Actor searches for 'cute puppies'.

## `maxResults` (type: `integer`):

Maximum number of images to save for each query (1-1,000). Bing shows about 500 images for one search; above that the Actor adds images from Bing's own size, shape, type and color filters for the same query, without duplicates.

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

Bing SafeSearch level for adult content. Strict filters adult images and text, Moderate filters adult images, Off shows everything.

## `imageSize` (type: `string`):

Keep only images of this size, as Bing defines it.

## `imageType` (type: `string`):

Keep only photos, clipart, line drawings, animated GIFs or images with a transparent background.

## `color` (type: `string`):

Keep only color images, black and white images, or images with one dominant color.

## `license` (type: `string`):

Keep only images with this license type, as Bing labels it. Always check the license on the source page before reusing an image.

## `aspectRatio` (type: `string`):

Keep only square, wide (landscape) or tall (portrait) images.

## `freshness` (type: `string`):

Keep only images Bing found within this time frame.

## `people` (type: `string`):

Keep only images of faces, or head-and-shoulders portraits.

## `proxyConfiguration` (type: `object`):

Proxy servers used to reach Bing. The default Apify Proxy works for most runs.

## Actor input object example

```json
{
  "queries": [
    "golden retriever puppies"
  ],
  "maxResults": 50,
  "safeSearch": "Moderate",
  "imageSize": "",
  "imageType": "",
  "color": "",
  "license": "",
  "aspectRatio": "",
  "freshness": "",
  "people": "",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (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": [
        "golden retriever puppies"
    ],
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/bing-images-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": ["golden retriever puppies"],
    "maxResults": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/bing-images-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": [
    "golden retriever puppies"
  ],
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call parsebird/bing-images-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/bing-images-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/lELuzZVAtVRJkT9GZ/builds/LEZTaRoZ9ERzwKQhP/openapi.json
