# FastAF complete API reference

Public web data over REST, x402 and MCP. This static reference is generated from the API endpoint registry, parameter schemas, CREDIT_PACKS and charging functions; it does not contain production credentials or scraped payloads.
Base URL: https://api.fastaf.co. Website: https://fastaf.co/. API key signup: https://fastaf.co/signup/.
All data endpoints below accept GET query parameters or POST JSON, except extract, which is POST JSON only. GET requests must not carry JSON bodies. Examples are illustrative, not promises about current search results.

## SDKs

Published SDKs, version 0.2.1:
- Python: pip install fastaf-sdk; import fastaf. https://pypi.org/project/fastaf-sdk/
- JavaScript: npm i @fastaf-co/fastaf; import { FastAF } from '@fastaf-co/fastaf'. https://www.npmjs.com/package/@fastaf-co/fastaf
- SDK source and examples: https://github.com/fastaf-co/fastaf-sdk
- Hugging Face demo: https://huggingface.co/spaces/fastaf-co/fastaf
- SDK documentation: https://fastaf.co/docs/#sdks

## Authentication and free tier

500 free credits every month after email verification (not on x402); x402 pay-per-call from $0.003; optional prepaid credit packs from $10 for 20,000 credits, without expiry. https://fastaf.co/pricing/
Every account gets 500 free credits every month after email verification, shared across API keys and REST/MCP and spent at the normal credit price before any paid credits. They reset to 500 at 00:00 UTC on the 1st of each month and do not carry over; they are not valid on x402. No card required. GET /v1/usage reports free_credits_remaining and free_credits_reset_at.
Signup emails the first API key and a confirmation link. Keys are stored only as hashes; save the original. The dashboard can create additional or replacement keys, shown once.
REST data calls accept Authorization: Bearer $FASTAF_API_KEY or X-API-Key. Dashboard cookies and MCP OAuth tokens do not authorize REST data calls.
MCP endpoint: POST https://api.fastaf.co/mcp (JSON-RPC). Discovery (initialize, tools/list, ping and lists) is public. tools/call and other protected methods require a key or OAuth token from an authorization using an existing FastAF key. MCP cannot spend x402 payments.
Official MCP server: co.fastaf/fastaf in the MCP Registry (https://registry.modelcontextprotocol.io/v0/servers?search=co.fastaf), endpoint https://api.fastaf.co/mcp, so anyone can check who runs it.

## Credit packs and prices

One-time purchases, not subscriptions; paid credits never expire, including earlier purchases. Credits are shared across all API-key data endpoints and MCP tools.
- starter: $10 USD, 20,000 credits; 4,000 default Google searches if used only for search; $2.5000 per 1,000 searches at full pack utilization.
- growth: $29 USD, 75,000 credits; 15,000 default Google searches if used only for search; $1.9333 per 1,000 searches at full pack utilization.
- scale: $99 USD, 300,000 credits; 60,000 default Google searches if used only for search; $1.6500 per 1,000 searches at full pack utilization.
- pro: $299 USD, 1,000,000 credits; 200,000 default Google searches if used only for search; $1.4950 per 1,000 searches at full pack utilization.
- business: $799 USD, 3,000,000 credits; 600,000 default Google searches if used only for search; $1.3317 per 1,000 searches at full pack utilization.
Pack purchase price and allocated per-call cost are different: compare equal workloads and utilization, not just the lowest volume rate.
The x402 prices below are derived from fastaf-api pricing code using its default X402_USD_PER_CREDIT=0.001; they are independent of credit packs. Deployment configuration can affect quotes, so the live PAYMENT-REQUIRED challenge is authoritative.

## x402 payment flow and curl examples

Production data calls use USDC on Base (eip155:8453). No FastAF account or API key is needed. Do not add an API key to a per-call payment request.
1. Request the exact URL without payment. HTTP 402 returns a base64 JSON PAYMENT-REQUIRED header. Its accepts entry contains network, asset, amount, recipient and timing requirements; do not copy a recipient from a documentation example.
2. An x402 v2 client with a funded wallet validates the price/network and signs that live challenge. curl alone cannot create the signed payment.
3. Set PAYMENT_SIGNATURE to that newly signed, base64-encoded payload, then retry the same URL. Settle occurs only after a successful result; PAYMENT-RESPONSE contains the receipt.
curl -i "https://api.fastaf.co/x402/v1/serp?query=coffee"
curl -i -H "PAYMENT-SIGNATURE: $PAYMENT_SIGNATURE" "https://api.fastaf.co/x402/v1/serp?query=coffee"
The second command is a template requiring a real signed challenge, not a self-contained payment. Keep wallet private keys out of command logs and chat. Do not reuse a payment after success or retry it blindly after an uncertain network outcome.
x402 has fixed prices. Options outside the covered band return options_need_api_key before charging; use API-key billing instead. Invalid input, failed calls and blocked targets are not settled.
Credit-pack purchase is separate: POST https://api.fastaf.co/x402/topup?pack=starter requires an existing API key plus a signed payment; pack is a query parameter, not a JSON field. It adds account credits rather than fetching data.
The isolated /x402/v1/demo/search endpoint uses Base Sepolia test USDC, not production funds; see https://fastaf.co/docs/#x402 for the demo workflow.

## Complete data endpoint catalogue

## Google SERP API
$0.003 per call, pay only for 200 responses
Google Search results (SERP) for a query, as JSON: organic result titles, URLs, snippets and positions. Supports keyword search, country and language targeting for source discovery, fact-finding and research.
Product: https://fastaf.co/apis/google-serp-api/
Detailed schemas and examples: https://fastaf.co/llms/serp.txt
REST: GET or POST https://api.fastaf.co/v1/serp
x402: GET or POST https://api.fastaf.co/x402/v1/serp
x402 alias: GET or POST https://api.fastaf.co/x402/v1/search (same handler and price).
MCP tools: google_search
Prepaid credits: 5-10 per successful request, depending on options.
- default: 5 credits.
- advance_search=true: 10 credits.
x402 fixed price: $0.003000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: Keyword web search with country and language targeting; query is required.

Parameters (GET query or POST JSON fields):
- query (required): Required Google search text; supports operators such as site:example.com and intitle:coffee. No default.
- results: Maximum results retained by FastAF, integer 1-100. Omit for the full returned page. Google supplies up to 10 per page; use page for more, not a larger results value. Minimum: 1. Maximum: 100.
- page: Zero-based Google results page, integer 0-100; default 0. Each page is a separate request. Minimum: 0.
- advance_search: Include advanced Google result features/snippets when true; true/false, default false.
- mob_search: Request mobile rather than desktop Google results; true/false, default false. FastAF does not add a mobile surcharge.
- html: Return raw source HTML instead of parsed JSON when true; true/false, default false.
- deep_scrape: Fetch content from organic-result destination pages as well as the SERP; true/false, default false. Use with advance_search=false; no FastAF surcharge.
- domain: Google host to search, e.g. google.com or google.co.uk; default google.com.
- country: Two-letter search country code, e.g. us, uk or fr; default us. Localizes results, not a scrape proxy selection.
- language: Result/interface language code, e.g. en, es, fr or de; default en. Use lr, where supported, to restrict document languages.
- location: City-level search origin, e.g. Austin, Texas, United States; omit for source-default location. Cannot be combined with uule.
- uule: Google's encoded geographic search token, copied from a Google URL. Omit for no explicit token; do not combine with location where supported.
- cr: Restrict documents by country: countryFR or countryFR|countryDE. Omitted: no explicit country restriction (unlike country, which localizes the search).
- lr: Document-language filter: lang_en or a pipe-separated list such as lang_en|lang_fr. Omitted: no explicit language restriction.
- tbs: Google filter expression, e.g. qdr:d for the past day or qdr:w for the past week. Omitted: no explicit time/advanced filter.
- safe: Adult-content filter: active enables SafeSearch; off disables it (default off).
- nfpr: Spelling correction: string 1 excludes automatically corrected queries; 0 allows them (default 0).
- filter: Duplicate/omitted-result filtering: string 1 enables it (default); 0 includes similar and normally omitted results.
- ludocid: Google business listing CID as a decimal string, copied from a Google local result. Omitted: no specific business selected.
- lsig: Opaque Google local-listing signature used with a business/knowledge-panel lookup; copy from a Google URL. No default.
- kgmid: Google Knowledge Graph entity ID, e.g. /m/09c7w0; may override other search filters except page/results. No default.
- si: Opaque Google cached-search/knowledge-panel tab token; may override other filters except page/results. No default.
- ibp: Google layout/expansion expression, e.g. gwp;0,7 for a ludocid lookup. Omitted: standard results layout.
- uds: Opaque Google results-filter token copied from a Google search URL. Omitted: no extra token filter; do not invent a token.
- sample: Set to 1 to get a fixed, illustrative example of this endpoint's output instead of a real call: the same JSON for everyone, marked {"sample": true, "illustrative": true}, ignoring every other parameter. No payment, API key or data source is involved; cached publicly for an hour and rate-limited per IP. Allowed: 1.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"query":"best espresso machine for home","country":"us","language":"en"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/serp?query=best+espresso+machine+for+home&country=us&language=en'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/serp?query=best+espresso+machine+for+home&country=us&language=en'
Output: Google SERP JSON. organic_results contains ranked title, link and snippet fields; search_information describes the query. Other Google result blocks may also appear.

## Google Maps API
$0.005 per call, pay only for 200 responses
Local business and places search API for AI agents: Google Maps results as JSON with addresses, ratings, review counts, coordinates and place IDs when available. Supports searches by query and location or place details by place_id.
Product: https://fastaf.co/apis/google-maps-api/
Detailed schemas and examples: https://fastaf.co/llms/maps.txt
REST: GET or POST https://api.fastaf.co/v1/maps
x402: GET or POST https://api.fastaf.co/x402/v1/maps
MCP tools: google_maps_places
Prepaid credits: 5 per successful request, depending on options.
- per call: 5 credits.
x402 fixed price: $0.005000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: Local places search by query and map center (ll); alternatively, place_id selects a place lookup.

Parameters (GET query or POST JSON fields):
- query: Maps search text, e.g. coffee in Rome; required unless place_id is supplied. Without location or ll, FastAF uses a place named in the query.
- location: Search-centre place name, e.g. Rome, Italy (up to 200 characters). Cannot combine with ll. Omit to infer from query; unresolved or out-of-area results are not charged.
- ll: Search centre as @latitude,longitude,zoom, e.g. @41.9028,12.4964,13z (coordinates in degrees; zoom 3z-30z; map height in metres also supported upstream). Needed for pagination. Cannot combine with location; omitted: infer from query/location.
- domain: Google host to search, e.g. google.com or google.co.uk; default google.com.
- language: Result/interface language code, e.g. en, es, fr or de; default en. Use lr, where supported, to restrict document languages.
- country: Two-letter search country code, e.g. us, uk or fr; default us. Localizes results, not a scrape proxy selection.
- data: Opaque data fragment copied from a Google Maps URL, e.g. !4m5!3m4!1s<id>!8m2!3d<lat>!4d<lon>. Used with type=place; unnecessary with place_id. No default.
- place_id: Google Maps place identifier, e.g. ChIJN1t_tDeuEmsRUsoyG83frY4, for one place's details. Required if query is omitted; no default.
- type: Maps operation: search for query results or place for details using data. Omit for query search or automatic place_id lookup. Allowed: search, place.
- page: Maps result offset, integer 0-100: 0 first page, 20 second, 40 third. Default 0; supply ll for pagination. Each page is a separate request. Minimum: 0.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"query":"coffee near Times Square","ll":"@40.758,-73.9855,14z","language":"en"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/maps?query=coffee+near+Times+Square&ll=%4040.758%2C-73.9855%2C14z&language=en'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/maps?query=coffee+near+Times+Square&ll=%4040.758%2C-73.9855%2C14z&language=en'
Output: Google Maps JSON. search_results contains places with title, address, rating, reviews, place_id and gps_coordinates when available.

## Amazon API
$0.003 per call, pay only for 200 responses
Amazon product search and pricing API for AI agents: JSON product details by ASIN, keyword search results, offers and bestsellers. Supports Amazon marketplace domains for ecommerce research, with titles, prices, ratings and availability when available.
Product: https://fastaf.co/apis/amazon-api/
Detailed schemas and examples: https://fastaf.co/llms/amazon.txt
REST: GET or POST https://api.fastaf.co/v1/amazon
x402: GET or POST https://api.fastaf.co/x402/v1/amazon
MCP tools: amazon_product
Prepaid credits: 1-5 per successful request, depending on options.
- resource=search: 1 credits.
- resource=product: 1 credits.
- resource=offers: 5 credits.
- resource=bestsellers: 5 credits.
x402 fixed price: $0.003000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: Amazon product lookup using resource=product, an ASIN and marketplace domain. Search, offers and bestsellers use the corresponding resource selector.

Parameters (GET query or POST JSON fields):
- resource: Amazon operation: search (default), product, offers or bestsellers. Reviews are not sold. Allowed: search, product, offers, bestsellers. Default: "search".
- asin: Amazon product identifier, usually 10 letters/digits, e.g. B07FZ8S74R. Required for product and offers; not used for search/bestsellers. No default.
- query: Required product search text for resource=search, e.g. wireless headphones. Not valid for other resources; no default.
- domain: Amazon domain suffix, not a hostname: com, co.uk, de, in, etc.; default com.
- country: Two-letter marketplace/proxy country code, e.g. us, gb or de; default us. Unlike scrape.country, this has no FastAF surcharge.
- language: Product-data language code, e.g. en, de or fr; omitted: marketplace default. Valid for search, product and bestsellers.
- postal_code: Delivery postal/ZIP code, e.g. 10001, to localize availability and price. Valid for search/product/offers; omitted: source-default delivery location.
- page: One-based page number, default 1. Search accepts 1-100; bestsellers accepts 1-2 (set full_list=false for a single page). Each request is billed separately. Minimum: 1. Maximum: 100.
- premium: Use premium proxies for resource=search; true/false, default false. Not valid for product/offers/bestsellers; no FastAF surcharge.
- sort_by: Review order: helpful or recent. Reviews are currently unavailable, so requests using this option are rejected without charge; no FastAF default. Allowed: helpful, recent.
- filter_by_star: Review rating filter: all_stars, five_star, four_star, three_star, two_star, one_star, positive or critical. Reviews unavailable; rejected without charge; no FastAF default. Allowed: all_stars, five_star, four_star, three_star, two_star, one_star, positive, critical.
- reviewer_type: Review author filter: all_reviews or avp_only_reviews (verified purchases). Reviews unavailable; rejected without charge; no FastAF default. Allowed: all_reviews, avp_only_reviews.
- media_type: Review attachment filter: all_contents or media_reviews_only. Reviews unavailable; rejected without charge; no FastAF default. Allowed: all_contents, media_reviews_only.
- format_type: Review product-variant filter: all_formats or current_format. Reviews unavailable; rejected without charge; no FastAF default. Allowed: all_formats, current_format.
- url: Full HTTP(S) Amazon reviews URL, an alternative to ASIN for reviews. Reviews are unavailable; this option is rejected without charge. No default.
- category_id: Bestseller category slug, node ID or slug/node pair, e.g. kitchen, 289668 or kitchen/289668. Omit for all departments; bestsellers only.
- type: Ranked list for bestsellers: bestsellers (default), new_releases, movers_and_shakers, most_wished_for or most_gifted. Allowed: bestsellers, new_releases, movers_and_shakers, most_wished_for, most_gifted.
- full_list: For bestsellers, true returns the combined ranked list (upstream default true); false returns only page. Boolean; no FastAF surcharge for the full list.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"resource":"product","asin":"B07FZ8S74R","domain":"com"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/amazon?resource=product&asin=B07FZ8S74R&domain=com'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/amazon?resource=product&asin=B07FZ8S74R&domain=com'
Output: Amazon product JSON for resource=product: ASIN, title, displayed price, availability_status, average_rating and total_reviews. Other resource modes return their own search, offer or bestseller data.

## LinkedIn API
$0.06 per call, pay only for 200 responses
LinkedIn public profile API for AI agents: retrieve a person by profile ID or slug for lead research and profile enrichment. Returns a JSON array with name, headline, location, public identifier and biography when available; public data only.
Product: https://fastaf.co/apis/linkedin-api/
Detailed schemas and examples: https://fastaf.co/llms/linkedin.txt
REST: GET or POST https://api.fastaf.co/v1/linkedin
x402: GET or POST https://api.fastaf.co/x402/v1/linkedin
MCP tools: get_linkedin_profile
Prepaid credits: 60 per successful request, depending on options.
- per call: 60 credits.
x402 fixed price: $0.060000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: Public LinkedIn person lookup by id with type=profile.

Parameters (GET query or POST JSON fields):
- id (required): Required public LinkedIn person-profile slug from /in/<id>/, e.g. williamhgates, not a full URL. No default; public data only.
- type: Profile resource selector; only profile is accepted and is the FastAF default. Company profiles are not supported here. Allowed: profile.
- premium: Use the premium profile retrieval option; true/false, default false.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"id":"williamhgates","type":"profile"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/linkedin?id=williamhgates&type=profile'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/linkedin?id=williamhgates&type=profile'
Output: JSON array of public LinkedIn profiles, not an object wrapper. fullName and public_identifier identify the person; headline, location and about are source-dependent.

## YouTube API
$0.005 per call, pay only for 200 responses
YouTube transcript and video search API for AI agents: retrieve timestamped transcript segments by video ID or find videos by keyword. Returns JSON transcripts with text, start and duration, or video search results for content research and summarization.
Product: https://fastaf.co/apis/youtube-api/
Detailed schemas and examples: https://fastaf.co/llms/youtube.txt
REST: GET or POST https://api.fastaf.co/v1/youtube
x402: GET or POST https://api.fastaf.co/x402/v1/youtube
MCP tools: search_youtube, youtube_transcript
Prepaid credits: 5 per successful request, depending on options.
- resource=transcript: 5 credits.
- resource=search: 5 credits.
x402 fixed price: $0.005000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: YouTube transcript lookup using resource=transcript and video ID v. Video search instead requires resource=search and search_query.

Parameters (GET query or POST JSON fields):
- resource: YouTube operation: transcript (default) or search. With no resource or video ID, search_query or its aliases selects search. Explicit canonical parameters take precedence over aliases. Allowed: transcript, search. Default: "transcript".
- v: Required YouTube video ID for transcript, e.g. jNQXAC9IVRw, not the watch URL. ID aliases: video_id, videoId, id, videoID. URL aliases: url, link, video_url accept YouTube watch, youtu.be, shorts and embed URLs. Not valid for search; no default.
- search_query: Required YouTube search text for resource=search, e.g. espresso tutorial. Aliases: q, query, search, keyword; ignored when a video ID is supplied. Without resource or a video ID, selects search. Not valid for transcript; no default.
- country: Two-letter YouTube country code, e.g. us or gb; upstream default us for search/transcripts.
- language: YouTube language code, e.g. en, es or de; upstream default en. For transcripts, requests the available caption language; no translation is guaranteed.
- sp: YouTube search filter or continuation token copied from a search URL/previous response; search only. Omit for the first unfiltered page. Each page is a separate request.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"resource":"transcript","v":"jNQXAC9IVRw","language":"en"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/youtube?resource=transcript&v=jNQXAC9IVRw&language=en'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/youtube?resource=transcript&v=jNQXAC9IVRw&language=en'
Output: YouTube transcript JSON: transcripts contains text segments with start and duration in seconds. resource=search returns video_results instead.

## Web Scraping API
$0.005 per call, pay only for 200 responses
Scrape a public webpage for AI agents: convert a web page URL into markdown, HTML, links or images, with optional JavaScript rendering and AI extraction or summary. Supports web content retrieval for research and RAG; response format follows the requested options.
Product: https://fastaf.co/apis/web-scraping-api/
Detailed schemas and examples: https://fastaf.co/llms/scrape.txt
REST: GET or POST https://api.fastaf.co/v1/scrape
x402: GET or POST https://api.fastaf.co/x402/v1/scrape
MCP tools: scrape_url
Prepaid credits: 1-35 per successful request, depending on options.
- basic: 1 credits.
- dynamic=true: 5 credits.
- premium=true or country set: 10 credits.
- dynamic=true plus premium=true or country set: 25 credits.
- challenge_mode=true (cannot combine with dynamic/premium/country): 10 credits.
- AI extraction (ai_query, ai_extract_rules or formats=summary): add 10 credits to the selected mode, once even if multiple AI options are used.
x402 fixed price: $0.005000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: Web page retrieval by URL with formats=markdown; dynamic and other optional rendering or extraction parameters select different modes.

Parameters (GET query or POST JSON fields):
- async: Return 202 with a scrape job immediately. Otherwise a scrape still running after 25 seconds returns 202. Default: false.
- url (required): Required public HTTP(S) page URL. Zillow/eBay URLs are rejected without charge: use their dedicated endpoints. Booking defaults to rendering; Reddit uses a best-effort public feed, ignoring rendering/proxy/wait/session/header options.
- dynamic: Render JavaScript before extracting content; true/false. FastAF default false, except booking.com defaults true with wait=8000. Ignored for Reddit feeds.
- js_rendering: Alias for dynamic with identical defaults and pricing. Boolean; cannot disagree with dynamic. Ignored for Reddit feeds.
- premium: Use residential proxies; true/false, default false. Cannot combine true with challenge_mode. Ignored for Reddit feeds.
- custom_headers: Boolean upstream header-forwarding flag, default false; NOT a header map. FastAF does not forward caller HTTP headers, cookies or Authorization to the target, so this cannot customize them. Ignored for Reddit feeds.
- wait: Extra browser loading delay in milliseconds, integer 0-35000, for dynamic rendering. Omitted: no explicit extra delay, except rendered booking.com defaults to 8000. Does not enable rendering; ignored for Reddit feeds. Minimum: 0. Maximum: 35000.
- country: Proxy exit country as a two-letter ISO 3166-1 code, e.g. us, gb or de. Omit for no country targeting. Selecting any country uses premium-tier pricing even if premium=false; incompatible with challenge_mode. Ignored for Reddit feeds.
- session_number: Reusable proxy session identifier, e.g. 12345. Repeat it to request the same proxy IP; expires after 60 seconds of inactivity. Omit to rotate normally. Ignored for Reddit feeds; not a FastAF login session.
- image: Enable fetching image URLs; true/false, default false. Not a screenshot: use /screenshot for captures, or formats=images to extract page image links.
- formats: One output format: html (default), links, markdown, summary or images. summary is AI-generated; links/images extract page URLs. Reddit supports html/markdown only. Allowed: html, links, markdown, summary, images.
- ai_query: Natural-language extraction prompt, e.g. Return the product price and currency. Omit for no prompt-based extraction. Not supported for Reddit feeds.
- ai_extract_rules: JSON-encoded extraction instructions as a STRING, e.g. {"price":"product price","currency":"currency code"}; not a nested JSON object. Omit for no rule-based extraction. Not supported for Reddit feeds.
- type: Non-HTML target format: image, pdf or pbf (Protocolbuffer Binary Format). Omit for normal page scraping. This selects a binary resource, not a screenshot or an output format conversion. Allowed: image, pdf, pbf.
- challenge_mode: Separate rendering mode with its own browser and proxies; true/false, default false. Uses its own rendering/proxies; cannot combine with dynamic=true, premium=true or country. Ignored for Reddit feeds.
- max_tokens: Optional token limit, integer 1-1000000, estimated at ~4 characters per token. Changes the answer to JSON {content, truncated, estimated_tokens, max_tokens, content_type}; over the limit, content is the first max_tokens*4 characters and content_id/content_url/expires_at fetch the full page for 1 hour at no extra charge (same API key; on x402 the id alone). Omit for the unchanged raw response; binary types are never cut. Minimum: 1. Maximum: 1000000.
- sample: Set to 1 to get a fixed, illustrative example of this endpoint's output instead of a real call: the same JSON for everyone, marked {"sample": true, "illustrative": true}, ignoring every other parameter. No payment, API key or data source is involved; cached publicly for an hour and rate-limited per IP. Allowed: 1.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"url":"https://example.com/","formats":"markdown"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/scrape?url=https%3A%2F%2Fexample.com%2F&formats=markdown'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/scrape?url=https%3A%2F%2Fexample.com%2F&formats=markdown'
Output: Markdown response text for formats=markdown, not a JSON wrapper. HTML is the default; links/images formats return JSON and binary targets return bytes.

## Google News API
$0.005 per call, pay only for 200 responses
News search API for AI agents: Google News results as JSON for a topic, company or person. Returns article titles, sources, timestamps, URLs and snippets when available for news monitoring and research, with country and language targeting.
Product: https://fastaf.co/apis/google-news-api/
Detailed schemas and examples: https://fastaf.co/llms/news.txt
REST: GET or POST https://api.fastaf.co/v1/news
x402: GET or POST https://api.fastaf.co/x402/v1/news
MCP tools: search_news
Prepaid credits: 5 per successful request, depending on options.
- per call: 5 credits.
x402 fixed price: $0.005000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: Google News keyword search with country and language targeting.

Parameters (GET query or POST JSON fields):
- query (required): Required Google News search text, e.g. renewable energy; supports Google search operators. No default.
- results: Maximum results retained by FastAF, integer 1-100. Omit for the full returned page. Google supplies up to 10 per page; use page for more, not a larger results value. Minimum: 1. Maximum: 100.
- country: Two-letter search country code, e.g. us, uk or fr; default us. Localizes results, not a scrape proxy selection.
- page: Zero-based results page: 0 is the first page, 1 the second; non-negative integer, default 0. Each page is a separate request. Minimum: 0.
- domain: Google host to search, e.g. google.com or google.co.uk; default google.com.
- language: Result/interface language code, e.g. en, es, fr or de; default en. Use lr, where supported, to restrict document languages.
- lr: Document-language filter: lang_en or a pipe-separated list such as lang_en|lang_fr. Omitted: no explicit language restriction.
- uule: Google's encoded geographic search token, copied from a Google URL. Omit for no explicit token; do not combine with location where supported.
- tbs: Google filter expression, e.g. qdr:d for the past day or qdr:w for the past week. Omitted: no explicit time/advanced filter.
- safe: Adult-content filter: active enables SafeSearch; off disables it (default off).
- nfpr: Spelling correction: string 1 excludes automatically corrected queries; 0 allows them (default 0).
- html: Return raw source HTML instead of parsed JSON when true; true/false, default false.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"query":"web scraping regulation","country":"us","language":"en"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/news?query=web+scraping+regulation&country=us&language=en'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/news?query=web+scraping+regulation&country=us&language=en'
Output: Google News JSON. news_results contains title, source, lastUpdated, url and snippet when available; timestamps may be relative text.

## Google Shopping API
$0.01 per call, pay only for 200 responses
Product price comparison and shopping search API for AI agents: Google Shopping results as JSON with titles, prices, merchants, product links and ratings when available. Supports keyword search and country targeting for ecommerce research.
Product: https://fastaf.co/apis/google-shopping-api/
Detailed schemas and examples: https://fastaf.co/llms/shopping.txt
REST: GET or POST https://api.fastaf.co/v1/shopping
x402: GET or POST https://api.fastaf.co/x402/v1/shopping
MCP tools: google_shopping_prices
Prepaid credits: 10 per successful request, depending on options.
- per call: 10 credits.
x402 fixed price: $0.010000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: Google Shopping keyword search with country and language targeting.

Parameters (GET query or POST JSON fields):
- query (required): Required Google Shopping search text or complete Google search URL, e.g. running shoes. No default.
- country: Two-letter search country code, e.g. us, uk or fr; default us. Localizes results, not a scrape proxy selection.
- page: Zero-based results page: 0 is the first page, 1 the second; non-negative integer, default 0. Each page is a separate request. Minimum: 0.
- domain: Google host to search, e.g. google.com or google.co.uk; default google.com.
- language: Result/interface language code, e.g. en, es, fr or de; default en. Use lr, where supported, to restrict document languages.
- lr: Document-language filter: lang_en or a pipe-separated list such as lang_en|lang_fr. Omitted: no explicit language restriction.
- shoprs: Opaque Google Shopping filter ID copied from a Google URL; pair with query text including the selected filter label. Omit for no explicit shopping filter.
- uule: Google's encoded geographic search token, copied from a Google URL. Omit for no explicit token; do not combine with location where supported.
- tbs: Google filter expression, e.g. qdr:d for the past day or qdr:w for the past week. Omitted: no explicit time/advanced filter.
- safe: Adult-content filter: active enables SafeSearch; off disables it (default off).
- nfpr: Spelling correction: string 1 excludes automatically corrected queries; 0 allows them (default 0).
- html: Return raw source HTML instead of parsed JSON when true; true/false, default false.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"query":"running shoes","country":"us","language":"en"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/shopping?query=running+shoes&country=us&language=en'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/shopping?query=running+shoes&country=us&language=en'
Output: Google Shopping JSON. shopping_results contains titles, displayed prices, merchant source, product links, ratings and reviews when available.

## Google Scholar API
$0.005 per call, pay only for 200 responses
Academic paper and citation search API for AI agents: Google Scholar results as JSON with titles, publication details, snippets, paper links and cited-by counts when available. Supports topic queries, citation lookup and year filters for literature research.
Product: https://fastaf.co/apis/google-scholar-api/
Detailed schemas and examples: https://fastaf.co/llms/scholar.txt
REST: GET or POST https://api.fastaf.co/v1/scholar
x402: GET or POST https://api.fastaf.co/x402/v1/scholar
MCP tools: search_scholar
Prepaid credits: 5 per successful request, depending on options.
- per call: 5 credits.
x402 fixed price: $0.005000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: Academic topic search with language and publication-year filters; citation or cluster IDs can replace query.

Parameters (GET query or POST JSON fields):
- html: Return raw source HTML instead of parsed JSON when true; true/false, default false.
- query: Scholar search text, supporting author: and source:. Required unless cites or cluster is supplied. May refine cites results; cannot combine with cluster. No default.
- language: Result/interface language code, e.g. en, es, fr or de; default en. Use lr, where supported, to restrict document languages.
- lr: Document-language filter: lang_en or a pipe-separated list such as lang_en|lang_fr. Omitted: no explicit language restriction.
- cites: Scholar article ID for a Cited by lookup, copied from a Scholar result. May combine with query to filter citing papers, but not cluster. No default.
- as_ylo: Inclusive earliest publication year as a four-digit string, e.g. 2020. Omit for no lower year bound; may combine with as_yhi.
- as_yhi: Inclusive latest publication year as a four-digit string, e.g. 2026. Omit for no upper year bound; may combine with as_ylo.
- scisbd: Scholar result mode: string 1 requests abstract results, 0 all results. Omitted: source-default result mode.
- cluster: Scholar article cluster ID for an All versions lookup. Use instead of query/cites, never together; no default.
- as_sdt: Scholar search/filter codes: 0 excludes patents (default), 7 includes patents, 4 selects US case law. Court codes can follow 4, e.g. 4,33,192.
- safe: Adult-content filter: active enables SafeSearch; off disables it (default off).
- filter: Duplicate/omitted-result filtering: string 1 enables it (default); 0 includes similar and normally omitted results.
- as_vis: Citation-only results: string 1 excludes them, 0 includes them (default 0).
- as_rr: Review-paper filter: string 1 returns review articles only, 0 all article types (default 0).
- page: Zero-based results page: 0 is the first page, 1 the second; non-negative integer, default 0. Each page is a separate request. Minimum: 0.
- results: Requested results per Scholar page, integer at least 1; omitted: source-default page size. Google may return fewer; not a count of separately billed requests. Minimum: 1.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"query":"retrieval augmented generation","language":"en","as_ylo":"2020","as_yhi":"2026"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/scholar?query=retrieval+augmented+generation&language=en&as_ylo=2020&as_yhi=2026'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/scholar?query=retrieval+augmented+generation&language=en&as_ylo=2020&as_yhi=2026'
Output: Google Scholar JSON. scholar_results includes title_link, displayed_link publication text, snippet and inline_links.cited_by with a textual total and cites_id when available.

## Google Jobs API
$0.005 per call, pay only for 200 responses
Job search API for AI agents: Google Jobs listings as JSON for a role, company or location. Returns job titles, employers, locations, posting details and application links when available for hiring research and job discovery.
Product: https://fastaf.co/apis/google-jobs-api/
Detailed schemas and examples: https://fastaf.co/llms/jobs.txt
REST: GET or POST https://api.fastaf.co/v1/jobs
x402: GET or POST https://api.fastaf.co/x402/v1/jobs
MCP tools: search_jobs
Prepaid credits: 5 per successful request, depending on options.
- per call: 5 credits.
x402 fixed price: $0.005000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: Google Jobs keyword search with country and language targeting; the query can include role and location.

Parameters (GET query or POST JSON fields):
- query (required): Required job search text, e.g. software engineer in Austin. No default.
- country: Two-letter search country code, e.g. us, uk or fr; default us. Localizes results, not a scrape proxy selection.
- language: Google Jobs result language/locale, e.g. en_us; upstream default en_us.
- uule: Google's encoded geographic search token, copied from a Google URL. Omit for no explicit token; do not combine with location where supported.
- domain: Google host to search, e.g. google.com or google.co.uk; default google.com.
- next_page_token: Opaque continuation token from the previous jobs response. Omit for the first page; keep the original query/filters. Each page is a separate request.
- chips: Google Jobs filter expression copied from the search page, e.g. employment_type:FULLTIME. Omitted: no extra chip filter.
- lrad: Google Jobs radius value copied from a Google Jobs URL. Passed through as a string; upstream documents no unit or range. Omit for source-default radius.
- ltype: Work-from-home filter token copied from a Google Jobs URL; upstream publishes no fixed value list. Omitted: no explicit work-from-home filter.
- uds: Opaque Google results-filter token copied from a Google search URL. Omitted: no extra token filter; do not invent a token.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"query":"product manager jobs new york","country":"us","language":"en"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/jobs?query=product+manager+jobs+new+york&country=us&language=en'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/jobs?query=product+manager+jobs+new+york&country=us&language=en'
Output: Google Jobs JSON. jobs_results contains title, company_name, location, extensions for posting details and apply_links when available.

## Google AI Mode API
$0.01 per call, pay only for 200 responses
AI answer and web research API for AI agents: Google AI Mode responses as JSON text blocks and source references. Supports natural-language search questions with country and language targeting for research summaries; source links may be Google redirect paths.
Product: https://fastaf.co/apis/google-ai-mode-api/
Detailed schemas and examples: https://fastaf.co/llms/ai.txt
REST: GET or POST https://api.fastaf.co/v1/ai
x402: GET or POST https://api.fastaf.co/x402/v1/ai
MCP tools: google_ai_answer
Prepaid credits: 10 per successful request, depending on options.
- per call: 10 credits.
x402 fixed price: $0.010000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: Natural-language Google AI Mode query with country and language targeting.

Parameters (GET query or POST JSON fields):
- query (required): Required question/search text for Google AI Mode, e.g. How does an espresso machine work? No default.
- country: Two-letter search country code, e.g. us, uk or fr; default us. Localizes results, not a scrape proxy selection.
- language: Result/interface language code, e.g. en, es, fr or de; default en. Use lr, where supported, to restrict document languages.
- uule: Google's encoded geographic search token, copied from a Google URL. Omit for no explicit token; do not combine with location where supported.
- location: City-level search origin, e.g. Austin, Texas, United States; omit for source-default location. Cannot be combined with uule.
- safe: Adult-content filter: active enables SafeSearch; off disables it (default off).
- html: Return raw source HTML instead of parsed JSON when true; true/false, default false.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"query":"how do x402 payments work","country":"us","language":"en"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/ai?query=how+do+x402+payments+work&country=us&language=en'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/ai?query=how+do+x402+payments+work&country=us&language=en'
Output: Google AI Mode JSON. text_blocks contains answer paragraphs with snippet and links; references holds source titles and snippets. Links can be path-only Google redirects, not resolved URLs.

## LinkedIn Jobs API
$0.005 per call, pay only for 200 responses
LinkedIn public job listings API for AI agents: JSON array of public LinkedIn job listings with title, company, location and job link when available. Public listings only, no authenticated content.
Product: https://fastaf.co/apis/linkedin-jobs-api/
Detailed schemas and examples: https://fastaf.co/llms/linkedin_jobs.txt
REST: GET or POST https://api.fastaf.co/v1/linkedin_jobs
x402: GET or POST https://api.fastaf.co/x402/v1/linkedin_jobs
MCP tools: search_linkedin_jobs
Prepaid credits: 5 per successful request, depending on options.
- per call: 5 credits.
x402 fixed price: $0.005000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: Required job title or company keyword, e.g. Python developer; no default.

Parameters (GET query or POST JSON fields):
- field (required): Required job title or company keyword, e.g. Python developer; no default.
- geoid: LinkedIn location ID; default 92000000 (worldwide).
- location: Location text, e.g. London; omit for worldwide jobs.
- page: One-based result page, integer at least 1; default 1. Minimum: 1.
- sort_by: Posting-date filter: day, week or month; omitted means no date filter.
- job_type: Employment filter: temporary, contract, volunteer, full_time or part_time; omitted means all types.
- exp_level: Experience filter: internship, entry_level, associate, mid_senior_level or director; omitted means all levels.
- work_type: Work model: at_work, remote or hybrid; omitted means all models.
- filter_by_company: LinkedIn company ID; omitted means all companies.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"field":"python"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/linkedin_jobs?field=python'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/linkedin_jobs?field=python'
Output: JSON array of public LinkedIn job listings with title, company, location and job link when available. Public listings only, no authenticated content.

## Google Patents API
$0.005 per call, pay only for 200 responses
Google Patents search API for AI agents: Search Google Patents for inventions, patent titles and publication links.
Product: https://fastaf.co/apis/google-patents-api/
Detailed schemas and examples: https://fastaf.co/llms/patents.txt
REST: GET or POST https://api.fastaf.co/v1/patents
x402: GET or POST https://api.fastaf.co/x402/v1/patents
MCP tools: search_patents
Prepaid credits: 5 per successful request, depending on options.
- per call: 5 credits.
x402 fixed price: $0.005000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: Required patent search keywords; no default.

Parameters (GET query or POST JSON fields):
- query (required): Required patent search keywords; no default.
- page: Result page, integer at least 1; omitted uses source default. Minimum: 1.
- num: Result count, integer 1-100; omitted uses source default. Minimum: 1. Maximum: 100.
- sort: Sort order: new or old; omitted uses source default. Allowed: new, old.
- before: Publication cutoff date in YYYY-MM-DD format; omitted means no cutoff.
- after: Publication start date in YYYY-MM-DD format; omitted means no cutoff.
- inventor: Inventor name filter; omitted means any inventor.
- assignee: Assignee name filter; omitted means any assignee.
- country: Patent country code; omitted means any country.
- language: Result language code; omitted uses source default.
- status: Patent status filter; omitted uses source default.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"query":"solar cell"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/patents?query=solar+cell'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/patents?query=solar+cell'
Output: Search Google Patents for inventions, patent titles and publication links. JSON response; source fields may vary.

## Google Flights API
$0.005 per call, pay only for 200 responses
Google Flights search API for AI agents: Search Google Flights for flight itineraries and current fares.
Product: https://fastaf.co/apis/google-flights-api/
Detailed schemas and examples: https://fastaf.co/llms/flights.txt
REST: GET or POST https://api.fastaf.co/v1/flights
x402: GET or POST https://api.fastaf.co/x402/v1/flights
MCP tools: search_flights
Prepaid credits: 5 per successful request, depending on options.
- per call: 5 credits.
x402 fixed price: $0.005000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: Required three-letter uppercase IATA departure airport code; no default. Required three-letter uppercase IATA arrival airport code; no default. Required outbound date in YYYY-MM-DD format; no default.

Parameters (GET query or POST JSON fields):
- departure_id (required): Required three-letter uppercase IATA departure airport code; no default.
- arrival_id (required): Required three-letter uppercase IATA arrival airport code; no default.
- outbound_date (required): Required outbound date in YYYY-MM-DD format; no default.
- return_date: Return date in YYYY-MM-DD format, on or after outbound_date; optional.
- type: Trip type: 1 round trip, 2 one way; omitted uses source default. Allowed: 1, 2.
- adults: Adult passenger count, positive integer; omitted uses source default. Minimum: 1.
- currency: Three-letter uppercase currency code; omitted uses source default.
- hl: Interface language code; omitted uses source default.
- gl: Two-letter country code; omitted uses source default.
- travel_class: Cabin class: 1 economy, 2 premium economy, 3 business, 4 first; omitted uses source default. Allowed: 1, 2, 3, 4.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"departure_id":"JFK","arrival_id":"LHR","outbound_date":"2027-01-15","type":"2"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/flights?departure_id=JFK&arrival_id=LHR&outbound_date=2027-01-15&type=2'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/flights?departure_id=JFK&arrival_id=LHR&outbound_date=2027-01-15&type=2'
Output: Search Google Flights for flight itineraries and current fares. JSON response; source fields may vary.

## Bing Search API
$0.005 per call, pay only for 200 responses
Bing web search results API for AI agents: JSON object with bing_data containing ranked title, link and snippet fields.
Product: https://fastaf.co/apis/bing-search-api/
Detailed schemas and examples: https://fastaf.co/llms/bing.txt
REST: GET or POST https://api.fastaf.co/v1/bing
x402: GET or POST https://api.fastaf.co/x402/v1/bing
MCP tools: bing_search
Prepaid credits: 5 per successful request, depending on options.
- per call: 5 credits.
x402 fixed price: $0.005000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: Required web search keywords; no default.

Parameters (GET query or POST JSON fields):
- query (required): Required web search keywords; no default.
- mkt: Market such as en-US; omit for source default, mutually exclusive with cc.
- cc: Two-letter country code such as us; omit for source default, mutually exclusive with mkt.
- first: Starting result position, integer at least 1; default 1. Minimum: 1.
- count: Requested result count, integer 1-50; actual count varies, omitted uses source default. Minimum: 1. Maximum: 50.
- safeSearch: Adult-content filter: Off, Moderate or Strict; omitted uses source default. Allowed: Off, Moderate, Strict.
- filters: Opaque Bing filters copied from a Bing search URL; omitted means no explicit filter.
- lat: GPS latitude for search origin; omitted uses source default.
- lon: GPS longitude for search origin; omitted uses source default.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"query":"what is api"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/bing?query=what+is+api'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/bing?query=what+is+api'
Output: JSON object with bing_data containing ranked title, link and snippet fields.

## Google Images API
$0.01 per call, pay only for 200 responses
Google Images search results API for AI agents: Google Images JSON with image results, thumbnails, original image URLs, source links and dimensions when available. Image rights remain with the source.
Product: https://fastaf.co/apis/google-images-api/
Detailed schemas and examples: https://fastaf.co/llms/images.txt
REST: GET or POST https://api.fastaf.co/v1/images
x402: GET or POST https://api.fastaf.co/x402/v1/images
MCP tools: google_images
Prepaid credits: 10 per successful request, depending on options.
- per call: 10 credits.
x402 fixed price: $0.010000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: Required Google Images search keywords; no default.

Parameters (GET query or POST JSON fields):
- query (required): Required Google Images search keywords; no default.
- country: Two-letter search country code; default us.
- language: Result language code; default en.
- domain: Google search domain; default google.com.
- page: Zero-based results page, integer at least 0; default 0. Minimum: 0.
- safe: Adult-content filter: active or off; default off.
- tbs: Advanced Google Images filter expression copied from a search URL; omitted means no filter.
- imgar: Aspect ratio: s (square), t (tall), w (wide), xw (panoramic); omitted means any.
- imgsz: Image size such as l, m, i, vga or 2mp; omitted means any size.
- image_color: Color filter such as bw, trans, red, blue or white; omitted means any color.
- image_type: Image type: face, photo, clipart, lineart or animated; omitted means any type.
- licenses: License filter: f, fc, fm, fmc, cl or ol; verify rights with the source before reuse.
- html: Return raw source HTML when true; default false.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"query":"espresso machine"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/images?query=espresso+machine'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/images?query=espresso+machine'
Output: Google Images JSON with image results, thumbnails, original image URLs, source links and dimensions when available. Image rights remain with the source.

## Reddit API
$0.003 per call, pay only for 200 responses
Public Reddit feed API for AI agents: Markdown text for formats=markdown; HTML by default. Public feed entries include titles, dates, links and content; author usernames and links to user profiles are removed. RSS coverage can be partial; rate limits return an error without charge.
Product: https://fastaf.co/apis/reddit-api/
Detailed schemas and examples: https://fastaf.co/llms/reddit.txt
REST: GET or POST https://api.fastaf.co/v1/reddit
x402: GET or POST https://api.fastaf.co/x402/v1/reddit
MCP tools: read_reddit
Prepaid credits: 1 per successful request, depending on options.
- per call: 1 credits.
x402 fixed price: $0.003000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: Required public reddit.com subreddit or thread URL, e.g. https://www.reddit.com/r/python/; no default. Reads the public RSS feed only.

Parameters (GET query or POST JSON fields):
- url (required): Required public reddit.com subreddit or thread URL, e.g. https://www.reddit.com/r/python/; no default. Reads the public RSS feed only.
- formats: Response format: html (default) or markdown. Feeds may contain fewer posts or comments than the website. Allowed: html, markdown. Default: "html".
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"url":"https://www.reddit.com/r/python/","formats":"markdown"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/reddit?url=https%3A%2F%2Fwww.reddit.com%2Fr%2Fpython%2F&formats=markdown'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/reddit?url=https%3A%2F%2Fwww.reddit.com%2Fr%2Fpython%2F&formats=markdown'
Output: Markdown text for formats=markdown; HTML by default. Public feed entries include titles, dates, links and content; author usernames and links to user profiles are removed. RSS coverage can be partial; rate limits return an error without charge.

## Walmart API
$0.005 per call, pay only for 200 responses
Walmart product search API for AI agents: retrieve listings from a Walmart search URL as JSON search_results containing item arrays. Includes product titles, prices, ratings, availability and seller details when available for ecommerce research.
Product: https://fastaf.co/apis/walmart-api/
Detailed schemas and examples: https://fastaf.co/llms/walmart.txt
REST: GET or POST https://api.fastaf.co/v1/walmart
x402: GET or POST https://api.fastaf.co/x402/v1/walmart
MCP tools: search_walmart
Prepaid credits: 5 per successful request, depending on options.
- per call: 5 credits.
x402 fixed price: $0.005000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: Walmart product search by a complete Walmart search URL containing the search query.

Parameters (GET query or POST JSON fields):
- url (required): Required full HTTP(S) walmart.com search URL, e.g. https://www.walmart.com/search?q=headphones. Include search, page and filter options in that URL; no default.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"url":"https://www.walmart.com/search?q=headphones"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/walmart?url=https%3A%2F%2Fwww.walmart.com%2Fsearch%3Fq%3Dheadphones'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/walmart?url=https%3A%2F%2Fwww.walmart.com%2Fsearch%3Fq%3Dheadphones'
Output: Walmart JSON. search_results is an array of groups, each containing an item array with titles, current_price, rating, review_count and availability_status when available.

## Zillow API
$0.005 per call, pay only for 200 responses
Real estate and property listing search API for AI agents: Zillow search URLs return JSON zillow_data with prices, addresses, beds, baths and listing links, plus coordinates and Zestimate when available. Supports US housing research without generic page scraping.
Product: https://fastaf.co/apis/zillow-api/
Detailed schemas and examples: https://fastaf.co/llms/zillow.txt
REST: GET or POST https://api.fastaf.co/v1/zillow
x402: GET or POST https://api.fastaf.co/x402/v1/zillow
MCP tools: search_zillow
Prepaid credits: 5 per successful request, depending on options.
- per call: 5 credits.
x402 fixed price: $0.005000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: US property search by a complete Zillow search URL, such as the city _rb URL in the example.

Parameters (GET query or POST JSON fields):
- url (required): Required full HTTP(S) Zillow URL, e.g. https://www.zillow.com/homes/Austin,-TX_rb/. Short city paths such as /austin-tx/ are normalized. Aliases address, location, city, q, query, search become /homes/<encoded value>_rb/ URLs; digits-only zpid becomes /homedetails/<zpid>_zpid/. Canonical url takes precedence. No default; answers without listings are not charged.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"url":"https://www.zillow.com/homes/Austin,-TX_rb/"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/zillow?url=https%3A%2F%2Fwww.zillow.com%2Fhomes%2FAustin%2C-TX_rb%2F'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/zillow?url=https%3A%2F%2Fwww.zillow.com%2Fhomes%2FAustin%2C-TX_rb%2F'
Output: Zillow JSON. zillow_data contains listings with zpid, displayed price, address, beds, baths and detailUrl, plus statusText, latLong and zestimate when available.

## eBay API
$0.005 per call, pay only for 200 responses
eBay product search and item data API for AI agents. eBay search or item URLs return JSON listings or product details with titles, prices, condition, shipping and links when available. Supports marketplace research and price comparison.
Product: https://fastaf.co/apis/ebay-api/
Detailed schemas and examples: https://fastaf.co/llms/ebay.txt
REST: GET or POST https://api.fastaf.co/v1/ebay
x402: GET or POST https://api.fastaf.co/x402/v1/ebay
MCP tools: search_ebay
Prepaid credits: 5 per successful request, depending on options.
- per call: 5 credits.
x402 fixed price: $0.005000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: eBay keyword search using resource=search and a search URL. Item URLs use resource=product.

Parameters (GET query or POST JSON fields):
- url (required): Required full HTTP(S) eBay search URL (/sch/...) or item URL (/itm/...) on an eBay country domain. Search/filter/pagination options go in this URL. No default.
- resource: eBay operation: search or product. FastAF defaults to product for /itm/ URLs and search otherwise; both have the same price. Allowed: search, product.
- html: Return raw source HTML instead of parsed JSON when true; true/false, default false.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"resource":"search","url":"https://www.ebay.com/sch/i.html?_nkw=mechanical+keyboard"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/ebay?resource=search&url=https%3A%2F%2Fwww.ebay.com%2Fsch%2Fi.html%3F_nkw%3Dmechanical%2Bkeyboard'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/ebay?resource=search&url=https%3A%2F%2Fwww.ebay.com%2Fsch%2Fi.html%3F_nkw%3Dmechanical%2Bkeyboard'
Output: eBay search JSON. search_results contains listing title, itemId, condition, price, extracted_price, shipping and link when available. Item lookups return product_results instead.

## X Scraper API
$0.005 per call, pay only for 200 responses
X (Twitter) public profile API for AI agents: look up a username for audience research and profile enrichment. Returns JSON with name, handle, biography, follower, following and post counts when available; public profile data, not tweet search.
Product: https://fastaf.co/apis/x-scraper-api/
Detailed schemas and examples: https://fastaf.co/llms/x.txt
REST: GET or POST https://api.fastaf.co/v1/x
x402: GET or POST https://api.fastaf.co/x402/v1/x
MCP tools: x_profile
Prepaid credits: 5 per successful request, depending on options.
- per call: 5 credits.
x402 fixed price: $0.005000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: Public X (Twitter) profile lookup by profileId, without an @ prefix.

Parameters (GET query or POST JSON fields):
- profileId (required): Required public X/Twitter username, e.g. nasa, without @ or a profile URL. No default; retrieves profile data, not an arbitrary post.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"profileId":"nasa"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/x?profileId=nasa'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/x?profileId=nasa'
Output: Public X profile JSON with name, handle, description, followers_count, following_count and statuses_count when available.

## Screenshot API
$0.005 per call, pay only for 200 responses
Web page screenshot API for AI agents: capture a website URL as PNG, JPEG or WebP image bytes for visual inspection and page archiving. Supports full-page capture, viewport dimensions and load readiness; the discovery example is a base64-encoded PNG, not a JSON response.
Product: https://fastaf.co/apis/screenshot-api/
Detailed schemas and examples: https://fastaf.co/llms/screenshot.txt
REST: GET or POST https://api.fastaf.co/v1/screenshot
x402: GET or POST https://api.fastaf.co/x402/v1/screenshot
MCP tools: No dedicated MCP tool; use the HTTP endpoint.
Prepaid credits: 5 per successful request, depending on options.
- per call: 5 credits.
x402 fixed price: $0.005000 USD per successful call, paid in USDC on Base. Unsupported higher-cost options require API-key billing.
Input: Website screenshot by URL with format=png and wait_until=load. Viewport and fullPage options are optional.

Parameters (GET query or POST JSON fields):
- url (required): Required public HTTP(S) page URL to capture in a browser. Private/network-internal targets and login paths are refused. No default.
- fullPage: Capture the entire scrollable page when true, or only the viewport when false; boolean, default viewport-only capture.
- width: Browser viewport width in CSS pixels, supplied as a positive integer string, e.g. 1280. Omitted: upstream viewport default; FastAF sets no fixed width.
- height: Browser viewport height in CSS pixels, supplied as a positive integer string, e.g. 720. Omitted: upstream viewport default; fullPage may produce a taller image.
- wait_until: Capture readiness: domcontentloaded (default) after DOM parsing, load after the load event, or networkidle after network activity is idle. Allowed: load, domcontentloaded, networkidle. Default: "domcontentloaded".
- format: Image encoding: png (default), jpg or webp. Response contains image bytes, not JSON or base64 text. Allowed: png, jpg, webp. Default: "png".
- quality: Image quality, integer 0-100; default 80. Applies to lossy jpg/webp encoding; PNG is lossless. Default: 80. Minimum: 0. Maximum: 100.
- X-FastAF-Max-Spend: Optional spending cap in USD, decimal with up to 6 places (e.g. 0.01). If this route's fixed price is above it, the call is refused with 409 spend_cap_exceeded before any payment challenge. x402 clients sign every payment, so no session total is kept here.

Example input:
{"url":"https://example.com/","format":"png","wait_until":"load"}
curl with API key:
curl --fail-with-body -H "Authorization: Bearer $FASTAF_API_KEY" 'https://api.fastaf.co/v1/screenshot?url=https%3A%2F%2Fexample.com%2F&format=png&wait_until=load'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i 'https://api.fastaf.co/x402/v1/screenshot?url=https%3A%2F%2Fexample.com%2F&format=png&wait_until=load'
Output: Tiny illustrative PNG encoded as base64 for JSON discovery only; the successful response contains image/png bytes, not JSON or base64 text. jpg and webp options return their respective image bytes.

## Structured Data Extraction API
$0.02 per call, pay only for 200 responses
Extract structured JSON from a public web page for AI agents: send a URL and a JSON Schema, get back JSON that validates against that schema, with optional JavaScript rendering and premium proxies. Optional schema fields may be missing or null; only fields listed in required are guaranteed to be present in a successful response. Optional nulls are omitted before validation. Answers that are not valid JSON or do not match the schema are never charged.
Product: https://fastaf.co/apis/extract-api/
Detailed schemas and examples: https://fastaf.co/llms/extract.txt
REST: POST https://api.fastaf.co/v1/extract
x402: POST https://api.fastaf.co/x402/v1/extract
MCP tools: extract
Prepaid credits: 40 per successful request, depending on options.
- per call: 40 credits.
x402 fixed price: $0.020000 USD per successful call, paid in USDC on Base. One price for plain, rendered and premium pages; answers that do not validate against the schema return 422 extraction_failed and are never charged or settled.
Input: POST only, JSON body: a public page url and a JSON Schema (draft 2020-12 subset: at most 8 KB, 5 levels and 50 properties, local $ref only, root type object or array). render_js (alias dynamic) and premium are optional; challenge_mode is not available.

Parameters (POST JSON fields):
- url (required): Required public HTTP(S) page URL, at most 8192 characters. Same rules as scrape: private targets and login paths are refused, Zillow/eBay point to their endpoints, Booking is rendered; Reddit and Amazon pages are refused. Nothing is charged for a refused URL.
- schema (required): Required JSON Schema object (draft 2020-12 subset) describing the JSON to return. Root type object or array; at most 8 KB without whitespace, 5 levels deep (root included) and 50 properties in total; local $ref (#/$defs/...) only, no recursion. Keywords: type, properties, required, additionalProperties, items, prefixItems, enum, const, anyOf, oneOf, allOf, not, $defs, format, pattern, numeric and length bounds, and annotations. An invalid schema returns 400 before anything is charged.
- render_js: Render JavaScript before extracting; true/false, default false (booking.com defaults true). Same price.
- dynamic: Alias for render_js; cannot disagree with it. Same price.
- premium: Use residential proxies; true/false, default false. Same price.

Example input:
{"url":"https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html","schema":{"type":"object","required":["title","price","in_stock"],"properties":{"title":{"type":"string"},"price":{"type":"object","required":["amount","currency"],"properties":{"amount":{"type":"number"},"currency":{"type":"string"}}},"in_stock":{"type":"boolean"}}}}
curl with API key:
curl -X POST 'https://api.fastaf.co/v1/extract' \
  -H "Authorization: Bearer $FASTAF_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{"url":"https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html","schema":{"type":"object","required":["title","price","in_stock"],"properties":{"title":{"type":"string"},"price":{"type":"object","required":["amount","currency"],"properties":{"amount":{"type":"number"},"currency":{"type":"string"}}},"in_stock":{"type":"boolean"}}}}'
curl for a fresh x402 challenge (HTTP 402 is expected; no payment is made):
curl -i -X POST 'https://api.fastaf.co/x402/v1/extract' \
  -H 'Content-Type: application/json' \
  -d '{"url":"https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html","schema":{"type":"object","required":["title","price","in_stock"],"properties":{"title":{"type":"string"},"price":{"type":"object","required":["amount","currency"],"properties":{"amount":{"type":"number"},"currency":{"type":"string"}}},"in_stock":{"type":"boolean"}}}}'
Output: JSON that validates against the request schema, minified. Optional schema fields may be missing or null; only fields listed in required are guaranteed to be present in a successful response. Optional nulls are omitted before validation. Answers that are not JSON, do not match the schema or exceed 64 KB return 422 extraction_failed with validation_errors and are never charged or settled.

## Account, billing and discovery endpoints

These are control/documentation routes, not additional public-data products. API-key/session eligibility and full schemas are in https://api.fastaf.co/openapi-api.json. Dashboard sessions only authorize the supported account/usage/key routes, not data spending.
- GET /v1/scrape/jobs/{job_id}: Poll a private scrape job Parameters: path:job_id (required).
- GET /v1/usage: Current account usage and credit balance
- GET /v1/requests: Recent API requests for the current account Parameters: query:limit, query:before, query:before_id.
- GET /v1/usage/daily: Daily usage aggregates per endpoint Parameters: query:days.
- GET /v1/keys: List API keys for the current account
- POST /v1/keys: Create an API key for the current account Parameters: body:name.
- DELETE /v1/keys/{id}: Revoke an API key Parameters: path:id (required).
- POST /v1/checkout: Start a credit pack purchase with the API key Parameters: body:pack (required).
- POST /x402/topup: FastAF Credit Packs Parameters: query:pack (required).
- POST /public/signup: Start email-confirmed free signup Parameters: body:email (required), body:terms_accepted (required), body:terms_version (required), body:turnstile_token (required).
- GET /public/signin/{token}: Follow the emailed confirmation or sign-in link Parameters: path:token (required).
- POST /v1/signup: Retired agent signup (always 410)
- GET /v1/scrape/content/{id}: Full content of a truncated max_tokens scrape Parameters: path:id (required).
- POST /public/signin: email and turnstile_token; sends a magic sign-in link.
- GET /public/session: current session, cookie required. POST /public/signout: clear the session.
- POST /public/checkout: JSON {pack}, session cookie required. GET /public/orders/{order_id}/status: checks order completion.
- GET /health: service health.
- GET /.well-known/x402.json: payable endpoint manifest; GET /x402/v1/: endpoint catalogue.
- GET /.well-known/mcp.json and /.well-known/mcp/server-card.json: public MCP discovery.
- GET /.well-known/mcp: MCP server card built from the registry entry co.fastaf/fastaf (name, transport, OAuth, tool names).
- GET /.well-known/agent-card.json: capability metadata, not an A2A message/task runtime.
MCP structured results contain credits_used (the list price of this call, whether paid from free or paid credits) and credits_remaining (account balance snapshot, free plus paid credits). These are response field names, not a requirement to prepay for x402.

## Free browser tools

POST /public/tools/serp-checker: JSON {query, gl?, domain?, turnstile_token}. query is required, at most 300 characters; gl is a two-letter country code, default us; domain is a bare hostname. Returns {results:[{position,title,url,domain}], domain?, position?}; null position means not found among up to ten organic results.
POST /public/tools/page-to-markdown: JSON {url, turnstile_token}. Public HTTP(S) URL, at most 2048 characters. Returns {markdown,truncated}, capped at 20,000 characters.
All require a server-verified Turnstile token, allow 3 attempts per tool per IPv4 /24 or IPv6 /64 per UTC day, and share a 300-attempt daily capacity limit. Failed attempts that reach the data service still count; missing/invalid tokens return 403 and exhaustion returns 429 with a signup link. They do not charge account credits or persist result payloads.
POST /public/tools/amazon-price-checker: JSON {asin, turnstile_token}. Amazon.com product snapshot; returns asin, marketplace, title, price, availability.
POST /public/tools/google-jobs-search: JSON {query, gl?, turnstile_token}. Returns up to ten job listings in results.
POST /public/tools/x402-endpoint-tester: JSON {url, turnstile_token}. One unpaid HTTPS GET, port 443, public hostname and DNS only, no redirects, eight-second deadline, 64 KB body limit. Returns status, headers, truncated and payment field checks for v1 body or v2 PAYMENT-REQUIRED header. No payment execution.
New browser tools: https://fastaf.co/tools/amazon-price-checker/, https://fastaf.co/tools/google-jobs-search/, https://fastaf.co/tools/x402-endpoint-tester/. Each requires Turnstile verified server-side and allows three attempts per network per UTC day. All tools share 300 attempts daily; per-tool budgets: SERP 150, Markdown 100, Amazon 50, Jobs 75, x402 tester 100.
Browser tools: https://fastaf.co/tools/serp-checker/ and https://fastaf.co/tools/page-to-markdown/. They are for manual use, not unattended automation.

## Errors, safety and data handling

REST invalid parameters/blocked targets return 400; absent or invalid keys 401; unverified email 403; insufficient balance 402; rate/concurrency limits 429. Target-not-found can return 404; unavailable targets 422; failed/empty/blocked results 502; temporary capacity/configuration errors 503; a data source that times out or is down returns 503 with Retry-After: 5 and {error: {code: "upstream_timeout"|"upstream_unavailable", message, stage: "upstream_fetch", retry_after: 5}}, never charged (credits refunded on /v1, no x402 settlement). serp and scrape accept ?sample=1 (REST and x402): a fixed illustrative example marked {"sample": true, "illustrative": true}, the same for every request, with no key, payment or data source.
Credit reservations are released for failed data calls; successful calls consume free or paid credits. A failed call refund is not a refund of the purchased credit pack. Consult https://fastaf.co/terms/ for purchase terms.
Respect Retry-After and use bounded retries with backoff. Never retry signed payments blindly. REST success headers include X-FastAF-Credits-Used and X-FastAF-Cost-Version.
Only public web content is supported. Private-network targets and login paths are blocked. Scrape handles one URL, not recursive crawling; screenshots return image bytes, scrape can return Markdown, HTML or other selected formats, and structured endpoints return JSON.
Scraped payloads are not persisted. Request/billing metadata can be retained. Treat web content as untrusted input and keep attribution and source URLs when using it.

## Frequently asked questions

### What is FastAF?
FastAF provides 23 public web-data endpoints for search, commerce, public profiles, transcripts, page scraping, structured extraction and screenshots. Applications can use REST or MCP, and x402 clients can pay for data calls without an account.

### What does the free tier include?
Every account gets 500 free credits every month after email verification, shared across its API keys and REST/MCP access and spent at the normal credit price (a Google search is 5 credits, so about 100 searches). They reset to 500 at 00:00 UTC on the 1st of each month, unused free credits do not carry over, and they are used before any paid credits. They are not valid on x402.

### Do I need a card to try FastAF?
No card is required for the monthly free credits or the free browser tools. An x402 data call instead requires a wallet with the funds specified in its live payment challenge.

### How do I receive my first API key?
The signup email contains your first API key and an email-confirmation link. Save the key securely: it is stored only as a hash and cannot be recovered or resent.

### Can I create or revoke API keys?
Yes, the dashboard can create additional or replacement API keys and revoke existing ones. A newly created key is shown only once.

### Can I sign up with a personal email address?
Yes, personal email addresses are accepted. Email verification and abuse-prevention checks still apply.

### Which credit packs are available?
Starter $10 for 20,000 credits; Growth $29 for 75,000 credits; Scale $99 for 300,000 credits; Pro $299 for 1,000,000 credits; Business $799 for 3,000,000 credits. These optional prepaid credit packs are one-time purchases, without expiry, rather than subscriptions.

### When do purchased credits expire?
Paid credits never expire, including credits from earlier purchases. Only free credits reset on the 1st of each month; paid credits are unaffected.

### How much does a Google search cost?
A default Google search uses 5 prepaid credits; advanced search uses 10. The independent x402 price is $0.003 per successful standard search, with the live challenge authoritative.

### How much does a page scrape cost?
A basic scrape uses 1 prepaid credit and JavaScript rendering uses 5. Other options can increase the cost, so check the endpoint reference before making the request.

### Are failed data requests charged?
Failed data requests do not consume free or prepaid credits; any credit reservation is released. An unsuccessful x402 data request does not settle a payment.

### Does an API error refund a credit-pack purchase?
No: restoring a failed request’s reserved credits is different from refunding a credit-pack purchase. Purchase refund conditions are described in the terms.

### What is x402 access?
x402 lets a client request data, receive an HTTP 402 payment challenge and retry with a signed payment. Prices start at $0.003 per call. Prices start at $0.003 per call. FastAF uses USDC on Base for production data calls and settles only successful results.

### Does x402 require an account or API key?
Per-call x402 data endpoints do not require a FastAF account or API key. Buying a credit pack through the separate /x402/topup endpoint does require an existing API key.

### Can every REST option be used over x402?
No: x402 endpoints have fixed prices and reject options that exceed what that price covers with options_need_api_key. Use API-key billing for those higher-cost variants.

### How do I authenticate a REST data request?
Send Authorization: Bearer with your API key, or use the X-API-Key header. Dashboard session cookies and MCP OAuth tokens cannot authorize REST data calls.

### How does MCP authentication work?
MCP discovery is public, while tool calls require an API key or an OAuth connection authorized with an existing FastAF key. MCP does not accept x402 payments.

### What is the concurrency limit?
Account concurrency is 2 on the free tier, 5 with a paid pack and 25 at the Business threshold. The allowance is shared across keys and REST/MCP activity, and burst limits also apply.

### Can FastAF access private or login-only pages?
No, FastAF is for public web data, not content behind an account or paywall. Private-network targets and login paths are blocked.

### Does FastAF store scraped page content?
FastAF does not persist scraped payloads. Request and billing metadata can be recorded for usage, reliability and account history.

### Can FastAF crawl a whole website?
The scrape endpoint processes one public URL per call. FastAF does not provide a recursive whole-site crawl or map endpoint.

### What are the free browser tool limits?
The SERP checker and Page to Markdown each allow three attempts per network per UTC day, sharing IPv4 /24 and IPv6 /64 allowances. A combined 300-attempt daily capacity limit also applies, and these tools do not spend account credits.

### How should I handle rate limits?
For HTTP 429, wait for the Retry-After interval before retrying and reduce concurrent requests. For the free browser tools, daily allowances reset at midnight UTC.

## Use cases and glossary

- Amazon Price Monitoring API for AI Agents: https://fastaf.co/use-cases/scrape-amazon-prices-ai-agent/ Track Amazon product prices and availability from an agent or script with FastAF's Amazon endpoint. Pay per call via x402, no subscription.
- Job Listings Aggregation API: https://fastaf.co/use-cases/google-jobs-api-for-agents/ Aggregate job postings from Google Jobs into your app or agent. FastAF jobs endpoint, $0.005 per call via x402, no subscription.
- eBay sold listings API for agents: https://fastaf.co/use-cases/ebay-sold-listings-api/ Understand eBay search URLs, sold filters and the limits of listing data.
- News Monitoring API for AI Agents: https://fastaf.co/use-cases/google-news-api-for-agents/ Monitor Google News for brands, competitors or topics from an agent. FastAF news endpoint, $0.005 per call via x402.
- SERP Rank Tracking API for AI Agents: https://fastaf.co/use-cases/serp-api-for-ai-agents/ Check where a domain ranks on Google from an agent. FastAF's SERP endpoint returns Google results as JSON at $0.003 per call via x402.
- Web Scraping API for RAG Pipelines: https://fastaf.co/use-cases/web-page-to-markdown-for-llm/ Fetch public web pages for retrieval-augmented generation. FastAF scrape and search endpoints, pay-per-call via x402, MCP-ready.
- x402: https://fastaf.co/glossary/x402/ x402 is a protocol for paying for HTTP resources using a payment challenge and a signed retry.
- MCP: https://fastaf.co/glossary/mcp/ Model Context Protocol (MCP) standardizes how AI applications discover and invoke tools and access context.
- HTTP 402: https://fastaf.co/glossary/http-402/ HTTP 402 Payment Required is an HTTP status code indicating that payment is required for a resource.
- Pay-per-call API: https://fastaf.co/glossary/pay-per-call-api/ A pay-per-call API charges for individual API requests rather than requiring a recurring subscription.
- API use cases for AI agents: https://fastaf.co/use-cases/ Practical workflows for search, commerce, news, jobs and page content.
- Agent API and payments glossary: https://fastaf.co/glossary/ Plain-English definitions of x402, MCP, HTTP 402, USDC on Base and other terms for agent payments and tools.
- Google Flights API for AI Agents: https://fastaf.co/use-cases/google-flights-api-for-agents/ Search Google Flights for flight itineraries and current fares.
- Token-aware web scraping for AI agents: get only the content your LLM needs: https://fastaf.co/use-cases/token-aware-scraping/ Large pages blow up agent context windows. Use FastAF scrape and structured endpoints to return clean, compact data per call from $0.003.

## Agent data guides

- [Pay-per-call web scraping for AI agents with x402](https://fastaf.co/how-to/x402-pay-per-call-web-scraping/)
- [MCP servers for Amazon, SERP and web scraping](https://fastaf.co/how-to/best-mcp-servers-amazon-serp-scraping/)
- [Cost per agent: monthly SaaS vs x402 pay-per-call](https://fastaf.co/how-to/cost-per-agent-saas-vs-x402/)
- [How FastAF handles heavy pages and timeouts](https://fastaf.co/how-to/heavy-pages-timeouts/)
- [x402 endpoint discovery checklist: how agents find a paid API](https://fastaf.co/how-to/x402-discovery-checklist/)
- [Add FastAF to Claude Code, Codex and Cursor](https://fastaf.co/how-to/add-fastaf-claude-code-codex-cursor/)
- [How to detect poisoned or incomplete SERP results in AI agents](https://fastaf.co/how-to/detect-poisoned-incomplete-serp-results/)
- [Cap agent spend per call with fixed x402 prices](https://fastaf.co/how-to/agent-spend-caps-per-call-pricing/)
- [Use FastAF from the Cloudflare Agents SDK](https://fastaf.co/how-to/fastaf-cloudflare-agents-sdk/)
- [FastAF as a fallback search provider](https://fastaf.co/how-to/search-api-fallback-provider/)
- [Budget a scraping job before you run it](https://fastaf.co/how-to/budget-scraping-job-fixed-prices/)
- [Try FastAF for free, no card](https://fastaf.co/how-to/free-search-api-for-agents/)
- [Too many MCP tools? Keep agent context small](https://fastaf.co/how-to/mcp-tool-schema-bloat/)
- [How agents find an API (and where FastAF is)](https://fastaf.co/how-to/agent-discovery-files/)
- [Why agent retries cost more than you think](https://fastaf.co/how-to/agent-tool-retry-cost/)

## Further reading

- FAQ: https://fastaf.co/faq/
- Comparisons: https://fastaf.co/compare/apify/, https://fastaf.co/compare/firecrawl/, https://fastaf.co/compare/exa/
- Free tiers compared (FastAF, Tavily, Firecrawl, Exa): https://fastaf.co/compare/free-tier/
- MCP setup by client: https://fastaf.co/integrations/claude-code/, https://fastaf.co/integrations/cursor/, https://fastaf.co/integrations/vercel-ai-sdk/, https://fastaf.co/integrations/openai-agents-sdk/, https://fastaf.co/integrations/langchain/
- Token-efficient web data: https://fastaf.co/docs/token-efficient-web-data/
- Summary: https://fastaf.co/llms.txt
- x402 OpenAPI: https://api.fastaf.co/openapi.json
- Complete OpenAPI: https://api.fastaf.co/openapi-api.json
- Documentation: https://fastaf.co/docs/
- Pricing: https://fastaf.co/pricing/
- x402 price list: https://fastaf.co/pricing/x402-price-list/
- Signup: https://fastaf.co/signup/