Oxylabs AI Mode scraper: a repository with no code and a 400 character query cap

Three parameters are mandatory and one defaults to false

The request table is the whole interface, and it is small. Three parameters are mandatory: `source`, which must be set to `google_ai_mode` to select the scraper, `query`, the prompt itself, which cannot exceed 400 characters, and `render`, where `html` is required for this source. That last one is the odd requirement in the table, since the product's pitch is parsed JSON rather than rendered HTML, and the documentation does not explain why an HTML render is the prerequisite for it. `parse` defaults to `false` and turns parsed data on when set to true, `geo_location` names the country the prompt is sent from, and `callback_url` takes an endpoint for push delivery. The default column is inconsistent too, mixing a dash character with a hyphen for the same meaning of not applicable, so a reader parsing the table has to normalise it.

The sample posts to one endpoint with credentials in a tuple

The whole request is thirty lines and one POST. Install `requests`, then:

import json
import requests

# API parameters.
payload = {
    'source': 'google_ai_mode',
    'query': 'best health trackers under $200',
    'render': 'html',
    'parse': True,
    'geo_location': 'United States'
}

# Get a response.
response = requests.post(
    'https://realtime.oxylabs.io/v1/queries',
    # Replace with your credentials.
    auth=('USERNAME', 'PASSWORD'),
    json=payload,
)

# Print the response to stdout.
print(response.json())

# Save the response to a JSON file.
with open('response.json', 'w') as file:
    json.dump(response.json(), file, indent=2)

Note what the sample does not do. There is no retry, no timeout, no status check on the HTTP response, and it calls `response.json()` twice rather than once, so a non-JSON error body surfaces as an exception rather than a message. Authentication is HTTP basic with the username and password sitting in the source file as placeholders, and `geo_location` is sent as a plain country name. The response is written to disk with an indent so a human can read it, which is a reasonable default for a first call and a poor default for a loop.

Two status codes, one for the job and one for the parse

The output is a job envelope. At the top level sit `url`, `page`, `content`, `created_at`, `updated_at`, `job_id` and `status_code`, where the last one is the status of the scraping job itself. Inside `content` there are `links` for the external references shown in the side box, `prompt` for the original prompt, `citations` for the citation list in the main block, `response_text`, `markdown_text`, and `parse_status_code`, the status of the parsing operation alone. So a successful job can carry a failed parse, and the two fields are the only way to tell that apart. The schema documentation adds a warning that matters more than the field list: depending on the search query, both the number of items and the fields included can change. A consumer that treats this as a fixed schema will break on the first unusual prompt.

The JSON sample ends mid object and the HTML section is empty

The output samples section has two headings. The JSON one opens an object, shows a `results` array with one content object, two real citation entries and then an elided third, and stops in the middle of the `citations` array at an opening brace. The second heading, for an HTML example, has nothing under it at all, even though `html_example.png` sits in the repository tree as an image showing what that example would have been. A reader who needs the HTML output shape has to look at a picture or at the full sample file. The full JSON sample is linked, and it is one of the links worth reading carefully, because the two example links in the README are not to the current branch.

Both sample links are pinned to one commit hash

The link to the full JSON output sample points into the blob view of a specific commit, and the link to the language samples points into the tree view of the same commit. Both carry a forty character hash in the path. Nothing in the README links to `main` or to a directory, so a reader who clicks through sees a frozen snapshot and has no way from the page to tell whether it is the current state. For an example file that is defensible, since samples should not drift under a reader's feet, but here the same hash is used for the code examples directory as well, which is where drift actually matters. The repository's default branch is `main` and the last push was 2026-08-21, so there is content on the branch that the README's own example links do not show.

There is no source code and the language field says Java

The entire top level of the repository is `README.md`, `output-sample.json`, a directory named `Code examples`, and three images: `ScraperAPI+GoogleAI-1090x275px.png`, `html_example.png` and a GitHub repositories banner. There is no build file, no library, no wrapper, no test and no licence file. Repository metadata reports the primary language as Java, which comes from the language sample files inside the examples directory rather than from anything that ships. The licence field is empty, so neither the metadata nor the tree tells you what you are licensed to use the samples under. The interesting number is the shape of the audience: 3628 stars against 32 forks and zero open issues, which is the ratio you get when a repository is a signposting page rather than a codebase.

The first badge is an affiliate link carrying a transaction id

The header line before the title is a link to the vendor's product page, and it is not clean. It carries `utm_source=877`, `utm_medium=affiliate`, `utm_campaign=llm_scrapers`, `utm_content=google-ai-mode-scraper-github` and a `transaction_id` of thirty-two hex characters. A second badge links to a Discord invite, a third to the vendor's YouTube channel, and a callout later in the file offers a free trial on the vendor's dashboard. So the path from the repository to a paying account is laid out in the first three lines and repeated at the point where the request sample is introduced. None of that is hidden, and affiliate tracking on an open source README is normal practice. It does mean the repository should be read as the top of a sales funnel, which is the frame to keep in mind when weighing the use cases listed further down.

The legality question is answered with a referral

The first entry in the README's own FAQ asks whether it is allowed to scrape AI generated content from Google, and the answer is that legality depends on factors like Google's terms of service, your use case and applicable laws, followed by a recommendation to consult a legal expert before proceeding. That is the honest answer and it is also the only one available, since the vendor cannot grant permission on Google's behalf. The second question, about limitations of the scraper, is answered with a single word in this copy of the file and then cut off. The use cases the README does commit to are monitoring brand presence in AI results, adapting content for AI driven search interfaces, and gathering responses as training data, which is the one that carries the most legal weight of the three.

Editorial conclusion

Treat this as documentation for a paid API rather than as a library, because that is what it is, and the sample code is thirty lines you could write yourself once you have credentials. Read the parameter table before budgeting anything: the 400 character query cap will shape how you chunk prompts, the mandatory html render is unexplained, and parse defaults to false, so an unparsed response looks like an empty one unless you check parse_status_code separately from status_code. Treat the response schema as unstable, since the project itself says fields and item counts vary by query. And settle the legal question for your own use case before writing the first call, because the repository explicitly declines to answer it.

Frequently asked questions

Official sources

1. Issues
2. oxylabs/google-ai-mode-scraper on GitHub
3. Project website
4. README