# [LLM visibility: make your pages cheap to read](https://rebilder.com/solutions/llm-visibility)

> LLM visibility is a token-budget problem before it is a content problem. What a model receives from your site, and how to cut it by an order of magnitude.

- **Updated:** 2026-08-17

A language model reading your page is spending context on every byte you send, including the nav, the cookie banner and the footer. LLM visibility is mostly the work of not making it pay for those.



## What you get

- See the exact bytes and tokens a model receives from any URL
- Cut a page to its facts without changing what browsers get
- Serve `text/markdown` from two lines of middleware
- Keep the whole thing self-hostable, with no telemetry

## Visibility is a budget problem first

A model retrieving your URL does not render it. It receives bytes and converts them to tokens, and its context window is finite and shared with the user’s conversation, the system prompt and every other source it pulled. Your page is competing for room, and markup is what loses you the argument.

This is why the fix is structural rather than editorial. Rewriting your copy does not change the ratio of chrome to substance; changing what you serve does. On the reference captures, a services page went from 13,581 bytes to 1,412 and a product page from 91,226 to 1,315, with identical facts in both cases.

> **Check yours in one command** Compare `curl -s https://your-site/page | wc -c` against `curl -s -H 'Accept: text/markdown' https://your-site/page | wc -c`. If the second number is not dramatically smaller, the second request is not being answered at all.

## Where the first fact sits matters as much as the total

Total size decides whether you are read. Position decides whether the useful part survives truncation and summarisation. Both reference captures moved the first substantive fact from deep in the document to the opening lines: character 23,185 to line 4 on the product page, character 10,152 to line 8 on the services page.

- **Find your own offset.** For each template, search the raw HTML for the first fact a person would actually ask about: a price, opening hours, a fee, an eligibility rule.
- **Count what is above it.** Everything before that offset is what a model pays to reach you.
- **Cut, do not rewrite.** The facts stay identical. What changes is how much of your theme travels with them.

## The serving layer, in two lines

Content negotiation is the whole mechanism. A request that asks for markdown gets markdown built from your own stored values; everything else is untouched. Nothing is generated, nothing is estimated, and no model runs at request time.

middleware.ts

```ts
import { gateway } from '@rebilder/gateway'

export default gateway({
  source: { kind: 'document', resolve: myPages },
})
```

The SDK has no concept of a plan or a quota and never will, so nothing about your traffic shape changes what the edge does. If you would rather not depend on us at all, it runs on your own infrastructure unchanged.

## What this does not do

- It cannot make an assistant mention you. Assistants are not deterministic and no vendor controls their output, so a guaranteed citation is not a thing anyone can sell.
- It does not change what Google sees. Content negotiation returns the same substance in another format, and search crawlers keep receiving canonical HTML.
- It does not rewrite your content. The gateway prints values you already store; if a fact is missing from your source of truth, it stays missing.
- It does not run a model at request time. Page substance is never generated, which is a hard architectural rule rather than a current limitation.

## What is LLM visibility?

Whether a language model can retrieve your pages and afford to read them. It has two measurable parts: is the fetch answered with parseable text, and how many tokens does the useful content cost once it arrives.

## How many tokens does my page cost an LLM?

Roughly bytes divided by four for English prose, but the ratio is worse for markup-heavy HTML because tags tokenize badly. The reliable way is to fetch the page as the agent does and measure what comes back rather than estimating from the rendered view.

## Does serving markdown to models affect my site for humans?

No. The negotiation is per request: browsers get your normal pages, and only clients that ask for markdown receive it. Nothing about your theme, your analytics or your checkout changes.

## Can I do this without a third-party service?

Yes. The gateway SDK is open, free, unmetered and self-hostable, and the command-line scanner ships zero telemetry: it never uploads a scan, a URL or a hostname. Running the whole thing on your own infrastructure is a supported path, not a loophole.

## Related

- [AI visibility: the half you control](https://rebilder.com/solutions/ai-visibility)
- [LLM SEO: what transfers from SEO](https://rebilder.com/learn/llm-seo)
- [LLM optimization](https://rebilder.com/solutions/llm-optimization)
- [LLM brand visibility](https://rebilder.com/solutions/llm-brand-visibility)
- [Gateway quickstart](https://rebilder.com/docs/quickstart)