# Customer Spotlight: Bringits, a Web Unblocker API and Data Platform for Production Scraping Bringits is a web data platform built around a web unblocker API: you send it a URL, and it handles the IPs, browser fingerprints, sessions, and retries needed to get the page back. Its Unblocker product "bypasses anti-bot systems, manages fingerprinting, and delivers clean data automatically," according to [Bringits](https://bringits.com/products/unblocker/). Around it, Bringits offers Stream, a no-code builder for scraping workflows, and an AI Parser that turns pages into structured fields. Bringits is a Massive customer. This spotlight explains how its web unblocker API works, based on Bringits' public documentation and our own requests to its endpoints on October 26, 2026. > **Key Takeaways** > > - Bringits' web unblocker API takes one `POST` with a target `method` and `url`, plus optional `headers`, `body`, `countries`, and `browser: true` for JavaScript-rendered pages. > - Responses come back in a **JSON envelope**. A target's 404 is delivered as a successful call, with the target's status inside the envelope. > - Errors use **nine documented codes**, each with retry guidance. `TARGET_BLOCKED` returns `Retry-After: 60`; `SERVICE_UNAVAILABLE` returns `Retry-After: 5`. > - A separate `/llm` endpoint returns ChatGPT answers as text and markdown, fetched from a chosen country. > - Bringits states 1,000+ requests per second, under 200ms average response time, a 99.9% uptime SLA, and 40B+ pages processed monthly. ## What is a web unblocker API? A web unblocker API, also called a web unlocker API, is a single endpoint that fetches a web page for you and deals with the defenses that stop ordinary scrapers. Instead of managing proxy pools, CAPTCHAs, and headless browsers yourself, you send a URL and get the response. Our glossary entry on [what a web unblocker is](https://www.joinmassive.com/glossary/what-is-a-web-unblocker) covers the general idea. The company describes its version as "not just another proxy network. It's a managed web access engine." The product page lists four mechanisms: adaptive requests that adjust to a site's protections, per-request control of "browser fingerprints, headers, sessions, and rendering," automatic IP rotation and retries, and an "ML layer that classifies every scraping result in real time" to improve request strategies over time ([Bringits](https://bringits.com/products/unblocker/)). The team says it built the product from experience. Its about page says it was built by engineers who spent "years solving the challenges that emerge when web data becomes mission-critical," including "sophisticated blocking, constantly changing sources, high-frequency collection, data quality, performance, and reliability at scale" ([Bringits](https://bringits.com/company/about/)). ## How does the Bringits Unblocker request work? Every call goes to `POST /request` on `unblocker.bringits.com` with a Bearer token. The body names the target and, optionally, the country to route through and whether to render the page in a browser ([Bringits Docs](https://docs.bringits.com/unblocker/request)):
BASH
curl -X POST \
  https://unblocker.bringits.com/request \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -d '{"method": "GET",
       "url": "https://example.com",
       "countries": ["BR"],
       "browser": true}'
