SERPHouse

Read the connected SERPHouse account -- `results.email`, `results.name` and `results.plan[]` with `name`, `plan_type`, `price`, `currency`, `credit_available` and `credit_total`. CALL THIS BEFORE A BATCH: every search on this provider spends credits from a finite monthly allowance that does NOT roll over (Free 4,000, Basic 400,000, Regular 800,000), a standard SERP costs 10 credits, a Google autocomplete 5, and a top-100 search 10 per page scraped. Running out answers HTTP 402 on every search tool at once, which reads like a broken integration rather than an empty wallet. A reference lookup: it scrapes nothing, answers in well under a second and consumed no credits when measured on 2026-09-24.

List every search-engine domain SERPHouse will scrape, as a flat array of strings in `results` (`google.com`, `google.co.uk`, `bing.com`, `us.yahoo.com`, ...). This is the authoritative source for the `domain` argument on every search tool -- an unsupported domain is refused rather than silently substituted, and Yahoo in particular requires a REGIONAL domain (`us.yahoo.com`), never bare `yahoo.com`. A reference lookup: it scrapes nothing, answers in well under a second and consumed no credits when measured on 2026-09-24.

List the language codes one engine accepts, as a `results` object mapping code to human name. THE THREE ENGINES SPELL LANGUAGES DIFFERENTLY and a code from the wrong list is not accepted: Google uses `en`/`fr`, Bing uses locale form `en-US`/`fr-FR`, Yahoo uses `lang_en`. Pass `google`, `bing` or `yahoo` as `type`. AN UNRECOGNISED `type` IS NOT REFUSED -- measured 2026-09-24, `/language/list/nosuch` answers 200 with BING's list -- so a typo returns a plausible-looking vocabulary for the wrong engine rather than an error. A reference lookup: it scrapes nothing, answers in well under a second and consumed no credits when measured on 2026-09-24.

Search SERPHouse's geo-targeting database and get back rows carrying `id`, `name`, `loc`, `type` and `country_code`. THE `loc` FIELD OF A ROW IS WHAT THE SEARCH TOOLS TAKE -- a full comma-joined string such as `Alba,Texas,United States`, not a free-text place name -- and its `id` is what they take as `loc_id`. Google and Bing have SEPARATE databases, so pass `type=bing` when the search will target Bing. Guessing a location string instead of looking it up here is the most common cause of a search that answers but targets the wrong place. A reference lookup: it scrapes nothing, answers in well under a second and consumed no credits when measured on 2026-09-24.

Poll one scheduled task. The state is in `msg`, not in `status`: `Waiting for a process` while it is queued and `Completed` once the result can be fetched (measured 2026-09-24). `status` stays `success` for both -- it reports that the QUESTION was answered, not that the task is done. AN UNKNOWN ID ANSWERS HTTP 404 with `msg: "Not found"` while still saying `status: "success"`, so treat the HTTP status as the authority on whether the id exists. Fetch the result with `serphouse_get_serp_get`. A reference lookup: it scrapes nothing, answers in well under a second and consumed no credits when measured on 2026-09-24.

Fetch a stored SERP result by task id. Works for a task queued with `serphouse_post_serp_schedule` or `serphouse_post_serp_google_advanced_scheduled` AND for a completed LIVE search, whose id is in `results.search_metadata.id` -- so a live result can be re-read later without paying for the scrape twice (measured 2026-09-24). The body is `results.search_metadata`, `results.search_parameters` and `results.results` with the parsed blocks. An unknown or unfinished id answers HTTP 404. A reference lookup: it scrapes nothing, answers in well under a second and consumed no credits when measured on 2026-09-24.

