How to Scrape Bing Recipe Results (2026)

I wanted the Bing recipe carousel as data - the swipeable strip of dish cards with a rating and a cook time on each - so in July 2026 I sat down to work out how to scrape Bing recipes properly. The naive version is a few lines of Python. The version that actually returns a rating, a cook time, and a clean source link for every card is a real project, because those fields are not sitting in the SERP HTML the way the title is.

This guide is the record of what I ran. I show the Python that pulls the recipe links, where the rating and cook time actually live, the traps that break a first draft, and the one-request API route I use when I need the whole carousel as JSON.

What do Bing recipe results contain?

Bing recipe results contain four fields per card: the recipe title, a rating, a cook time, and the source site that published it. Bing renders them as a carousel of recipe cards near the top of the SERP for a dish query, and every one of those four fields comes from Recipe structured data that the publishing site marks up, not from anything Bing computes itself.

That matters for scraping because it tells you where each field really comes from. Google’s Recipe structured-data documentation lists the exact properties, and Bing reads the same schema.org vocabulary: the title is name (the one required property), the rating is aggregateRating, and the cook time is cookTime or totalTime. The time values are ISO 8601 durations, so a thirty-minute bake is PT30M, not the “30 min” string you see on the card.

The source field is the one that bites people. Each card links to the recipe’s origin page, but Bing wraps that link in a bing.com/ck/a redirect with the real destination base64url-encoded inside, so the domain you want is not sitting in the href as plain text. Before any of that parsing is worth doing, though, it helps to know what Bing’s own rules say about hitting the recipe SERP with a script.

Can you scrape Bing recipe results?

You can scrape Bing recipe results because they render on a public SERP to any logged-out visitor, but two facts shape how you do it: Bing’s robots.txt disallows the search path, and there is no official recipe API to fall back on. I fetched https://www.bing.com/robots.txt live in July 2026, and the catch-all User-agent: * block disallows the paths the recipe carousel lives on:

User-agent: *
Disallow: /search
Disallow: /Search
Disallow: /results

robots.txt is a crawling convention rather than a law, so it records Bing’s stated wishes rather than a binding rule. On the legal side, US courts have leaned toward scrapers of public data: in hiQ Labs v. LinkedIn the Ninth Circuit found that accessing publicly available data is unlikely to be unauthorized access under the CFAA. That is not a green light. You still owe attention to Microsoft’s terms, to recipe copyright (the ingredient list and method text belong to the publisher, not to you to republish wholesale), and to the rules in your jurisdiction. I go deeper in is scraping Bing legal.

There is also no shortcut through a first-party endpoint, because Microsoft retired the standalone Bing Search APIs on August 11, 2025, and the recipe results were never exposed as an API even before that. So the only route to Bing recipe data in 2026 is the public SERP, which brings us to the Python.

How do you scrape Bing recipe results with Python?

You scrape Bing recipe results with Python in two passes: fetch the recipe SERP and pull each recipe link, then follow those links and read the rating and cook time out of each page’s Recipe markup. The reason it takes two passes is the thing most tutorials skip. The rating and cook time are not reliably in the SERP HTML, because Bing hydrates the carousel client side while the raw response hands you the recipe links and little else.

Start with the SERP fetch. The trap here is that Bing answers an automated request with HTTP 200 and a hidden challenge page, so a status check passes while the results are gone. Assert on the body, not the status code:

import requests
from bs4 import BeautifulSoup

r = requests.get(
    "https://www.bing.com/search",
    params={"q": "chicken alfredo recipe"},
    timeout=25,
)
if "challenge/verify" in r.text:
    raise SystemExit("Bing served a challenge page, not results")

soup = BeautifulSoup(r.text, "html.parser")
for li in soup.select("li.b_algo")[:6]:
    h2 = li.find("h2")
    a = h2.find("a") if h2 else None
    if a:
        print(h2.get_text(strip=True))
        print(a["href"])   # https://www.bing.com/ck/a?... real URL is base64url-encoded inside

That gives you the recipe titles and their links, with the real destination hidden inside a bing.com/ck/a redirect you have to decode. To turn a link into a rating and a cook time, fetch the source page and read its Recipe JSON-LD, which is where aggregateRating, cookTime, and totalTime actually live:

import json

def recipe_fields(html):
    soup = BeautifulSoup(html, "html.parser")
    for tag in soup.find_all("script", type="application/ld+json"):
        try:
            data = json.loads(tag.string or "{}")
        except json.JSONDecodeError:
            continue
        for block in (data if isinstance(data, list) else [data]):
            if "Recipe" in str(block.get("@type", "")):
                rating = (block.get("aggregateRating") or {}).get("ratingValue")
                pub = block.get("publisher")
                return {
                    "title": block.get("name"),
                    "rating": rating,
                    "cook_time": block.get("cookTime") or block.get("totalTime"),  # e.g. PT30M
                    "source": pub.get("name") if isinstance(pub, dict) else None,
                }
    return None

The cook_time comes back as an ISO 8601 duration like PT30M, so you convert it with a library such as isodate or a small regex before it is useful in a spreadsheet. Now count the moving parts in this DIY route:

• The challenge page. A burst of SERP fetches from one IP starts returning challenge/verify inside a 200, and every source-page fetch is another request Bing can flag.
• The ck/a redirect. Every recipe link is wrapped, so you decode the base64url payload or issue a follow-up request just to learn the source domain.
• Two requests per recipe. One SERP fetch plus one fetch per source page to get the rating and cook time, which multiplies your request count and your block risk together.
• Volatile markup. Not every publisher ships clean Recipe JSON-LD, and Bing’s carousel classes shift, so the parser needs upkeep.

None of that is hard on its own. Together, run across a residential proxy pool to survive the challenge page, it is the maintenance project every search scraper turns into once you pass a few hundred queries. That is the point where handing the blocking and parsing to an API pays for itself.

How do you scrape Bing recipes without getting blocked?

You scrape Bing recipes without getting blocked by sending the dish query to a scraper API that returns the recipe carousel as parsed JSON, with the proxy rotation, the challenge handling, and the ck/a decoding done server side. One request replaces the whole two-pass DIY pipeline: no source-page fetches, no ISO 8601 wrangling, no redirect to unwrap.

I use ChocoData for this. The call is a single GET with the dish query and an API key, against the Bing recipes endpoint:

curl "https://api.chocodata.com/api/v1/bing/recipes?q=chicken+alfredo&api_key=$CHOCO_API_KEY"

The same call from Python, which is the version I run in pipelines:

import os, requests

resp = requests.get(
    "https://api.chocodata.com/api/v1/bing/recipes",
    params={"q": "chicken alfredo", "api_key": os.environ["CHOCO_API_KEY"]},
    timeout=30,
)
data = resp.json()
for recipe in data["recipes"]:
    print(recipe["title"], recipe["rating"], recipe["total_time"])
    print(recipe["source"], recipe["url"])   # source site and decoded destination URL

Each card comes back with the four fields you actually wanted - title, rating, total_time, and source - plus the url already decoded from the ck/a redirect, so there is nothing left to parse or follow. Because the anti-bot work is server side, the language on your end does not matter, and the same endpoint shape covers Bing’s other verticals by swapping recipes for search, images, or videos. If you want the mechanics of why the raw route gets challenged in the first place, I break them down in how to scrape Bing without getting blocked.

DIY or managed: which should you use?

Choose the DIY Python route for a one-off pull and the managed API for anything ongoing, because the cost of each flips as your query count grows. For a handful of dishes from a clean residential IP, the two-pass requests and JSON-LD script above is fine, and you keep full control of the fetch. For continuous collection across many dishes and markets, the source-page fetches, the challenge retries, and the ck/a decoding turn into standing maintenance, and offloading them is the cheaper path once you price in your own time.

If I needed Bing recipe data tomorrow, I would not rebuild the proxy-and-CAPTCHA stack to chase a rating and a cook time that the carousel already computed. For a quick experiment I would run the DIY parse and accept the occasional challenge page. For anything I had to keep running, I would send the query to the recipes endpoint and spend my time on the data instead. If you want to see how the managed options compare on coverage and price before you commit, I rank them in best Bing scrapers and APIs in 2026.