| Parameter | What it does | |---|---| | `method` | Target HTTP method: `GET`, `POST`, `PUT`, `DELETE`, `PATCH`, `HEAD`, or `OPTIONS`. Ignored when `browser` is true | | `url` | The page to fetch | | `headers`, `body` | Optional headers and raw body sent to the target (HTTP mode only) | | `countries` | Optional ISO country codes used to pick an egress proxy, such as `["US","GB"]` | | `browser` | `true` loads the page in a headless browser and returns the rendered HTML | Two details from the docs are worth knowing before you build on it. If no proxy matches the requested countries, the request "still runs via direct egress," meaning it goes out without a proxy, with fingerprint emulation still applied. And usage "is incremented only after the target response is successfully read," so transport and proxy-selection failures don't count against your monthly quota ([Bringits Docs](https://docs.bringits.com/unblocker/request)). ## How does Bringits report errors and blocks? Every response is a JSON envelope with four fields: `status`, `headers`, `body`, and `error`. When Bringits delivers a page, the outer HTTP status is 200 even if the target returned 404 or 500. The target's real status sits in the `status` field. That design separates "the site said no" from "the request failed," which a scraper that only checks the outer HTTP status cannot tell apart. When something does fail, `error` holds one of nine codes, and the docs say which ones to retry: | HTTP | `error` | Retry? | |---|---|---| | 400 | `INVALID_REQUEST` | No, fix the request | | 401 | `INVALID_CREDENTIALS` | No, check the token | | 403 | `ACCESS_DENIED` | No | | 429 | `QUOTA_EXCEEDED` | After the monthly reset | | 429 | `RATE_LIMITED` | After `Retry-After` | | 502 | `TARGET_BLOCKED` | After `Retry-After` (60 seconds) | | 503 | `SERVICE_UNAVAILABLE` | After `Retry-After` (5 seconds) | | 504 | `TARGET_TIMEOUT` | Yes, with backoff | | 500 | `INTERNAL_ERROR` | Once | ![Four-step flow of a Bringits Unblocker request: quota check, proxy selection, fetch or browser render, JSON envelope.](assets/bringits-request-flow.png "How a Bringits Unblocker request resolves, from Bringits' documentation.") Source: [Bringits Docs, "Request"](https://docs.bringits.com/unblocker/request). Self-serve plans have a monthly request quota, and a `QUOTA_EXCEEDED` response includes `used`, `limit`, and `reset_at`. The docs add that "Enterprise tenants are not subject to monthly request quotas." Here is a small Python client built on the table above. It retries the four transient codes, treats `INTERNAL_ERROR` as final to keep the example short, honors `Retry-After` when present, and returns the target's own status:
PYTHON
import time
import requests
API = "https://unblocker.bringits.com/request"
RETRY = {"RATE_LIMITED", "TARGET_BLOCKED",
         "SERVICE_UNAVAILABLE", "TARGET_TIMEOUT"}
def fetch(url, token, tries=3, **opts):
    body = {"method": "GET", "url": url, **opts}
    head = {"Authorization": f"Bearer {token}"}
    for n in range(tries):
        r = requests.post(API, json=body,
                          headers=head, timeout=180)
        try:
            env = r.json()
        except ValueError:
            r.raise_for_status()  # plain-text auth errors
            raise
        if env.get("error") is None:
            return env["status"], env["body"]
        if env["error"] not in RETRY:
            raise RuntimeError(env["error"])
        if n + 1 == tries:
            break
        wait = r.headers.get("Retry-After")
        time.sleep(int(wait) if wait else 2 ** n)
    raise RuntimeError(env["error"])
Call it as `fetch("https://example.com", token, browser=True, countries=["BR"])`. We tested it against fixtures built from the documented envelope: a success, a delivered target 404, option pass-through, a block followed by success, repeated timeouts, a quota error, a bad request, a plain-text auth error, and giving up after three tries. All nine tests passed. `QUOTA_EXCEEDED` is deliberately not retried, because the quota only resets monthly (see `reset_at`). Bringits' docs give `Retry-After` in seconds; the HTTP standard also allows a date there ([RFC 9110](https://www.rfc-editor.org/rfc/rfc9110.html#name-retry-after)), so parse it defensively if you reuse this client elsewhere. ## What we saw when we called the endpoints without a token On October 26, 2026, we sent requests to both Bringits endpoints with no token and with an invalid one, to see what an integration hits first. | Request | Response | |---|---| | `POST /request`, no token | `403 Forbidden`, plain text | | `POST /request`, invalid token | `401 Unauthorized`, with a `WWW-Authenticate: Bearer ... error="invalid_token"` header, the standard Bearer token error ([RFC 6750](https://www.rfc-editor.org/rfc/rfc6750.html)) | | `POST /llm`, no token | `403 Forbidden`, plain text | The plain-text replies suggest the token is checked at a gateway in front of the Unblocker service, so they arrive without the JSON envelope. That is why the client above checks for a non-JSON response first. Treat both 401 and 403 as "fix your credentials," not as a block to retry. ## What else is in the Bringits platform? Bringits has two products around the Unblocker, and two packaged data services: - **Stream** lets teams "build, automate, and control web scraping flows" in a visual, no-code builder, with scheduling, retries, monitoring, and alerts ([Bringits](https://bringits.com/products/stream/)). Its docs list [browser commands](https://docs.bringits.com/stream/commands/browser), more than 20 [parsing commands](https://docs.bringits.com/stream/commands/parse), [data validation steps](https://docs.bringits.com/stream/commands/validation), and [sinks](https://docs.bringits.com/stream/commands/sink) that deliver results to [RabbitMQ](https://docs.bringits.com/stream/commands/sink/rabbitmq-sink), [Kafka](https://docs.bringits.com/stream/commands/sink/kafka-sink), [S3](https://docs.bringits.com/stream/commands/sink/s3-sink), and [MongoDB](https://docs.bringits.com/stream/commands/sink/mongodb-sink). - **AI Parser** turns raw pages into structured fields. You can "describe the data in plain language, and AI generates the extraction rule automatically," and Bringits says it adapts when page layouts change ([Bringits](https://bringits.com/products/parser/)). - **E-commerce data APIs** cover product, pricing, stock, and seller data across seven marketplaces, including Amazon, Shopee, and MediaMarkt, delivered as JSON or in batches to S3, Snowflake, or BigQuery ([Bringits](https://bringits.com/solutions/ecommerce/)). - **LLM data APIs** return prompt and response data with citations from AI models. The `/llm` endpoint takes a `prompt` and optional `countries`, defaults to the US, and returns `response.text` and `response.markdown`. ChatGPT is live and Gemini is listed as coming soon ([Bringits Docs](https://docs.bringits.com/unblocker/llm)). Bringits' homepage lists customers including AutoDS, FinViz, Zoomd, and LSports. ## Bringits' stated scale Four headline numbers appear on the Bringits homepage ([Bringits](https://bringits.com/)): | Metric | Bringits' stated figure | |---|---| | Requests per second | 1,000+ | | Average response time | Under 200ms | | Uptime SLA | 99.9% | | Pages processed monthly | 40B+ | These are Bringits' own figures. We did not measure them, since our tests above did not use a token. The e-commerce and LLM data pages both cite "99.9% delivery reliability." ## Who is Bringits for? Bringits fits three kinds of teams: 1. **Engineering teams tired of maintaining scrapers.** The Unblocker removes proxy and browser upkeep, and its envelope makes failures easy to sort. 2. **Data and operations teams without much engineering time.** Stream's no-code flows, monitoring, and sinks move collection out of custom scripts. 3. **Companies that want the dataset, not the pipeline.** The e-commerce and LLM data APIs deliver normalized records on a schedule. If you are building AI agents that read the web, our guide to [giving AI agents live web access](https://www.joinmassive.com/blog/how-to-give-ai-agents-live-web-access) covers where an unblocker fits next to search APIs and browsers. For the anti-bot side, see our [2026 anti-bot playbook](https://www.joinmassive.com/blog/2026-anti-bot-playbook). Our earlier spotlight on [Gaffa's browser automation API](https://www.joinmassive.com/blog/gaffa-browser-automation-api) covers a related approach. And if you would rather build your own collection stack, Massive's [Web Render API](https://www.joinmassive.com/blog/introducing-massive-web-render-api) returns clean HTML or markdown from any public source, in any location. ## Frequently Asked Questions ### What is Bringits? Bringits is a web data platform. Its products are Unblocker, a web unblocker API; Stream, a no-code builder for scraping workflows; and AI Parser, which turns web pages into structured data. It also sells e-commerce and LLM datasets through dedicated APIs. ### How does a web unblocker API work? You send the target URL to one endpoint. The service picks an IP, sets browser fingerprints and headers, renders the page if asked, retries failures, and returns the response. With Bringits, the response arrives in a JSON envelope that includes the target's own HTTP status. ### Does Bringits render JavaScript? Yes. Setting `browser` to `true` in the request loads the page in a headless browser and returns the rendered HTML in the response body. ### Can I choose a country with Bringits? Yes. The `countries` field takes ISO country codes and selects an egress proxy in one of them. If none matches, the docs say the request runs through direct egress instead. ### Does Bringits charge for failed requests? According to its docs, usage is counted only after the target response is successfully read, not on transport or proxy-selection failures. Its data API pages say customers "pay for delivered records, not retry attempts." ## The bottom line - Bringits' web unblocker API packages web access as one call, with clear errors and retry guidance in its docs. - Stream and AI Parser cover the steps after fetching: scheduling, monitoring, parsing, and delivery. - Read the envelope, not the outer status: the target's real answer is in the `status` field. ## Sources - Bringits, [Home](https://bringits.com/), [About](https://bringits.com/company/about/), [Unblocker](https://bringits.com/products/unblocker/), [Stream](https://bringits.com/products/stream/), [AI Parser](https://bringits.com/products/parser/), [E-commerce data](https://bringits.com/solutions/ecommerce/) - Bringits Docs, ["Request"](https://docs.bringits.com/unblocker/request), ["LLM Scraping API"](https://docs.bringits.com/unblocker/llm), and Stream's ["Browser"](https://docs.bringits.com/stream/commands/browser), ["Parse"](https://docs.bringits.com/stream/commands/parse), ["Validation"](https://docs.bringits.com/stream/commands/validation), and ["Sink"](https://docs.bringits.com/stream/commands/sink) command pages - IETF, [RFC 9110: HTTP Semantics](https://www.rfc-editor.org/rfc/rfc9110.html) and [RFC 6750: Bearer Token Usage](https://www.rfc-editor.org/rfc/rfc6750.html) - Massive, no-token request test of Bringits' `/request` and `/llm` endpoints, October 26, 2026 (first-party test) - Massive, fixture tests of the Python client in this post, October 26, 2026 (first-party test)