Run a real-time search through the GET form of SERPHouse's live endpoint and get the parsed SERP straight back. DEPRECATED BY THE VENDOR -- its own documentation page carries a deprecation notice -- and `serphouse_post_serp_live` is the same operation in the supported form, so prefer that one. Only `q` is required here, but a search without `domain`, `lang`, `device` and `serp_type` is answered from SERPHouse's defaults rather than from what you meant. The credential is NEVER sent as the `api_token` query parameter this endpoint also accepts: it rides in the `Authorization` header, so it cannot end up in a log line or a referrer. THIS CALL IS SLOW -- measured 31.5s and 41.2s on 2026-09-24 against the live API, so allow minutes rather than seconds. A 200 IS NOT A SUCCESS ON THIS PROVIDER: a scrape that failed upstream answers HTTP 200 with `{"status": "error", "msg": "Please try again"}`, so this integration reads the body's `status` field and raises instead of handing back an empty result. Those failures cost NO credits (measured 2026-09-24: the balance was unchanged across two of them), so retrying is the right response. Standard plans allow 60 requests/minute.

Scrape Bing Images for a query and get each result's thumbnail, source page and dimensions. NO `domain` and NO `device` argument. `lang` is a locale (`en-US`), and you must pass `loc` or `loc_id`. A 200 IS NOT A SUCCESS ON THIS PROVIDER: a scrape that failed upstream answers HTTP 200 with `{"status": "error", "msg": "Please try again"}`, so this integration reads the body's `status` field and raises instead of handing back an empty result. Those failures cost NO credits (measured 2026-09-24: the balance was unchanged across two of them), so retrying is the right response. Standard plans allow 60 requests/minute.

Scrape Bing News for a query and get the articles parsed -- headline, source, publication time and link. Bing's news index differs from Google's, which is the point of reading both. NO `domain` ARGUMENT; `lang` is a locale (`en-US`). A 200 IS NOT A SUCCESS ON THIS PROVIDER: a scrape that failed upstream answers HTTP 200 with `{"status": "error", "msg": "Please try again"}`, so this integration reads the body's `status` field and raises instead of handing back an empty result. Those failures cost NO credits (measured 2026-09-24: the balance was unchanged across two of them), so retrying is the right response. Standard plans allow 60 requests/minute.

Scrape one page of Bing web results and get the blocks back parsed. NO `domain` ARGUMENT -- Bing is served from one domain, so unlike the Google and Yahoo tools this one takes none. `lang` is a LOCALE here (`en-US`, `fr-FR`), not a bare language code; `serphouse_get_language_list_by_type` with `type=bing` is the list. Pass `loc` OR `loc_id`, and remember Bing's location database is separate from Google's, so look the location up with `type=bing`. A 200 IS NOT A SUCCESS ON THIS PROVIDER: a scrape that failed upstream answers HTTP 200 with `{"status": "error", "msg": "Please try again"}`, so this integration reads the body's `status` field and raises instead of handing back an empty result. Those failures cost NO credits (measured 2026-09-24: the balance was unchanged across two of them), so retrying is the right response. Standard plans allow 60 requests/minute.

Get the suggestions Google offers while a query is being typed -- the cheapest keyword research this provider sells, and the only search tool that needs nothing but `q`. `client` picks which autocomplete surface to imitate (`chrome`, `safari`, `youtube`, ...) and the sets genuinely differ, so `youtube` is how you read video-search intent. COSTS 5 CREDITS PER CALL rather than the 10 a SERP costs (measured 2026-09-24: three calls moved the balance by 15). Suggestions are localised by `lang` and `loc`. A 200 IS NOT A SUCCESS ON THIS PROVIDER: a scrape that failed upstream answers HTTP 200 with `{"status": "error", "msg": "Please try again"}`, so this integration reads the body's `status` field and raises instead of handing back an empty result. Those failures cost NO credits (measured 2026-09-24: the balance was unchanged across two of them), so retrying is the right response. Standard plans allow 60 requests/minute.

