Oxylabs AI Studio Python SDK: five apps, one API key, and an archived repository

An archived repository, one release, and a manifest three patches ahead

The repository state deserves stating before the API does. It is marked archived, and the most recent commit on the default branch is dated 21 August 2026. The published release history contains a single entry, version 0.2.19 from November 2025, while the project manifest in the same repository declares version 0.2.22. So the version you install from the package index and the version the source tree describes are not the same number, and the repository is not the place where changes are still landing. The licence is MIT and the project points at a hosted service as its home, since this is a client for someone else's API rather than a tool you run yourself. Everything the SDK does happens on that service, with your key.

Five apps, one class each, and an API key in the constructor

The SDK is organised as five classes, each in its own module under a package named for the apps, and each takes the API key when you construct it. Crawl takes a site and a natural language prompt and walks it. Scrape takes a single URL. The browser agent takes a URL and a prompt and drives a page before capturing it. Search takes a query. Map takes a site and returns a picture of it. Map is also the endpoint with the widest parameter set in the documented examples, combining a crawl depth limit, a result limit, a list of search keywords to steer the crawl, a flag to include the site's sitemap, a credit ceiling, and two booleans that decide whether the crawl may leave the starting host: one for subdomains and one for other domains entirely. Construction looks the same in every case:

from oxylabs_ai_studio.apps.ai_crawler import AiCrawler

crawler = AiCrawler(api_key="<API_KEY>")

The stated requirements are Python 3.10 or newer and an API key, and installation is a single pip command for the package name. Results come back on a data attribute of the returned object rather than as a bare value, which is the one convention worth internalising before writing the calling code.

The output format decides whether you owe it a schema

Every endpoint takes an output format, and the set of allowed values differs by endpoint: crawl offers json, markdown, csv and toon; scrape adds a screenshot option; the browser agent adds html as well. The rule underneath is consistent. If the format is json, csv or toon, a schema is required, and the schema is a JSON schema describing the fields you want back. Markdown and screenshot need nothing. That makes the structured path two-step: describe what you want in a prompt, ask the SDK to turn it into a schema, then pass that schema with the scrape or crawl call. The helper is a method on the client itself, taking the same kind of natural language sentence the rest of the SDK uses.

JavaScript rendering is off everywhere, and a string only on one endpoint

A rendering flag appears on crawl, scrape, search and map, and its default is False in all four cases, which means the fast path is assumed and pages that build their content in the browser come back empty. The scraper is the exception that matters: its flag accepts either a boolean or the string auto, where auto asks the service to detect whether rendering is needed. The other endpoints do not document that option. The scraper also takes a list of browser instructions, actions to run before the capture, such as clicking, typing and waiting, but that list requires rendering to be switched on, and its format follows the browser instruction format of the vendor's separate web scraper API.

Search quietly switches endpoints when you ask for less

The search endpoint has a threshold behaviour that is worth knowing before you benchmark it. A normal search takes a limit that defaults to ten and tops out at fifty, and a flag that decides whether the results include page content, defaulting to on. The separate instant search takes a limit capped at ten and returns immediately. The automatic part: when the limit is ten or less and content retrieval is switched off, the ordinary search call does not poll, it uses the instant endpoint instead. The location parameter differs between the two as well, documented in one place as a two letter code, a country name or coordinates, and in the instant path as Google's canonical location name. So a request that looks like a normal search can travel a different route depending on two booleans and an integer.

Location, user agent, and a ceiling on credits

Three parameters show up across the endpoints and are the ones that shape a bill. A location parameter takes a two letter country code or a country name and points the request at a proxy in that place, with the list of accepted values documented on the vendor's developer site and linked from each endpoint. A user agent parameter on the scraper sets the request header, documented on the same site. A max credits parameter, optional, appears on crawl and map and caps what a single call can spend, which is the mechanism for keeping one expensive request from consuming a month of allowance. The scraper also has an option that trims output to the main page content, on by default, which produces cleaner and smaller markdown when you only need the article body.

A uv lockfile, a hatchling build, strict typing and a wide lint rule set

The packaging tells you the project was set up with current tooling. The manifest requires Python 3.10 or newer, builds with hatchling, and declares five runtime dependencies: an async HTTP client, the validation library and its settings companion, a dotenv loader, and a retry library. A separate development group adds a type checker, a linter and the package upload tool. The type checker runs in strict mode with missing imports ignored, and the linter targets Python 3.12 with a broad rule selection covering style, bug patterns, comprehension simplification, import sorting, naming, return style, upgrade suggestions and the bandit security checks, with one exception carved out for bare excepts. The repository root carries a uv lockfile, a lowercase makefile, a guide for agentic coding, and eleven example scripts covering every endpoint. Those examples are where the parameter combinations live that the documentation does not spell out: one pair differs only by whether content comes back with the results, another generates its schema before scraping, and two of them pass a Pydantic model rather than a plain dictionary, which is the practical reason the validation library is a runtime dependency instead of a development one.

Editorial conclusion

Oxylabs AI Studio SDK suits a Python developer who already has an API key and wants the five extraction endpoints behind one import each, with a schema helper for the structured formats and a credit ceiling per call. It does not suit a team starting a new integration, because the repository is archived and the single published release is older than the version in its own manifest, so a fresh project should check whether the service and its SDK are still the maintained path. Three things to verify before writing code against it: whether your output format forces a schema, since json, csv and toon all require one and markdown does not; whether your crawl needs JavaScript rendering, because the default is off everywhere and the scraper is the only endpoint that accepts an automatic detection mode; and how a search call behaves at small limits, because below ten results with content retrieval disabled it silently switches to a different endpoint that returns without polling.

Frequently asked questions

Official sources

1. License: MIT
2. oxylabs/oxylabs-ai-studio-py on GitHub
3. Project website
4. README
5. Releases