# A real browser for AI agents and services

> Fractera AI Browser

A real browser on your server for machines: it opens pages and web applications the way a person does and returns what is actually on them.

Memory, other services and agents give it addresses and get back the final HTML after scripts, all the text, headings, links, buttons, forms, fields and media by attributes — for several pages in one call. YouTube videos come back with their data and subtitles with timestamps.

- Pages as a person sees them
- Nothing inside the machine is reachable
- Runs on your server

- [Read the API](https://ai-browser.aifa.dev/en/settings?section=api)
- [Open the passport](https://ai-browser.aifa.dev/en/passport)

## What it solves

An agent that reads the web with plain HTTP requests sees empty templates of script-drawn pages and meta tags instead of content. And a browser running next to your data is a risk of its own if a page can make it knock on the machine's internal doors.

The AI browser is a separate microservice with its own address, its own key and its own pages. It does one thing: opens what it is given with a real browser and returns the result in a form a program can use.

## How a request travels

One entry point, and every step between the caller and the page is a check.

1. **The caller.** A program sends addresses with its key, or a process of this machine with the machine secret.
2. **Address check.** Scheme and address are checked before a tab exists: only http and https, never the machine, loopback or a private network.
3. **A guarded tab.** Each address gets its own browser context and its own proxy. Cookies of one page never reach the next.
4. **Real browser.** Camoufox opens the page, waits for the document, the load event and network quiet — each wait with its own limit.
5. **The answer.** The final HTML, text, elements and media by attributes, and the list of what was refused.

## What comes back

A shallow look at elements and media by their attributes, and the whole text and code of the page.

- **Final HTML and text.** The full HTML after scripts have run, and all visible text — not the source the server sent.
- **Structure.** Title, lang, canonical, meta tags and headings h1–h6 with their levels.
- **Interactive elements.** Links, buttons, forms and fields with their names, labels, placeholders and options.
- **Media by attributes.** Images, video, audio and frames by their attributes: address, alt, poster, duration, title.

## Nothing inside the machine is reachable

The browser stands next to the data layer and other services. A page must not be able to use it as hands inside the machine.

- **Before the tab.** Scheme, literal IP and resolved name are checked before a tab opens: loopback, private networks, link-local and the machine's own addresses are refused.
- **Every request.** All browser traffic leaves through the service's own proxy for that address. It resolves names itself and connects only to the address it checked — redirects and WebSockets included.
- **No way around.** The browser engine is started so that even loopback goes through the proxy; by default Firefox would send it past.

## YouTube

The same browser, a method of its own: youtube returns the content of a video, not the page around it.

- **Video data.** Title, description, channel, duration, publish and upload dates, views, keywords — from the video page itself.
- **Subtitles with timestamps.** Taken from the request the player makes when subtitles are turned on, as lines [mm:ss–mm:ss] text. A language can be asked for.
- **What was obtained, and why.** No subtitles or the player gave none — the video's data with transcript: null and the reason in words.

## The read test bench

The service ships with a bench behind architect sign-in. It calls the same contract as any program — there is no second path into the browser.

- Paste addresses one per line and see exactly the answer a program receives.
- Open the final HTML, the visible text, headings, interactive elements and media lists.
- See what a page tried to reach inside the machine and was refused.

`/{lang}/settings?section=read-test`

## API quickstart

One REST API, one key. Two methods: read pages, read a YouTube video.

### Read an application that is drawn by scripts

```bash
curl -X POST https://ai-browser.your-domain.com/v1/read \
  -H "Content-Type: application/json" -H "x-ai-browser-key: YOUR_KEY" \
  -d '{ "urls": ["https://todomvc.com/examples/react/dist/"] }'
```

### Read several pages in one call

```bash
curl -X POST https://ai-browser.your-domain.com/v1/read \
  -H "Content-Type: application/json" -H "x-ai-browser-key: YOUR_KEY" \
  -d '{ "urls": [
    "https://developer.mozilla.org/en-US/docs/Web/HTML",
    "https://en.wikipedia.org/wiki/Web_browser",
    "https://example.com/"
  ] }'
```

### Read a YouTube video: data and subtitles with timestamps

```bash
curl -X POST https://ai-browser.your-domain.com/v1/youtube \
  -H "Content-Type: application/json" -H "x-ai-browser-key: YOUR_KEY" \
  -d '{ "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "lang": "en" }'
```

## Limits

Limits are stated in the answer itself, and anything cut is marked — a list of 300 links out of 2,000 carries total: 2000.

| What | Limit |
|---|---|
| Addresses per call | 10 |
| Tabs open at once | 3 |
| Time per address | 90 s |
| Final HTML per page | 5,000,000 characters |
| Visible text per page | 1,000,000 characters |
| Each list of elements | 300 items |

## Installation

There is exactly one thing to know about installing this.

One run of the Fractera installer robot on your own server brings up every microservice of the platform, the AI browser included — the browser engine, its libraries, nginx and the access key are arranged for you.

## Design principles

- **One path into the browser.** The bench, the API and every method open pages through one guarded tab. A second path into the browser would bypass the address ban.
- **Refusals are named.** Every refusal has a permanent code and a reason: url-forbidden, page-timeout, not-youtube, video-unavailable. A failed address never breaks the others in the same call.
- **Nothing is silent.** What is cut is marked, what did not load is said. load_reached: false means the page was returned without waiting for its load event.

## Questions and answers

Short answers to what people ask before they integrate.

### Why a real browser instead of a plain HTTP request?

Because many pages are drawn by scripts. A plain request to TodoMVC returns 645 characters of HTML; the browser returns 3,289 after the scripts have run — the list, the input field, the buttons. A plain request sees an empty template, the browser sees the page a person sees.

### Can a page I open reach inside my server?

No. Addresses of the machine itself, loopback, private networks and link-local ranges are refused before a tab opens, and again on every request the page makes — images, frames, fetch, redirects and WebSockets. All browser traffic leaves through the service's own proxy, which resolves each name itself and connects only to the address it checked. A probe on the server counts hits on a loopback listener: zero, including after a redirect to 127.0.0.1.

### What exactly comes back?

For every address: the final URL and status, the title, the full final HTML, all visible text, lang and canonical, meta tags, headings h1–h6, links, buttons, forms and fields with their labels, images, video, audio and frames by their attributes — each list with items and total. Plus what the page tried to reach and was refused, and whether the page reached its load event.

### What if a YouTube video has no subtitles?

You still get the video's data — title, description, channel, duration, dates, views — with transcript: null and a reason in words. Subtitles are taken from the request the player itself makes; when the player gives none, the answer says so instead of returning an empty success.

### How fast is it?

A light page opens in a few seconds; a heavy one with dozens of third-party resources takes 20–60 s. Up to 10 addresses per call, 3 open at once, 90 s per address. Measured on the reference server: three heavy pages in one call — about 95 s.

### Does it sign in to sites or get past bot protection?

No. The browser does not sign in to sites and does not solve bot checks. If a site shows a check page instead of its content, you get that page with its status code — measured: a Vercel security checkpoint came back as status 403 with its own title.

### Who calls it?

Memory calls it first, to keep pages and videos people send. Other services of the server and agents call it over the same contract with a key; processes of the same machine use the machine secret.

### Where does it run?

On your server. The browser, its cache and every page it opens stay on the machine; there is no third-party scraping service in the middle.

## The Fractera project on GitHub

Fractera AI Browser is one microservice of the Fractera platform, the engineering infrastructure for autonomous agents. The whole project, this service included, is open source.

- https://github.com/Fractera/Agentic-Engineering-Infrastructure

---

Source page: https://ai-browser.aifa.dev/en