Scrape Google's forums / discussions surface -- Reddit, Stack Exchange, vendor communities and the rest -- rather than the general web index. This is what to call when you want what people SAID about something instead of what publishers wrote about it. `verbatim=1` stops Google rewriting a narrow query into a broader one. A 200 IS NOT A SUCCESS ON THIS PROVIDER: a scrape that failed upstream answers HTTP 200 with `{"status": "error", "msg": "Please try again"}`, so this integration reads the body's `status` field and raises instead of handing back an empty result. Those failures cost NO credits (measured 2026-09-24: the balance was unchanged across two of them), so retrying is the right response. Standard plans allow 60 requests/minute.

Scrape Google Images for a query and get each result's thumbnail, source page, dimensions and title. Pass `loc` OR `loc_id`. Image results are paged differently from web results -- a page carries many more items -- so a `page` walk goes deep quickly. A 200 IS NOT A SUCCESS ON THIS PROVIDER: a scrape that failed upstream answers HTTP 200 with `{"status": "error", "msg": "Please try again"}`, so this integration reads the body's `status` field and raises instead of handing back an empty result. Those failures cost NO credits (measured 2026-09-24: the balance was unchanged across two of them), so retrying is the right response. Standard plans allow 60 requests/minute.

Scrape the Google Jobs surface and get the postings parsed -- title, employer, location, posting age and the boards Google aggregated them from. `date_range` restricts to recently posted roles. Pass `loc` or `loc_id` to read a specific market; job results are among the most location-sensitive Google surfaces. A 200 IS NOT A SUCCESS ON THIS PROVIDER: a scrape that failed upstream answers HTTP 200 with `{"status": "error", "msg": "Please try again"}`, so this integration reads the body's `status` field and raises instead of handing back an empty result. Those failures cost NO credits (measured 2026-09-24: the balance was unchanged across two of them), so retrying is the right response. Standard plans allow 60 requests/minute.

Scrape the Google Local pack / Maps listings for a query and get each business parsed -- name, rating, review count, address, category and hours where Google shows them. This is the surface for 'who ranks locally for X', which is a different question from the organic web ranking `serphouse_post_google_web` answers. Pass `loc` or `loc_id` to say where 'locally' is. A 200 IS NOT A SUCCESS ON THIS PROVIDER: a scrape that failed upstream answers HTTP 200 with `{"status": "error", "msg": "Please try again"}`, so this integration reads the body's `status` field and raises instead of handing back an empty result. Those failures cost NO credits (measured 2026-09-24: the balance was unchanged across two of them), so retrying is the right response. Standard plans allow 60 requests/minute.

Scrape Google News for a query and get the articles parsed -- headline, source, publication time, link and thumbnail. `date_range` is the useful control here: `h`, `d`, `w`, `m`, `y` or an explicit `YYYY-MM-DD,YYYY-MM-DD` window, which is how you ask for coverage of an event rather than whatever is currently ranking. Pass `loc` OR `loc_id`. A 200 IS NOT A SUCCESS ON THIS PROVIDER: a scrape that failed upstream answers HTTP 200 with `{"status": "error", "msg": "Please try again"}`, so this integration reads the body's `status` field and raises instead of handing back an empty result. Those failures cost NO credits (measured 2026-09-24: the balance was unchanged across two of them), so retrying is the right response. Standard plans allow 60 requests/minute.

Scrape Google Shopping for a product query and get the listings parsed -- title, price, merchant, rating, review count and link. SHOPPING RESULTS ARE STRONGLY LOCALISED: the same query returns different merchants and currencies per location, so the `loc`/`loc_id` you pass decides the market you are reading, and passing neither is refused. A 200 IS NOT A SUCCESS ON THIS PROVIDER: a scrape that failed upstream answers HTTP 200 with `{"status": "error", "msg": "Please try again"}`, so this integration reads the body's `status` field and raises instead of handing back an empty result. Those failures cost NO credits (measured 2026-09-24: the balance was unchanged across two of them), so retrying is the right response. Standard plans allow 60 requests/minute.

