---
title: "geoharness.toml reference · GeoHarness"
description: "Every geoharness.toml key GeoHarness accepts: type, whether it is required, the reason for each default, and how it is validated."
canonical: "https://geo.avarok.net/docs/config/"
tokens: 6229
---

# geoharness.toml reference

GeoHarness reads one file, `geoharness.toml`, from your site directory. Keys are camelCase, unknown keys are errors, and policy choices such as Content Signals are never defaulted.

Updated 2026-11-19 · Source: [docs/config.md](https://github.com/Avarok-Cybersecurity/geoharness/blob/main/docs/config.md)

## Which keys does geoharness.toml accept?

geoharness.toml keys

| Key                                | Type                                                | Required                           | Default (reason)                                                                                                               | Validation                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| ---------------------------------- | --------------------------------------------------- | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `site.origin`                      | string                                              | yes                                | —                                                                                                                              | `https://host[:port]`, no path, query or trailing slash                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `site.name`                        | string                                              | yes                                | —                                                                                                                              | non-empty, single line (it is the llms.txt H1)                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `site.language`                    | string                                              | yes                                | —                                                                                                                              | BCP 47 tag (`en`, `en-US`)                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `identity.kind`                    | `"person"` \| `"organization"`                      | yes                                | —                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `identity.name`                    | string                                              | yes                                | —                                                                                                                              | non-empty, single line                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `identity.url`                     | string                                              | yes                                | —                                                                                                                              | absolute http(s) URL                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `identity.sameAs`                  | string\[\]                                          | no                                 | `[]` (no profiles is a valid statement, not an assumption)                                                                     | absolute http(s) URLs; injected as `rel=me` and JSON-LD `sameAs`                                                                                                                                                                                                                                                                                                                                                                                                            |
| `identity.organization`            | table `{ name, url }`                               | no                                 | absent (a person need not belong to one)                                                                                       | both keys required when present                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `contentSignal.search`             | bool                                                | yes                                | — (a policy choice; never defaulted)                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `contentSignal.aiInput`            | bool                                                | yes                                | —                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `contentSignal.aiTrain`            | bool                                                | yes                                | —                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `bots`                             | array of tables                                     | yes                                | —                                                                                                                              | at least one; a token may appear in only one policy (case-insensitive)                                                                                                                                                                                                                                                                                                                                                                                                      |
| `bots[].tokens`                    | string\[\]                                          | yes                                | —                                                                                                                              | user-agent tokens, no whitespace or `:`; `*` allowed                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `bots[].group`                     | `"search"` \| `"user"` \| `"training"` \| `"other"` | yes                                | —                                                                                                                              | `search`/`user` tokens are checked by the audit's blocking robots check                                                                                                                                                                                                                                                                                                                                                                                                     |
| `bots[].allow`                     | string\[\]                                          | no                                 | `[]` (a group may be disallow-only)                                                                                            | each starts with `/` or `*`                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `bots[].disallow`                  | string\[\]                                          | no                                 | `[]` (a group may be allow-only)                                                                                               | each starts with `/` or `*`                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `content.mainSelector`             | string                                              | yes                                | —                                                                                                                              | valid CSS selector; when a page has no match its `<body>` is used with a `page.no_main` warning                                                                                                                                                                                                                                                                                                                                                                             |
| `content.exclude`                  | string\[\]                                          | no                                 | `[]` (excluding nothing changes nothing)                                                                                       | route globs starting with `/`                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `llms.summary`                     | string                                              | yes                                | —                                                                                                                              | single line (the llms.txt blockquote)                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `llms.sections`                    | array of tables                                     | yes                                | —                                                                                                                              | may be empty (`[]`) for an llms.txt with no sections                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `llms.sections[].title`            | string                                              | yes                                | —                                                                                                                              | single line (an H2)                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `llms.sections[].routes`           | string\[\]                                          | yes                                | —                                                                                                                              | route globs starting with `/`                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `env`                              | string\[\]                                          | no                                 | `[]` (no template may read the environment unless a name is declared)                                                          | `[A-Z_][A-Z0-9_]*`, unique                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `headers.immutable`                | string\[\]                                          | no                                 | `[]` (no asset is assumed to be content-hashed)                                                                                | Cloudflare `_headers` URL patterns starting with `/`                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `prerender`                        | table                                               | no                                 | absent (only sites built with a prerender adapter need it)                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `prerender.routes`                 | string\[\]                                          | yes, when `[prerender]` is present | —                                                                                                                              | literal absolute routes (no globs, query or fragment); read by the host's vite-prerender adapter, validated by the core                                                                                                                                                                                                                                                                                                                                                     |
| `analytics`                        | table                                               | no                                 | absent (most sites state no analytics; absent behaves as `cloudflareWebAnalytics = false`, which never loosens the site's CSP) |                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `analytics.cloudflareWebAnalytics` | bool                                                | yes, when `[analytics]` is present | — (a policy choice; never defaulted)                                                                                           | true: every `Content-Security-Policy` line of the site's `_headers` admits `https://static.cloudflareinsights.com` in `script-src` (and `script-src-elem` when set) and `'self'` plus `https://cloudflareinsights.com` in `connect-src`; a missing directive is created from its `default-src` fallback, so nothing else changes. Reported as the `headers.csp_extended` warning. false: the live audit fails (`index.live_beacon`) if Cloudflare injects the beacon anyway |

### Globs

`content.exclude` and `llms.sections[].routes` are matched against page routes: `*` matches within one path segment, `**` across segments, everything else is literal (`/blog/**`, `/docs/*/`).

`headers.immutable` entries are written verbatim as `_headers` URL patterns, so `*` there is Cloudflare's splat, which crosses `/`.

### Templates

Page HTML and adapter-supplied markdown may contain `{{geo.build_id}}`, `{{geo.lastmod}}` and `{{env.NAME}}` (whitespace inside the braces is allowed). `NAME` must be listed in `env`; reading an undeclared name is an error, never an empty string. Other `{{...}}` text is left untouched.

## Example

This site's own configuration, which GeoHarness uses to build what you are reading:

```
# GeoHarness builds, audits and deploys its own site with this file (see .github/workflows/deploy.yml).

[site]
origin = "https://geo.avarok.net"
name = "GeoHarness"
language = "en"

[identity]
kind = "organization"
name = "Avarok Cybersecurity"
url = "https://avarok.net"
sameAs = ["https://github.com/Avarok-Cybersecurity"]

# An open-source tool's documentation is meant to be found, quoted and learned:
# search, answers and training all help people use it correctly.
[contentSignal]
search = true
aiInput = true
aiTrain = true

[[bots]]
group = "search"
tokens = ["Googlebot", "Bingbot", "OAI-SearchBot", "Claude-SearchBot", "PerplexityBot"]
allow = ["/"]

[[bots]]
group = "user"
tokens = ["ChatGPT-User", "Claude-User", "Perplexity-User"]
allow = ["/"]

[[bots]]
group = "training"
tokens = ["GPTBot", "ClaudeBot", "Google-Extended", "Applebot-Extended", "CCBot"]
allow = ["/"]

[[bots]]
group = "other"
tokens = ["*"]
allow = ["/"]

[content]
mainSelector = "main"

# Cloudflare injects the Web Analytics beacon on avarok.net; admit it in the CSP instead of failing on it.
[analytics]
cloudflareWebAnalytics = true

[llms]
summary = "GeoHarness is a GitHub Action that builds any website, serves markdown twins to AI agents for free on Cloudflare, gates on a GEO score and Lighthouse 100, deploys and verifies the live site."

[[llms.sections]]
title = "Docs"
routes = ["/docs/**"]

[[llms.sections]]
title = "Project"
routes = ["/", "/citations/"]
```

```json
{
  "@context": "https://schema.org",
  "@type": "WebPage",
  "author": {
    "@type": "Organization",
    "name": "Avarok Cybersecurity",
    "sameAs": [
      "https://github.com/Avarok-Cybersecurity"
    ],
    "url": "https://avarok.net"
  },
  "description": "Every geoharness.toml key GeoHarness accepts: type, whether it is required, the reason for each default, and how it is validated.",
  "inLanguage": "en",
  "isPartOf": {
    "@type": "WebSite",
    "name": "GeoHarness",
    "url": "https://geo.avarok.net/"
  },
  "name": "geoharness.toml reference · GeoHarness",
  "url": "https://geo.avarok.net/docs/config/"
}
```
