SERP API · Bing
Bing Search API for structured results with market context.
Send a Bing query with documented market, country, language, location, safe-search, and pagination controls. Receive parsed JSON result collections ready for monitoring and analysis.
Server-side GET API · Start with api_key + engine=bing + q · Talk to a data expert
- Market-aware Market, country, and language
- Origin controls Place with coordinates
- Parsed output Structured result collections
- Result window Offset and count
Web data workflow · bing searchReady
q coffee roasters
mkt en-US
cc
lang us · en
fieldlocation Austin, Texas
fieldlat
fieldsafesearch moderate
fieldfirst
stackResult ledger
Bing visibility, kept in context
Add Bing evidence without flattening its market model.
Define the market, language, origin, filtering, and result window your question requires. The returned objects stay useful because your application can retain that request fingerprint beside them.
01
Market inputs remain explicit
Keep mkt, cc, and lang visible instead of treating locale as a single interchangeable value.
02
Origin can be precise
Use a named location with supported latitude and longitude controls when the observation needs a precise search origin.
03
Parsed collections shorten the path
Consume documented result objects rather than building a Bing page parser into your application.
04
Optionality is visible
Interpret absent ads, images, and other modules as query-dependent until the HTTP outcome and response context say otherwise.
- 01
Query coffee roasters
- 02
Market en-US
- 03
Country us
- 04
Language en
- 05
Origin Austin
- 06
Window 1–10
Product fit
Choose Bing Search when market-aware visibility belongs in the dataset.
This endpoint is designed for Bing-specific observations and parsed output. Validate representative markets and queries against the current documentation before shaping a production consumer.
Strong fit
Measure Bing as its own search surface.
Build keyword, publisher, brand, paid-placement, and cross-engine monitoring around Bing controls rather than assuming another engine's request model applies.
Market and language comparisons
Location and coordinate-based observations
Safe-search controlled research
Offset and result-count windows
Output contract
Parsed Bing response
- Required input
api_key·engine=bing·q- Core output
Metadata and parsed JSON result collections
- Conditional output
Optional modules exposed by the returned page
- Production reference
Coverage boundary: parameters describe the requested search context; they do not make one observed result universal across every user, place, language, or moment.
Bing request controls
Build the market brief before you compare results.
Start with the query, then add the documented market, origin, filtering, and result-window inputs needed for the decision your application will make.
01 · query
Search intent
Supply the search phrase your observation should represent.
q
02 · market
Market, country, and language
Describe the market and language context using the distinct values supported by the endpoint.
mkt cc lang
03 · origin
Location and coordinates
Provide a geotarget location together with supported coordinate values when a precise origin matters.
location lat lon
04 · filtering
Safe-search level
Set the documented filtering value that belongs to the observation.
safesearch
05 · window
Offset and count
Choose the result offset and requested number of results, then store both with returned positions.
first count
Illustrative request GET /v2?api_key=…&engine=bing&q=coffee%20roasters&mkt=en-US&cc=us&lang=en&location=Austin%2C%20Texas&lat=30.2672&lon=-97.7431&safesearch=moderate&first=0&count=10
Implementation note: use only supported combinations and values from the current Bing API documentation. Add parameters deliberately and URL-encode every user-supplied value.
Parsed response model
Keep the market and result window beside every stored position.
Bing Search returns metadata and parsed JSON result collections. Core and optional collections should be consumed as parts of one contextual observation.
01 · context
general
Response-level metadata helps identify and inspect the search observation returned by the endpoint.
02 · primary collection
organic[]
Use returned titles, links, descriptions, and observed positions according to the documented response shape.
03 · discovery
related[]
Related searches can supply query refinements when the returned Bing response exposes that collection.
04 · conditional
module?
Ads, images, and other sections are optional and query-dependent modules; do not assume every successful response contains them.
- 01
1 Inspect the HTTP status.
- 02
2 Validate the documented response shape.
- 03
3 Read returned collections in request context.
- 04
4 Preserve absent-versus-empty states your product needs.
One contextual request
From Bing market brief to application-ready objects.
Your application defines the observation and interprets the returned data. WebScrapingAPI operates the supported Bing retrieval path and documented parsing between those boundaries.
- 01
Define the observation
Choose the Bing query, market, country, language, origin, safe-search level, and result window that answer one clear question.
- 02
Send a server-side request
Call
/v2withapi_key,engine=bing,q, and the documented context your workload needs. - 03
Validate the outcome
Handle transport errors, timeouts, and non-successful HTTP statuses before parsing the JSON body.
- 04
Store context with results
Retain the request fingerprint, returned collections, observation time, and your own schema version for comparable analysis.
Integration
Make one bounded Bing request from your server.
Keep the API key in an environment variable, encode query values, set an explicit timeout, and handle the HTTP outcome before consuming JSON.
Request brief
Start with a representative market.
The examples request a US English observation for “coffee roasters.” Change only documented values and verify the returned shape before expanding the query set.
- Endpoint
https://serpapi.webscrapingapi.com/v2- Secret
WSA_API_KEYstays server-side- Required
api_key+engine=bing+q- Context
mkt+cc+lang- Safety
- 120-second timeout and explicit status handling
: "${WSA_API_KEY:?WSA_API_KEY is required}"
curl --get --fail-with-body --max-time 120 \
"https://serpapi.webscrapingapi.com/v2" \
--data-urlencode "api_key=$WSA_API_KEY" \
--data-urlencode "engine=bing" \
--data-urlencode "q=coffee roasters" \
--data-urlencode "mkt=en-US" \
--data-urlencode "cc=us" \
--data-urlencode "lang=en"import os
import requests
api_key = os.environ.get("WSA_API_KEY")
if not api_key:
raise RuntimeError("WSA_API_KEY is required")
response = requests.get(
"https://serpapi.webscrapingapi.com/v2",
params={
"api_key": api_key,
"engine": "bing",
"q": "coffee roasters",
"mkt": "en-US",
"cc": "us",
"lang": "en",
},
timeout=120,
)
response.raise_for_status()
print(response.json())const apiKey = process.env.WSA_API_KEY;
if (!apiKey) throw new Error("WSA_API_KEY is required");
const url = new URL(
"https://serpapi.webscrapingapi.com/v2?engine=bing&q=coffee%20roasters"
);
url.searchParams.set("api_key", apiKey);
url.searchParams.set("mkt", "en-US");
url.searchParams.set("cc", "us");
url.searchParams.set("lang", "en");
const response = await fetch(url, {
signal: AbortSignal.timeout(120_000),
});
if (!response.ok) {
throw new Error("API status " + response.status);
}
console.log(await response.json());<?php
$apiKey = getenv("WSA_API_KEY");
if ($apiKey === false || $apiKey === "") {
throw new RuntimeException("WSA_API_KEY is required");
}
$parameters = http_build_query([
"api_key" => $apiKey,
"q" => "coffee roasters",
"mkt" => "en-US",
"cc" => "us",
"lang" => "en",
]);
$client = curl_init(
"https://serpapi.webscrapingapi.com/v2?engine=bing&" . $parameters
);
curl_setopt_array($client, [
CURLOPT_RETURNTRANSFER => true,
CURLOPT_TIMEOUT => 120,
]);
$body = curl_exec($client);
$status = curl_getinfo($client, CURLINFO_RESPONSE_CODE);
$error = curl_error($client);
curl_close($client);
if ($body === false) throw new RuntimeException($error);
if ($status < 200 || $status >= 300) {
throw new RuntimeException("API status " . $status);
}
echo $body;package main
import (
"fmt"
"io"
"net/http"
"net/url"
"os"
"time"
)
func main() {
apiKey := os.Getenv("WSA_API_KEY")
if apiKey == "" { panic("WSA_API_KEY is required") }
requestURL := "https://serpapi.webscrapingapi.com/v2?" +
"api_key=" + url.QueryEscape(apiKey) +
"&engine=bing&q=" + url.QueryEscape("coffee roasters") +
"&mkt=en-US&cc=us&lang=en"
client := &http.Client{Timeout: 120 * time.Second}
response, err := client.Get(requestURL)
if err != nil { panic(err) }
defer response.Body.Close()
if response.StatusCode < 200 || response.StatusCode >= 300 {
panic(fmt.Sprintf("API status %d", response.StatusCode))
}
body, err := io.ReadAll(response.Body)
if err != nil { panic(err) }
fmt.Println(string(body))
}import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
public final class BingSearchExample {
public static void main(String[] args) throws Exception {
String apiKey = System.getenv("WSA_API_KEY");
if (apiKey == null || apiKey.isBlank()) {
throw new IllegalStateException("WSA_API_KEY is required");
}
String key = URLEncoder.encode(apiKey, StandardCharsets.UTF_8);
String url = "https://serpapi.webscrapingapi.com/v2?api_key=" + key
+ "&engine=bing&q=coffee%20roasters"
+ "&mkt=en-US&cc=us&lang=en";
var request = HttpRequest.newBuilder()
.uri(URI.create(url))
.timeout(Duration.ofSeconds(120))
.GET().build();
var response = HttpClient.newHttpClient()
.send(request, HttpResponse.BodyHandlers.ofString());
if (response.statusCode() < 200 || response.statusCode() >= 300) {
throw new IllegalStateException("API status " + response.statusCode());
}
System.out.println(response.body());
}
}using System;
using System.Net;
using System.Net.Http;
var rawApiKey = Environment.GetEnvironmentVariable("WSA_API_KEY");
if (string.IsNullOrWhiteSpace(rawApiKey)) {
throw new InvalidOperationException("WSA_API_KEY is required");
}
var apiKey = WebUtility.UrlEncode(rawApiKey);
var requestUrl =
"https://serpapi.webscrapingapi.com/v2?api_key=" + apiKey +
"&engine=bing&q=coffee%20roasters" +
"&mkt=en-US&cc=us&lang=en";
using var client = new HttpClient {
Timeout = TimeSpan.FromSeconds(120)
};
var response = await client.GetAsync(requestUrl);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());require "net/http"
require "uri"
api_key = ENV["WSA_API_KEY"]
raise "WSA_API_KEY is required" if api_key.nil? || api_key.empty?
uri = URI(
"https://serpapi.webscrapingapi.com/v2?engine=bing&q=coffee%20roasters"
)
parameters = URI.decode_www_form(uri.query) + [
["api_key", api_key],
["mkt", "en-US"],
["cc", "us"],
["lang", "en"]
]
uri.query = URI.encode_www_form(parameters)
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
http.open_timeout = 10
http.read_timeout = 120
response = http.get(uri.request_uri)
unless response.is_a?(Net::HTTPSuccess)
raise "API status #{response.code}"
end
puts response.bodyBuyer workflows
Use Bing observations where another engine would leave a blind spot.
Design the query set and comparison rules around the business question, then preserve the Bing request fingerprint with every result used downstream.
Search intelligence
Bing keyword visibility
Track returned positions across controlled market, language, origin, and result-window combinations.
Explore SERP monitoring →
Brand coverage
Publisher and brand presence
Observe approved domains across Bing query groups without treating one absence as a universal finding.
Explore brand protection →
Paid visibility
Returned ad placements
Capture paid-result modules when present and keep campaign interpretation inside your review process.
Explore ad verification →
Market research
Cross-engine landscape analysis
Add Bing sources and related queries to research that would otherwise represent only one search engine.
Explore market research →
Engine comparison
Choose the engine and response model your workflow actually needs.
Each child endpoint has its own controls and documented output. Design and test the consumer for the selected engine instead of assuming interchangeable request shapes.
Parsed collections
Google Search
Location, language, device, vertical, and pagination controls for Google result observations.
Compare Google →
Current engine
Bing Search
Market, country, language, origin, safe-search, and result-window controls with parsed collections.
Bing
Source payload
DuckDuckGo Search
Region, interface-language, safe-search, and time controls with source SERP HTML in a JSON envelope.
Compare DuckDuckGo →
Source payload
Yandex Search
Regional, language, device, page, and time controls with source SERP HTML in a JSON envelope.
Compare Yandex →
Need a different operating boundary? Scraper API returns an eligible public page for your extractor, while Managed Data can add an agreed schema, quality process, schedule, and delivery.
Pricing and evaluation
Test the Bing contexts your buying decision depends on.
Start with representative queries, markets, origins, and expected modules. Review current pricing and plan details before estimating a recurring workload.
- 01
Representative queries Include expected head, long-tail, and zero-module cases.
- 02
Required contexts Exercise the markets, languages, origins, and filtering levels you will store.
- 03
Consumer states Verify successful responses, optional collections, timeouts, and documented errors.
Bing Search API FAQ
Questions to settle before integration.
Confirm the output model, market controls, optionality, and product boundary before expanding beyond a representative request.
What does Bing Search API return?
Bing Search API returns request metadata and parsed JSON result collections. Documented collections include organic and related results; ads, images, and other modules are optional and appear only when the returned Bing page exposes them.
Which controls define a Bing market?
Use mkt for a market, cc for country context, lang for language, and location with lat and lon for a precise search origin. They describe different parts of the request, so preserve the values you send with every stored observation.
How do first and count control pagination?
The first parameter sets the result offset and count requests the size of the result window. Store both values with returned positions so separate pages are not compared as though they were the same observation.
Does a missing result module mean the request failed?
Not by itself. Inspect the HTTP status and documented error body first. A successful response can omit an optional collection when that Bing page did not expose the corresponding result module for the supplied query and context.
Can I apply Bing safe-search filtering?
Yes. Use the documented safesearch parameter for the filtering level required by the request. Keep that value with the observation because changing it can change which results and modules are returned.
How is Bing Search API different from Scraper API?
Bing Search API accepts Bing-specific search context and returns documented metadata plus parsed result collections. Scraper API retrieves an eligible public webpage, leaving extraction and the downstream data model with your application.
Your first Bing observation
Put market context beside every result your application uses.
Start with one documented Bing request, or speak with our team about recurring search-data delivery.