Scrape Google's SHORT-form video surface (Shorts) for a query -- a different index from `serphouse_post_google_videos_api`, which returns long-form results. Use this one for TikTok/Reels/Shorts-style coverage of a topic. A 200 IS NOT A SUCCESS ON THIS PROVIDER: a scrape that failed upstream answers HTTP 200 with `{"status": "error", "msg": "Please try again"}`, so this integration reads the body's `status` field and raises instead of handing back an empty result. Those failures cost NO credits (measured 2026-09-24: the balance was unchanged across two of them), so retrying is the right response. Standard plans allow 60 requests/minute.

Scrape Google Videos for a query and get each result's title, channel, duration, platform and link. `video_duration` (`short` 0-4 min, `medium` 4-20 min, `long` 20+ min), `video_quality` and `video_captions` narrow the set before it is scraped, which is cheaper than filtering afterwards. For the Shorts surface use `serphouse_post_google_short_videos_api`. A 200 IS NOT A SUCCESS ON THIS PROVIDER: a scrape that failed upstream answers HTTP 200 with `{"status": "error", "msg": "Please try again"}`, so this integration reads the body's `status` field and raises instead of handing back an empty result. Those failures cost NO credits (measured 2026-09-24: the balance was unchanged across two of them), so retrying is the right response. Standard plans allow 60 requests/minute.

Scrape one page of Google web results and get every block back parsed: `results.results` carries `organic`, `ads`, `local_pack`, `people_also_ask`, `related_searches`, `top_stories`, `knowledge_graph`, `inline_images`, `inline_videos` and `search_information` where Google shows them. Pass `loc` OR `loc_id` -- the API refuses a request carrying neither. One page is up to 10 results; use `serphouse_post_serp_google_advanced` to reach the top 100. A 200 IS NOT A SUCCESS ON THIS PROVIDER: a scrape that failed upstream answers HTTP 200 with `{"status": "error", "msg": "Please try again"}`, so this integration reads the body's `status` field and raises instead of handing back an empty result. Those failures cost NO credits (measured 2026-09-24: the balance was unchanged across two of them), so retrying is the right response. Standard plans allow 60 requests/minute.

Run one Google search DEEP: SERPHouse walks up to ten result pages and returns them together, which is how you get past Google's cap of 10 results per request (Google restricted the `num` parameter, so a single request cannot ask for 100). `max_pages` sets how far to go -- `max_pages=5` is up to 50 results, `max_pages=10` up to 100. BILLED PER PAGE at 10 credits a page, and only for pages that actually exist: asking for 7 when 2 are available costs 20. Use `serphouse_post_serp_google_advanced_scheduled` for the same search in the background. A 200 IS NOT A SUCCESS ON THIS PROVIDER: a scrape that failed upstream answers HTTP 200 with `{"status": "error", "msg": "Please try again"}`, so this integration reads the body's `status` field and raises instead of handing back an empty result. Those failures cost NO credits (measured 2026-09-24: the balance was unchanged across two of them), so retrying is the right response. Standard plans allow 60 requests/minute.

Queue a batch of DEEP Google searches in the background -- the scheduled form of `serphouse_post_serp_google_advanced`, which walks multiple result pages to get past Google's 10-results-per-request cap. Send an ARRAY of task objects; the response returns one row per task with its `id`, polled with `serphouse_get_serp_check` and collected with `serphouse_get_serp_get`. BILLED PER PAGE AND UP FRONT: 10 credits per page requested via `max_pages`, charged when the batch is accepted (measured 2026-09-24: one task at `max_pages=1` moved the balance by 10). A 100-task batch at `max_pages=10` is 10,000 credits, which is more than the entire free allowance.

Run a real-time search on any supported engine and get the parsed SERP straight back, with `serp_type` choosing between `web`, `news`, `image` and `shop`. This is the general-purpose live search: the per-engine tools (`serphouse_post_google_web`, `serphouse_post_bing_web`, ...) are narrower surfaces over the same scraping, and the scheduled tools are the same work without the wait. Pass `loc` OR `loc_id` for geo-targeting. THIS CALL IS SLOW -- measured 31.5s and 41.2s on 2026-09-24 against the live API, so allow minutes rather than seconds. A 200 IS NOT A SUCCESS ON THIS PROVIDER: a scrape that failed upstream answers HTTP 200 with `{"status": "error", "msg": "Please try again"}`, so this integration reads the body's `status` field and raises instead of handing back an empty result. Those failures cost NO credits (measured 2026-09-24: the balance was unchanged across two of them), so retrying is the right response. Standard plans allow 60 requests/minute.

Queue a batch of searches to run in the background instead of waiting on a live scrape. Send an ARRAY of task objects (SERPHouse recommends at most 100 per call); the response returns one row per task, each with its own `id`. Poll a task with `serphouse_get_serp_check` and collect it with `serphouse_get_serp_get`, or set `postback_url` on the task and have SERPHouse POST the result to you instead. THIS SPENDS CREDITS AT SCHEDULING TIME, not at collection time -- measured 2026-09-24, a one-task batch moved the balance by 10 the moment it was accepted, so a 100-task batch costs 1,000 credits up front. Use this rather than the live tools whenever latency matters: a live search took 31-41 seconds in the same measurement while scheduling answered in under a second.

Scrape Google web results in a LITE shape: the organic listings, without the ads, knowledge panels and other rich blocks `serphouse_post_google_web` returns. Use it when you only want the ranking and do not want to pay for parsing the rest. GEO-TARGETING IS DIFFERENT HERE: this endpoint takes `gl` (a two-letter country code) as the alternative to `loc`, NOT `loc_id`, and refuses a request carrying neither with `The gl field is required when loc is not present.` A 200 IS NOT A SUCCESS ON THIS PROVIDER: a scrape that failed upstream answers HTTP 200 with `{"status": "error", "msg": "Please try again"}`, so this integration reads the body's `status` field and raises instead of handing back an empty result. Those failures cost NO credits (measured 2026-09-24: the balance was unchanged across two of them), so retrying is the right response. Standard plans allow 60 requests/minute.

Scrape Yahoo Images for a query. `domain` must be a REGIONAL Yahoo host (`us.yahoo.com`) and `lang` the `lang_`-prefixed form (`lang_en`). No `device` and no location argument on this one. A 200 IS NOT A SUCCESS ON THIS PROVIDER: a scrape that failed upstream answers HTTP 200 with `{"status": "error", "msg": "Please try again"}`, so this integration reads the body's `status` field and raises instead of handing back an empty result. Those failures cost NO credits (measured 2026-09-24: the balance was unchanged across two of them), so retrying is the right response. Standard plans allow 60 requests/minute.

Scrape Yahoo News for a query and get the articles parsed. `domain` must be a REGIONAL Yahoo host (`us.yahoo.com`) and `lang` the `lang_`-prefixed form (`lang_en`); there is no location argument, so the regional domain is what chooses the market. A 200 IS NOT A SUCCESS ON THIS PROVIDER: a scrape that failed upstream answers HTTP 200 with `{"status": "error", "msg": "Please try again"}`, so this integration reads the body's `status` field and raises instead of handing back an empty result. Those failures cost NO credits (measured 2026-09-24: the balance was unchanged across two of them), so retrying is the right response. Standard plans allow 60 requests/minute.

Scrape one page of Yahoo web results. TWO YAHOO-SPECIFIC SPELLINGS, and getting either wrong is refused rather than corrected: `domain` must be a REGIONAL Yahoo host (`us.yahoo.com`, `in.yahoo.com`) because bare `yahoo.com` is not a valid domain, and `lang` is the `lang_`-prefixed form (`lang_en`). There is no location argument on the Yahoo tools -- the regional domain is how the market is chosen. A 200 IS NOT A SUCCESS ON THIS PROVIDER: a scrape that failed upstream answers HTTP 200 with `{"status": "error", "msg": "Please try again"}`, so this integration reads the body's `status` field and raises instead of handing back an empty result. Those failures cost NO credits (measured 2026-09-24: the balance was unchanged across two of them), so retrying is the right response. Standard plans allow 60 requests/minute.