Really Simple Licensing (RSL) — researched

Really Simple Licensing (RSL) is an open XML standard (launched 2025-09-10, RSL 1.0 Recommendation 2025-12-10, governed by the RSL Technical Steering Committee and the RSL Collective) for expressing machine-readable licensing, payment, and legal terms for digital content, discovered chiefly through a new robots.txt License: directive and composing with — not replacing — robots.txt, llms.txt, ai.txt, IETF AIPREF, Cloudflare Content Signals, W3C TDMRep, and C2PA/CAWG. Drawn from 4 sources covering the specification itself, deployment/tooling/anti-patterns, the standards landscape, and measured adoption/legal weight, this pack shows RSL as a well-engineered declaration layer with thin real-world uptake: direct measurement found roughly 3 independent publisher deployments (of which most are non-conformant with the spec's own rules), no AI company has agreed to honor it, and its legal force stands on notice/evidentiary value and an EU DSM Art. 4(3) reservation rather than technical enforcement.

Definitions

**RSS** is a first-class integration and the standard's namesake lineage: declare `xmlns:rsl` on `<rss>`, then add `<rsl:content>` inside each `<item>`. The `url` **MUST identify an asset governed by the same origin that publishes the feed** — a same-origin authority rule that stops a feed from licensing someone else's content[^1]. [source]
An RSL license is an **XML document**, not a text file. Three nesting levels carry the whole model[^1]: [source]
**This is the concept to read before advising anyone to adopt RSL.** The headline number and the deployed number differ by roughly three orders of magnitude, and press coverage routinely conflates them. [source]
This file is the **specification reference**: what RSL is, who governs it, and what the standard actually defines. For deploying it see the deployment file; for how it compares to neighbouring conventions see the standards file; for whether it works in practice see the adoption file. [source]
This file is the **evidence reference**, and the one to read before advising anyone to adopt RSL. Endorsement and deployment differ here by roughly three orders of magnitude, and press coverage routinely conflates them. [source]

Structure and components

[^1]: RSL 1.0 Specification (`RSL-SPEC-1.0`, Industry Specification, status Recommendation, published 2025-12-10; incl. §2.2 media type, §3 document model, §3.4.1 vocabularies, §3.7 payment, §3.12 reporting, §3.13 legal, §4 association, §4.4 robots.txt, §4.9 precedence, §5 OLP, §6 CAP, §7 EMS, §10 IANA, §11 acknowledgments, Appendix A Relax NG, errata log). https://rslstandard.org/rsl · errata: https://rslstandard.org/rsl/errata [^8]: RSL and AI Preferences — RSL's own stated relationship to IETF AIPREF. https://rslstandard.org/guide/ai-preferences [^30]: IETF AIPREF vocabulary — `draft-ietf-a [source]
[^1]: RSL 1.0 Specification (`RSL-SPEC-1.0`, Industry Specification, status Recommendation, published 2025-12-10; incl. §2.2 media type, §3 document model, §3.4.1 vocabularies, §3.7 payment, §3.12 reporting, §3.13 legal, §4 association, §4.4 robots.txt, §4.9 precedence, §5 OLP, §6 CAP, §7 EMS, §10 IANA, §11 acknowledgments, Appendix A Relax NG, errata log). https://rslstandard.org/rsl · errata: https://rslstandard.org/rsl/errata [^4]: RSL 1.0 announcement, 2025-12-10 — v1.0 publication, the "1,500+ media organizations" figure, Cloudflare/Akamai/Creative Commons/IAB Tech Lab endorsements. https [source]
**Settled (EU): machine-readable reservations do have statutory force.** DSM Directive (EU) 2019/790 **Art. 4(3)** lets rightsholders expressly reserve TDM rights "in an appropriate manner, such as machine-readable means," disapplying the general TDM exception[^43]. This is the one jurisdiction where an RSL file plausibly does legal work standing alone — which is why Cloudflare's Content Signals template embeds explicit Art. 4 reservation boilerplate[^35]. EU AI Act Art. 53(1)(c) additionally obliges GPAI providers to operate a copyright policy respecting such reservations. **For the EU statut [source]
| Layer | Question | Occupants | |---|---|---| | Discovery / curation | What should I read? | **llms.txt**, `sitemap.xml` | | Access | May I fetch it? | **robots.txt / RFC 9309** | | Usage preference | What class of use is allowed? | **IETF AIPREF**, **Cloudflare Content Signals**, TDMRep `tdm-reservation`, CAWG/C2PA TDM assertion, **ai.txt**, CC Signals | | **Licensing / consideration** | **On what terms, at what price, to whom, where?** | **RSL**, TDMRep `tdm-policy` (ODRL) | | Enforcement / settlement | How is it compelled and paid? | Cloudflare pay-per-crawl, RSL CAP/OLP (optional), x402 | [source]
1. **"It's `robots.txt` with extra steps, and `robots.txt` already lost."** The most-repeated critique: RSL inherits voluntary compliance while adding expressiveness that changes nothing about enforcement[^45][^22][^23]. One framing calls it an inherited original sin — "as expressiveness grew, so did the visible distance between the rights you can declare and the rights you can compel." 2. **Peer-operator skepticism, on the record.** Cloudflare CEO Matthew Prince, to Tech Brew (2025-09-22): *"It feels, unfortunately, a little bit more like an organization that's good at press releases and not [source]
Critical to state plainly: **these three protocols are OPTIONAL.** The spec's required foundation is only the XML vocabulary plus the Section 4 discovery mechanisms; implementers MAY adopt RSL purely as a declarative licensing and discovery format and keep their own payment infrastructure[^1]. Most real deployments today stop at the declaration layer. [source]
- **AIPREF's vocabulary is now two categories, not four.** As of `draft-ietf-aipref-vocab-07` (2026-08-19) the vocabulary is exactly `train-ai` (AI Model Training) and `search`[^30]. `draft-03` (2025-09-05) had four — `bots`, `train-ai`, `train-genai`, `search` — in a nesting hierarchy; by `-07` the hierarchy is gone, `bots` and `train-genai` are deleted, and `train-ai` is *redefined* to carry the generative meaning ("modify the learned parameters of an AI model that is used to generate synthetic content")[^30]. Any RSL↔AIPREF mapping written against the four-token vocabulary is stale. - **AIP [source]
| Rule | Detail | |---|---| | Namespace | `https://rslstandard.org/rsl` MUST be the **default** namespace on `<rsl>`, and SHOULD NOT use a prefix — except when embedded in a non-RSL container (RSS, EPUB), where every element MUST be `rsl:`-prefixed | | Media type | `application/rsl+xml` — MUST be used when served over HTTP | | XML | MUST conform to XML 1.0 | | Structure | `<rsl>` contains one or more `<content>`; each `<content>` MUST have a `url` attribute and at least one `<license>` | | Unknown elements | An unrecognized element **in the RSL namespace** makes the document non-conformant. El [source]
- **`License:` is an unregistered extension, and that is legitimate.** RFC 9309 §2.2.4 explicitly permits it: crawlers "MAY interpret other records that are not part of the robots.txt protocol — for example, `Sitemaps`," provided parsing does not interfere with defined records[^32]. `License:` sits in the same tolerated-extension class as `Sitemap:`. - **There is no REP field registry to register into.** RFC 9309 §4 states the document "has no IANA actions"[^32]. RSL §10.3's table registering the `License` directive therefore registers it *nowhere*[^1]. - **RSL's claim to "normatively extend" [source]
Membership is **free, non-exclusive, and terminable at will** — members may pursue bilateral deals independently[^10][^13][^14]. There is **no published take rate**: the stated intent is an ASCAP-style percentage of flow-through royalties with minimum thresholds, with an economist hired to design it[^14]. As of the latest reporting located, the Collective's published Terms of Service governs only the website and dashboard and contains **no member licensing agreement, no royalty split, no take rate, and no governance provisions** — despite a Nov 2025 commitment to publish the licensing agreemen [source]
5. **Expecting `License:` to restrict crawling.** It explicitly does not modify `Allow`/`Disallow`[^1]. Publishing `License:` with `Disallow:` empty still permits full crawling — you have priced content you are also giving away unconditionally. → Keep the access layer (`Disallow`, AI-bot tokens) and the licensing layer coherent; decide them together. [source]
One genuine composition point: all three usage-layer conventions resolve conflicts to **most restrictive** — AIPREF §5.1, RSL §4.9, and Cloudflare's "silence neither grants nor restricts"[^1][^30][^35]. [source]
This is the layer that makes RSL different in kind from `robots.txt`: a controlled vocabulary for *what an AI may do*, not merely *what it may fetch*. [source]
RSL's official quickstart is three steps[^6], and the declaration layer genuinely is that small: [source]
The field only makes sense as a **five-layer stack**. Most apparent rivalry dissolves once the layers are separated, and RSL occupies a layer that was genuinely under-served: [source]
6. **Mixing global and group-scoped `License:` directives carelessly.** If the client's selected `User-agent` group contains *any* `License` directive, it MUST **ignore all global ones**[^1]. Adding a per-bot license silently voids your site-wide default for that bot. → Repeat the default inside each group that needs it. [source]

How it works

| Mechanism | Where | Shape | |---|---|---| | `robots.txt` directive | `/robots.txt` | `License: https://example.com/license.xml` | | HTTP `Link` header | any response | `Link: <…>; rel="license"; type="application/rsl+xml"` | | HTML `<link>` | `<head>` (or any element) | `rel="license" type="application/rsl+xml"` | | HTML `<script>` | any element | `type="application/rsl+xml"`, full RSL doc inline | | RSS module | `<item>` | `<rsl:content>` with `xmlns:rsl` on `<rss>` | | Media/data file | file metadata | XMP, ID3, EPUB `<metadata>`, PNG `iTXt` | [source]
**Really Simple Licensing (RSL)** is an open, XML-based standard for expressing **machine-readable licensing, payment, and legal terms** for digital assets, so that AI crawlers and agents can discover what a publisher's content costs and on what conditions it may be used[^1]. It was launched **2025-09-10**[^10] and published as the **RSL 1.0 Recommendation on 2025-12-10** (document `RSL-SPEC-1.0`, superseding a 0.9 draft)[^1][^4]. [source]
**Bottom line on legal force.** Standing alone, in the US, an RSL file has **no demonstrated legal force**. Its plausible value is threefold: (i) **evidentiary** — dated proof the operator communicated terms; (ii) an **Art. 4(3) reservation in the EU**; (iii) a **predicate to a contract claim only if assent is separately obtained** (the hiQ pattern). Where RSL is paired with a real technical gate — CDN enforcement, EMS encryption, 401/402 responses — the posture changes materially, because then you may have an actual technological measure, which is precisely what *Ziff Davis* held `robots.txt` [source]
**This is the most directly damaging authority for RSL**, because RSL's primary discovery channel *is* `robots.txt` and the spec itself concedes RSL is not a technical access control[^1]. The irony is sharp: **Ziff Davis is an RSL launch supporter and a v1.0 spec editor's employer, it was the plaintiff who lost this claim, and `ziffdavis.com` serves no `License:` directive**[^20][^40]. [source]
**Settled: but a site's terms CAN bind a scraper that actually assented.** *hiQ Labs v. LinkedIn* is routinely miscited as "scraping public data is legal." The full outcome: hiQ won on the CFAA claim, then **lost on breach of contract** at summary judgment (N.D. Cal., 2022-11-04) because it had created an account and expressly accepted the User Agreement; a consent judgment of **$500,000** followed[^42]. The operative lesson: **the contract theory that actually won required affirmative assent — which delivery via `robots.txt` does not obtain.** [source]
`url=""` (empty) is legal **only** where an association mechanism defines the scope itself (HTML `<link>`/`<script>`, RSS) — it then means "whatever this association covers," letting one license document be reused across many pages[^1]. [source]
**Contested:** - Whether `robots.txt`/RSL can form a binding unilateral contract at all — genuinely open; a survey of US case law found only ~17 cases ever mentioning robots.txt[^40]. - What counts as "machine-readable" under Art. 4(3) — no agreed technical standard; commentators note case-by-case interpretation "is incompatible with the scale of TDM and eliminates legal certainty"[^43]. - Whether declaring terms in `robots.txt` is even net-positive. A notable perverse-incentive argument: crawler operators "are now better off if they never download the robots.txt file, because then you know fo [source]
| Type | Trigger for payment | |---|---| | `purchase` | One-time | | `subscription` | Recurring access | | `training` | Each time content is used for AI training | | `crawl` | Each time content is crawled | | `use` | Each time content contributes to an AI-generated output (inference, grounding, generation) | | `contribution` | Good-faith monetary or in-kind support | | `attribution` | No money; visible credit plus a functional link required | | `free` | Nothing required | [source]
There is **no public record of TSC deliberation, no published membership process, and no voting or consensus procedure.** RSL is "open" in the sense of publicly readable and royalty-free to implement; it is **not** open in the sense of forkable or community-governed. Say it that way. [source]
The honest framing: **RSL did not invent machine-readable licensing — it is the first to put a number and a currency in the file.** TDMRep is also a different legal theory: a rights *reservation* (the DSM Art. 4 opt-out trigger), where RSL is a standing *offer*. [source]
- The large AI copyright settlements and the ~40 pending AI lawsuits are **ordinary copyright actions with no RSL nexus** — context for why RSL exists, not evidence that it works. - **Cloudflare Pay Per Crawl transactions are not RSL transactions.** Real money moves through Cloudflare's proprietary HTTP-402 mechanism, not through RSL[^25]. [source]
Likewise, RSL's requested IANA registrations are **requests, not registrations**: `application/rsl+xml` does not appear in the IANA media-types registry as of 2026-09-02[^38]. Serve the media type because the spec requires it, but do not describe it as IANA-registered. [source]
**Is there a standards-body turf conflict?** Yes — a scope conflict, not a hostile one, and asymmetric. RSL self-declares `Category: Industry Specification` / `Status: Recommendation` with a self-hosted permanent namespace and self-declared versioning policy[^1]. There is no open participation process, no appeals mechanism, no IPR-disclosure regime, and no external consensus check comparable to IETF rough consensus or W3C horizontal review. No formal IETF or W3C objection to RSL exists; the relationship is best described as **polite non-adoption** — the IETF declines licensing/payment as out o [source]
- **`<standard>`** — URL of a *shared* licensing framework (Creative Commons, a collective, a platform's pay-per-crawl policy). Clients MUST treat it as an **opaque identifier** for matching, though it SHOULD dereference to human-readable terms. This is how many publishers reference one collective license. - **`<custom>`** — URL of a publisher-specific licensing process (contact form, license-request page). - **`<amount currency="…">`** — explicit price; `currency` is **required**, ISO 4217. - **`<accepts type="…">`** — payment protocol, keyed by media type. The spec names **x402** (`applicati [source]
> Do **not** repeat the widely-shared claim that "Cloudflare adopted RSL." Cloudflare operates a competing settlement mechanism; the accurate statement is that a Cloudflare product lead is acknowledged in the spec and the vocabularies overlap. [source]

Examples and snippets

- **Medium** — the model deployment, and a clean illustration of the *two-`<license>`* pattern: one license permits `ai-input ai-index search` under `attribution`; a second prohibits `ai-train` and routes training requests to a support form under `payment type="subscription"`. Verified 2026-09-02. - **The Guardian** — **self-defeating.** The same `<license>` block contains both `<permits type="usage">ai-train ai-input</permits>` and `<prohibits type="usage">all</prohibits>`. Per spec §3.6, prohibitions take precedence over permits for the same `type`[^1] — so `prohibits all` wins and the adver [source] — Worked examples of live RSL deployments (Medium/Guardian/Stack Overflow); Guardian block is a genuine self-contradiction (permits ai-train ai-input beside prohibits all, prohibits wins per spec conflict rule) — kept as a documented anti-pattern, not merged.

Measurements and reference values

**No crawl-scale measurement of RSL deployment exists** as of 2026-09-02. HTTP Archive, Common Crawl, Cloudflare Radar and the academic literature were checked; two candidate 2026 studies (an SSRN AI-readiness survey, n=766, which measures robots.txt AI permissions, llms.txt at ~25%, and schema.org; and an AI-discovery-file adoption study, n=1,905, tracking ten discovery files) **do not measure RSL or the `License:` directive at all**[^29]. The contrast with `llms.txt` is instructive: llms.txt has multiple independent adoption series (see `llms-txt-ecosystem-evidence.md`); RSL has none. [source]
**Direct measurement (primary evidence, 2026-09-02).** A scan of **130 domains**, deliberately enriched with RSL founding supporters and announced v1.0 endorsers, found **5 `License:` directives — 2 of them RSL's own properties, leaving 3 independent publishers (~2.4%)**[^20]. Because the sample was enriched toward supporters, this is a **ceiling, not an estimate**; a representative web-wide sample would score far lower. [source]
**The "1,500+ organizations" figure is one evidentiary point, and it counts endorsement.** It originates in the RSL Collective's own 2025-12-10 release and is redistributed by wire[^4]. The Collective itself was reported at "over 50 partners" in Nov 2025[^14] — the ~30× gap is the difference between signing a supporter form and joining the licensing body. Any "RSL has N backers" claim is ambiguous unless the source says which list it means. [source]

Problems, failure modes and limitations

| Artifact | Finding | Verdict | |---|---|---| | `rslstandard.org/robots.txt` | Prose notice "strictly prohibited… for AI training", then `User-agent: *` / `Disallow:` — **an empty `Disallow` means allow everything**[^2] | Ships the exact contradiction of Anti-Pattern 5 | | `rslcollective.org/royalty.xml` | Served as `application/xml`, not `application/rsl+xml`[^49] | **The canonical collective licence violates the spec's own MUST**[^1] | | `medium.com/license.xml` | Served as **`text/html; charset=utf-8`**[^49] | Non-conformant media type | | `theguardian.com/license.xml` | Served as `applica [source]
- **Pay-per-crawl is tractable**: a crawl is one observable HTTP event at the network boundary; a CDN can gate or bill it. - **Pay-per-inference (`payment type="use"`) is an open research problem.** It requires attributing a given model output to specific training documents. The state of the art (influence functions, TracIn, Data Shapley) fails at production scale on three axes: **cost** (accurate influence functions approach pretraining-scale compute), **approximation error** too large to bill on, and **instability** once RLHF and multi-stage training blur the contribution signal. RSL's headl [source]
The Resource Server validates locally or via `/introspect`, and returns `401 Unauthorized` or `402 Payment Required` with a `Link: …; rel="license"` header otherwise. The spec is candid about CAP's limit: it verifies *license compliance*, not *identity*, and SHOULD be paired with bot management or **Web Bot Auth** (`draft-meunier-web-bot-auth-architecture`) for network-layer identity — spoofed user agents are exactly the problem CAP alone does not solve[^1]. [source]
**Antitrust is a named, unresolved risk.** Outside counsel flagged at launch that RSL "may also raise other potential legal issues, such as the enforceability of RSL licensing agreements and **antitrust risks from collective licensing**"[^18]. This is the structural cost of the ASCAP analogy: ASCAP and BMI operate under **DOJ antitrust consent decrees**; a new horizontal rate-setting body among competing publishers has no equivalent framework. QUALIFIED — flagged by counsel, no filed action or investigation located. [source]
**The RSS provenance claim checks out, with a caveat worth carrying.** Walther genuinely co-created RSS — specifically **RSS 0.90 (RDF Site Summary), at Netscape in March 1999, with Dan Libby and R.V. Guha**[^13]. The caveat: the *widely adopted* format is RSS 2.0, the UserLand/Winer lineage that Walther was not part of; Netscape abandoned RSS in 2001. RSL's own normative reference is to RSS 2.0, not 0.90[^1]. So "built by the co-creator of RSS" is accurate but elides a fork. Notably **two of the three original Netscape RSS authors** — Walther and Guha — are on the RSL TSC[^11]. [source]
**The concrete fragmentation risk** is the `robots.txt` file itself. Four conventions now want lines in it: REP's `Allow`/`Disallow`, AIPREF's `Content-Usage:`, Cloudflare's `Content-Signal:`, and RSL's `License:`. A publisher can emit all four without syntactic conflict (RFC 9309 §2.2.4 guarantees that), but **there is no defined precedence *between* the three usage-layer vocabularies** — only within each — and no body currently owns resolving it (QUALIFIED — inferred from the three specs; no cross-precedence document located)[^31][^32][^35]. [source]
**HTML association scope** is *element*-scoped, not merely document-scoped: a `<link>` or `<script>` applies to its parent element and that element's descendants; in `<head>` it therefore covers the document. This enables per-`<section>` licensing of syndicated content — an inline `<script type="application/rsl+xml">` on a syndicated article carries a `url` pointing at the syndicator's canonical URL so the license travels with the copy[^1]. Caveat the spec itself flags: `<link rel="license">` outside `<head>` is **not conforming HTML** — use the inline `<script>` form for element-scoped licens [source]
2. **`License:` line pointing at a 404.** The most common deployment failure, because `robots.txt` has no validation and nothing warns you. Per spec, a client that cannot retrieve a valid RSL document MUST treat the asset as **unlicensed**[^1] — so a broken link is strictly worse than no line at all: you have advertised terms and delivered none. → `curl -sSI` the license URL in CI. [source]
**`<reporting>`** — obligations independent of payment. `type` is `telemetry` | `provenance` | `audit`; `profile` (required) is an opaque URI naming the reporting protocol; `endpoint` is optional. The teeth: **a client that does not recognize or cannot comply with the profile MUST treat the activity as not licensed**[^1]. [source]
The `search` / `ai-input` split is the commercially load-bearing distinction — it is precisely the "index me but don't answer *instead* of me" position publishers wanted and `robots.txt` cannot express. [source]
The consequential default: **a client that cannot obtain a valid RSL document for an asset MUST treat the asset as unlicensed**[^1]. RSL does not silently fall back to "permitted." [source]

Comparisons and alternatives

| # | Section | Read it for | |---|---|---| | — | Overview | What RSL is in one screen; how it differs from llms.txt and ai.txt | | 1 | Provenance, governance, and the RSL Collective | Who built it, the RSS lineage, the TSC, ASCAP-style collective licensing, the CC BY-ND spec licence, the antitrust question, 0.9 → 1.0 | | 2 | The RSL document model | `<rsl>`/`<content>`/`<license>`, hard invariants, `max-age` revalidation, most-restrictive conflict resolution | | 3 | The licensing vocabularies | `ai-train` / `ai-input` / `ai-index` / `search` / `ai-all`, user classes, geo scoping | | 4 | Payme [source]
**Adjacent standards** [^35]: Cloudflare Content Signals Policy (launched 2025-09-24; `search=`, `ai-input=`, `ai-train=`; CC0; embedded DSM Art. 4 reservation boilerplate). https://blog.cloudflare.com/content-signals-policy/ [^36]: Cloudflare pay-per-crawl — HTTP 402, `crawler-price` headers, Web Bot Auth. https://blog.cloudflare.com/introducing-pay-per-crawl/ [^40]: *Ziff Davis v. OpenAI*, 2025 WL 3635559 (S.D.N.Y. 2025-12-15) — robots.txt directives "do not 'effectively control' access… any more than a sign requesting that visitors 'keep off the grass' effectively controls access to a lawn" [source]
| Symptom | Likely cause | Check / fix | |---|---|---| | Crawlers ignore the license entirely | No major AI vendor has committed to honouring RSL (Concept 8) | Expected. RSL's near-term value is evidentiary/notice, not technical | | Validator rejects the document | Unknown element **in the RSL namespace** → non-conformant; elements in *other* namespaces should be ignored instead[^1] | Check for typos in element names; confirm `xmlns` is exactly `https://rslstandard.org/rsl` | | License seems not to apply to a page | Wrong scope. Outside HTML/RSS/embedded use, `<content url>` MUST be an RFC 930 [source]
**vs. Cloudflare — complementary at declaration, competing at settlement.** Content Signals Policy (`search=`, `ai-input=`, `ai-train=` in robots.txt, released CC0, launched 2025-09-24, auto-served on millions of managed-`robots.txt` domains) is vocabulary-only and its three tokens are near-identical to RSL's — the RSL spec itself says its usage category *includes* the Content Signals vocabulary[^1][^35]. Cloudflare's Will Allen is credited in RSL's acknowledgments[^1]. But **pay-per-crawl** (HTTP 402 + `crawler-price` headers + Web Bot Auth signatures, private beta since 2025-07-01) does not [source]
**EMS (Encrypted Media Standard)** — `encrypted="true"` on `<content>` (which then requires `server`); the client must obtain both a license and a key via `/key`. Cipher and rotation policy are implementation-defined; only the JWK structure and symmetric `kty="oct"` are mandated[^1]. This is the only part of RSL that is a genuine technical access control rather than a declaration. [source]
**vs. C2PA / CAWG — orthogonal, and commonly mis-cited.** C2PA has published a formal clarification that its Content Credentials technical specification contains **no standard TDM assertion and no DRM assertion**; the training controls live in the separate **CAWG Training and Data Mining Assertion** (`cawg.ai_training`, `cawg.ai_generative_training`, `cawg.data_mining`; values `allowed`/`notAllowed`/`constrained`) carried inside a C2PA manifest[^39]. Different axis entirely: C2PA answers *where did this come from and is it intact*; RSL answers *on what terms may I use it*. They compose — and C [source]
`<rsl>` takes one optional attribute, `max-age` — a **positive integer number of days** (not seconds, unlike HTTP `Cache-Control`) during which a client may treat the document as authoritative. **Default when absent: 30 days.** Revalidation duty extends to the *discovery mechanism* as well as the document: if the `robots.txt` `License:` line now points somewhere else, the client MUST re-fetch and re-evaluate[^1]. [source]
**vs. TDMRep — the closest true analogue, and it came first.** The W3C TDM Reservation Protocol Community Group's Final Report (2026-07-16) already does declaration → policy → terms: `tdm-reservation: 0|1` plus `tdm-policy: <URL>` pointing at an **ODRL 2.2** profile expressing `tdm:mine` permission with duties `obtainConsent` and `compensate`[^37]. It carries via `/.well-known/tdmrep.json`, HTTP headers, HTML `<meta>`, EPUB, and PDF XMP. What it lacks versus RSL: **no price amount, no currency, no payment type, no per-use-category granularity, no auth/token protocol**[^37]. [source]
**No IETF or W3C standardization path exists.** RSL self-designates "Recommendation" — nomenclature that mirrors W3C's terminal maturity level but carries no W3C standing[^1]. RSL *cites* IETF and W3C work (RFCs 2119/3339/3986/6749/6750/7517/9110/9309, ODRL 2.2, IPTC RightsML) and names IETF AIPREF as a possible future vocabulary source, but has not been submitted to any standards body[^1]. Headlines calling v1.0 an "official industry standard" are reporting a self-declaration. Leeds's own theory is explicitly de-facto rather than de-jure — the `robots.txt` precedent, "never legislated... but [source]
**vs. Creative Commons CC Signals** — announced 2025-06-25, a reciprocity norm rather than a price; CC states signals "may range in enforceability, legally binding in some cases and normative in others." CC's Timid Robot Zehta is credited in both the RSL 1.0 acknowledgments and the AIPREF vocab acknowledgments[^1]. [source]
**vs. llms.txt and ai.txt — see `llms-txt.md` and `ai-txt.md` in this hub.** The boundary confirmed against the llms.txt v2 spec: **llms.txt contains no licensing vocabulary whatsoever** — its grammar has four element types, none permission-bearing — and it explicitly states its expected use is *inference, not training*. It is the LLM-era analogue of `sitemap.xml` + `index.html`, not of `robots.txt`. A single HTTP response can legitimately carry both, on different link relations that never collide: [source]
Reddit is the instructive case — an RSL founding supporter that instead pursued **bilateral deals** (Google, OpenAI) and serves a blanket `Disallow: /`, collecting revenue by contract rather than by standard[^21]. [source]
Concepts 7–9 live in the sibling files: **7** the standards landscape → `rsl-vs-adjacent-standards.md`; **8** adoption reality and **9** legal weight → `rsl-adoption-and-legal-weight.md`. Deployment, tooling, anti-patterns and troubleshooting → `rsl-deployment-and-anti-patterns.md`. [source]
RSL's own framing is complementary rather than competitive: AIPREF "does not define a mechanism for obtaining permission or compensating publishers," which RSL adds[^8]. That is accurate. But note AIPREF §4.3 requires vocabulary extensions to be defined in "a standards-track RFC that updates this document" — so RSL tokens can never become AIPREF terms by RSL's fiat. The legitimate compositional route is AIPREF's "alternative formats" clause, which permits an external system to define a bidirectional mapping to the AIPREF data model. **RSL has not published such a mapping** (QUALIFIED — inferre [source]
Confidence notes, stated honestly: - **Nonprofit status: QUALIFIED.** Consistently asserted by RSL and repeated by reporters; not independently verified against any government filing (a ProPublica Nonprofit Explorer search returned no organization record — weak disconfirming evidence, since a 2025-founded entity might only file a 990-N, which that dataset excludes)[^11]. No source states the tax classification (501(c)(3) vs 501(c)(6)). - **Corroborating operational detail:** "Because it's a nonprofit, no one working for RSL is getting paid yet"[^14]. [source]
`<payment>` is what makes RSL a *licensing* standard rather than a permissions one. **If `<payment>` is omitted the license is `free`**[^1]. [source]
**vs. `robots.txt` / RFC 9309 — composes.** (Full REP reference: `robots-txt.md`; the Cloudflare `Content-Signal:` extension: `robots-txt-content-signals.md`.) RSL rides on REP rather than replacing it. Three precise points matter: [source]
**vs. `<link rel="license">` / HTTP `Link:`** — not a competitor: the `license` link relation is IANA-registered and RSL simply *uses* it, narrowed by `type="application/rsl+xml"`[^1]. [source]
**The gap worth naming:** RSL's own quickstart names no CMS plugin, no generator, and no CLI[^6]. Against a claim of 1500+ endorsing organizations[^4], a 46-star spec repo with one fork[^5] is the clearest available measure of how much *engineering* (as opposed to *endorsement*) the standard has attracted. Treat "supports RSL" in a press release as a signed statement of intent, not as deployed code. [source]
**vs. IETF AIPREF — the comparison that decides RSL's long-term standing.** AIPREF is the actual standards-track effort in this space, and the boundary has been ruled on explicitly. [source]
**vs. schema.org** — descriptive metadata with no AI-use categories or price; RSL composes with it via `<schema>`[^1]. [source]

Facts and statements

| | RSL 0.9 (Sept 2025) | RSL 1.0 (2025-12-10) | |---|---|---| | Document apparatus | None — no editors, status, or identifier | `RSL-SPEC-1.0`, Category *Industry Specification*, Status *Recommendation*, 9 named editors | | Usage tokens | `all`, `ai-train`, `ai-input`, `search` | **adds** `ai-all`, `ai-index` | | Payment types | includes `inference` | `inference` → **`use`**; **adds** `contribution` | | Protocols | — | **adds OLP, CAP, EMS** | | Schema | — | **adds Relax NG Compact** (Appendix A) | | Legal terms | — | **adds** warranties / disclaimers / attestation / proof | [source]
| Rung | You publish | You need to operate | Enforcement | |---|---|---|---| | 1. Declaration | `license.xml` + `robots.txt` `License:` | nothing | Honour-system; evidentiary/notice value only | | 2. Shared framework | + `<payment><standard>…` pointing at a collective or platform policy | nothing (the framework issuer does it) | Whatever the issuer enforces | | 3. Licensing server | + `server=` on `<content>` | an OLP `/token` + `/introspect` service | Token required before access | | 4. Request-time enforcement | + CAP | Resource server validates `Authorization: License …`, returns 401/402 | [source]
| RSL usage token | AIPREF `-07` equivalent | |---|---| | `ai-train` | ≈ `train-ai` | | `search` | ≈ `search` | | `ai-input` | **none** — AIPREF dropped the RAG/inference-input axis | | `ai-index` | **none** | | `ai-all`, `all` | **none** — AIPREF removed its superset category | [source]
| Attribute | Meaning | |---|---| | `url` | **Required.** The licensed asset or scope. Outside HTML/RSS/embedded-file association, it MUST be an RFC 9309 path — i.e. `robots.txt` path grammar, **including `*` and `$` wildcards**. Doubles as the canonical, opaque license identifier | | `server` | Optional. Base URL of an OLP License Server. **If present, clients MUST obtain a token before access — even for `free` and `attribution` licenses** | | `encrypted` | Optional boolean, lowercase, default `false`. If `true`, `server` is required and MUST support EMS | | `lastmod` | Optional RFC 3339 time [source]
**Settled: `robots.txt` is not a technological access control under DMCA §1201(a).** In *Ziff Davis v. OpenAI* (S.D.N.Y., 2025-12-15) the court dismissed the anti-circumvention claim, holding that robots.txt files "do not 'effectively control' access to that content any more than a sign requesting that visitors 'keep off the grass' effectively controls access to a lawn… robots.txt directives are merely requests… This is not 'circumvention' under the DMCA"[^40]. Leave to amend was denied three days later. [source]
**IANA / standards posture.** The spec *requests* registration of the `application/rsl+xml` media type and the `License` HTTP authentication scheme, and asserts that it "normatively extends" RFC 9309 with the `License` directive[^1]. These are requests and assertions made by an industry specification, not completed IETF actions — see Concept 7 for what that means. [source]
**Does R.V. Guha's involvement confer legitimacy?** Partially, and worth stating precisely. Guha is a listed RSL 1.0 editor (credited as Schema.org), co-creator of RSS, Schema.org, RDF and MCF[^1]. RSL's architecture visibly reflects that lineage — namespaced XML vocabulary, Relax NG schema, foreign-namespace must-ignore extension model, an RSS module, Schema.org JSON-LD integration. **Schema.org is also the strongest precedent RSL has**: a vendor-consortium vocabulary that never became a W3C Recommendation and is now universally deployed. What it does *not* confer is procedural standing insid [source]
**What the RSL Collective is.** Self-described as a "**nonprofit rights organization**" and licensing platform; legal entity appears as **RSL Internet Collective**, California governing law[^11]. Its own framing is explicitly the **ASCAP/BMI analogy**: "Collective licensing organizations like ASCAP and BMI have long helped musicians get paid fairly by working together and pooling rights into a single, indispensable offering"[^12]. It offers collective negotiation, automated licensing, encryption for proprietary content, and billing/reporting/auditing[^12]. [source]
**Server-side enforcement signalling** works without any of the three: a server MAY answer `401`/`402` with either an inline `application/rsl+xml` body (a dynamic, request-specific license) or a `Link` header pointing at the governing license[^1]. [source]
**Of nine testable September-2025 founding supporters, exactly one (Medium) deploys.** Of ten named v1.0 endorsers tested, two (Stack Overflow, The Guardian) do[^20]. Non-deployment is not an artifact of only checking `robots.txt`: HTTP `Link: rel="license"` headers were absent on all founding supporters tested, and `/license.xml` probes returned 404 (Reddit's returns 200 but serves its HTML SPA catch-all, not RSL)[^20]. [source]
- **Fastly** (spec editor) shipped a **VCL how-to blog post**, not a product, explicitly deferring real support: "In the future, we'll make a much tighter integration… but in the meantime, we wanted to give you the chance to try it out for yourself"[^24]. Fastly's own site does not deploy RSL[^20]. - **Cloudflare** endorsed v1.0 but ships an architecturally opposed stack — default AI-crawler blocking, Content Signals Policy, and **Pay Per Crawl**, which does not read `robots.txt` and actively blocks non-payers[^25][^35][^36]. Cloudflare's own site does not deploy RSL[^20]. - **Akamai** is a li [source]
The most useful reframing found in the literature: RSL is neither a lock nor a preference but a **standing offer** — published, dated, per-path, priced, open until withdrawn. A preference (AIPREF, Content Signals) has no acceptance state; an offer does. Whether crawler conduct constitutes acceptance is untested. [source]
The `contribution` payment type was co-developed with Creative Commons as the first application of the CC signals initiative[^10]. [source]
**Governance posture — the most under-reported fact about RSL.** The specification is licensed **CC BY-ND 4.0**, and "RSL" and "Really Simple Licensing" are **trademarks of the RSL Collective**[^1]. CC BY-**ND** is a *NoDerivatives* licence: the text may be redistributed verbatim but **not modified or forked**. The Open Definition classifies CC no-derivatives licences as **non-conformant**[^19]. This is materially more restrictive than W3C or IETF document licensing, which permits derivative works precisely so a specification can be forked or independently revised. [source]
| Token | Covers | |---|---| | `all` | Any automated processing, incl. AI training and search | | `ai-all` | Any AI use — explicitly a superset of `ai-train`, `ai-input`, `ai-index`, plus AI uses not yet enumerated | | `ai-train` | Training or fine-tuning models | | `ai-input` | RAG, grounding, generative search summaries — content *into* a model at inference time | | `ai-index` | Inclusion in an AI system's internal index / retrieval database | | `search` | Classic search indexing: hyperlinks and short excerpts. **Explicitly excludes AI-generated summaries** | [source]
| Tool | What it is | Status (verified 2026-09-02) | |---|---|---| | `https://rslstandard.org/validate` | Browser-based validator; paste XML, "Check Document". Self-described as **"not normative"** | Live; no API, no downloadable CLI, no documented schema binding[^9] | | Appendix A, RSL 1.0 spec | **Relax NG Compact schema** for RSL documents — the machine-checkable grammar | Published in-spec[^1] | | `https://rslcollective.org/developers` | The **only** license server listed in RSL's own registry ("Nonprofit server operated by leading web publishers"); OLP base `https://api.rslcollective.org` [source]
**The spec is still being amended in place.** The errata log runs from 2026-01-16 to at least **2026-08-07**, and includes a genuinely new normative section — **`<reporting>` (§3.12) was added 2026-06-12, six months after 1.0 shipped**[^1]. Treat "RSL 1.0" as a moving target and check the errata page before relying on any section. [source]
| Domain | `License:` directive | |---|---| | **medium.com** | `License: https://medium.com/license.xml` ✅ | | **stackoverflow.com** | `License: https://stackoverflow.com/license.xml` ✅ | | **theguardian.com** | `License: https://theguardian.com/license.xml` ✅ | | reddit.com | **absent** (serves blanket `Disallow: /`) | | yahoo.com · quora.com · oreilly.com · wikihow.com | **absent** | | people.com · ziffdavis.com · thedailybeast.com · ranker.com | **absent**[^20] | | apnews.com · vox.com · usatoday.com · buzzfeed.com · slate.com | **absent**[^20] | | fastly.com · cloudflare.com | **absent**[^ [source]
**Governance body.** The **RSL Technical Steering Committee (TSC)** publishes the spec; contact `[email protected]`, issues at `github.com/rslstandard/rsl`[^1]. The v1.0 editor list (9): G. Boyer (RSL Collective), C. Chen (Condé Nast), J. Fortuna (Ziff Davis), RV Guha (Schema.org), S. Koenig (Yahoo), J. Le Page (Automattic), A. Odewahn (O'Reilly Media), E. Walther (RSL Collective, TSC Chair), S. Wistow (Fastly)[^1]. The public TSC roster lists **eight** — Boyer is an editor but not on it; RSL does not explain the difference[^11]. Membership has churned: the Sept 2025 TSC named **Tim O'Reilly [source]
**Serving requirements that the quickstart glosses over but the spec mandates**[^1]: - Serve the XML as `Content-Type: application/rsl+xml`. - Serve it over **HTTPS** — clients MUST retrieve RSL files over HTTPS only. - Set `Last-Modified`/`ETag` so clients can cheaply revalidate; pick `max-age` deliberately (days; default 30). - **Every subdomain needs its own `robots.txt`** and therefore its own `License:` line[^6] — `robots.txt` is host-scoped, so `www.example.com` and `blog.example.com` do not inherit from each other. [source]
**The turf ruling.** In Dec 2025 an issue was filed against the AIPREF drafts arguing the vocabulary should carry payment methods and pricing per purpose, citing rslstandard.org directly and proposing RSL's extensibility be adopted into the IETF work. Co-chair Mark Nottingham closed it (2026-03-26): *"this proposal is a very different approach to the Working Group's deliverables, in a way that would likely require a charter change."*[^34] The charter corroborates it — technical enforcement of preferences, authenticating/authorizing crawlers, and preference registries are all explicitly **out o [source]
**Adjacent-body relationships** that are *not* standardization paths: Creative Commons co-developed `contribution`[^10]; IAB Tech Lab endorsed RSL while running a parallel effort (Content Monetization Protocols), with the two "collaborating on how each standard can dovetail," details unsketched[^14]. [source]
**Conflict resolution** is order-independent and restrictive-biased: document order MUST NOT affect interpretation; all applicable terms are evaluated together; more specific declarations beat broader ones; and where terms genuinely conflict, clients **MUST honor the most restrictive combination**[^1]. `<prohibits>` beats `<permits>` for the same `type`. [source]
Spec §11 acknowledges a wider circle: Elisabeth Douglas (wikiHow), Tony Stubblebine (Medium), Tim O'Reilly, Doug Leeds, Jonathan Roberts (People Inc.), **Will Allen (Cloudflare)**, and **Timid Robot Zehta (Creative Commons)**[^1]. [source]
**Asset-level metadata** (children of `<content>`, siblings of `<license>`)[^1]: `<schema>` (linked or inline Schema.org JSON-LD), `<alternate type="…">` (WARC/JSON/Markdown/plain-text renditions that **inherit the parent's license**), `<copyright type="person|organization" contactEmail contactUrl>`, and `<terms>` (URL to human-readable ToS). RSL publishes canned default terms at `https://rslstandard.org/rsl/default-terms`. [source]
**Pure speculation by commentators — label it as such:** - *"RSL creates notice that defeats fair use or innocent infringement."* Plausible-sounding; **no case so holds**. Under 17 U.S.C. §504(c)(2) notice can defeat an *innocent-infringement damages reduction*, but that is a narrow damages argument, not a liability theory. Note also that the large AI settlements to date have turned on **piracy of source material**, not on crawling and training[^45]. - *"RSL gives AI companies legal certainty"* — a marketing claim, disputed[^45]. - *"Regulation will follow the industry standard, as with `robot [source]
9. **Assuming `<permits>` is additive.** It is a **closed enumeration** — declaring `<permits type="usage">search</permits>` denies `ai-train`, `ai-input`, and `ai-index` by omission[^1]. Publishers who intend "search *and* RAG" must list both. [source]
llms.txt carries **no licensing vocabulary at all**, and ai.txt expresses only opt-out — neither can say "$0.015 per crawl, RAG allowed, training prohibited, US and EU only, attribution required." That expressive gap is RSL's reason to exist. Concept 7 maps the full standards landscape, including the IETF AIPREF working group, which is the comparison that actually matters for RSL's long-term standing. [source]
The standard's own site demonstrates the pattern — `https://rslstandard.org/robots.txt` carries a prose notice plus `License: https://rslcollective.org/royalty.xml`, and that URL serves a four-line RSL document permitting `ai-all` under a `use`-metered collective license (verified 2026-09-02)[^2][^3]. [source]
**No AI company has agreed to honour RSL.** OpenAI, Google/DeepMind, Anthropic, Meta, xAI, Mistral and Amazon are specifically documented as having made no commitment; no statement of support was found from Perplexity, Microsoft, Cohere or Common Crawl[^21][^22][^23]. Enforcement is, in one trade publication's phrase, "punted off to technical, legal and regulatory organizations such as CDNs, lawsuits and government bodies"[^22]. **This absence is the single most important fact about RSL**: it is a licensing offer whose counterparties have publicly declined to accept. [source]
**Tooling is real but at hobby scale.** A GitHub search returns six RSL repositories in total; the flagship is a WordPress plugin, `Jameswlepage/rsl-wp`, at **34 stars and 0 forks**[^27]. It is **not in the WordPress.org plugin directory** — the plugin API returns "Plugin not found"[^28]. The only license server in production is the RSL Collective's own[^7]. [source]
Its intellectual lineage is stated in the spec: RSS (for the syndication/module model), the Robots Exclusion Protocol RFC 9309 (for discovery and path grammar), Creative Commons (for shared license frameworks), HTML Encrypted Media Extensions (for EMS), and OAuth 2.0 (for OLP)[^1]. That lineage is literal, not rhetorical — co-founder **Eckart Walther** is credited as a co-creator of RSS[^10]. [source]
**OLP (Open License Protocol)** — an **OAuth 2.0 extension** for license acquisition[^1]. Role mapping: Publisher ≈ Resource Owner, Client ≈ OAuth Client, License Server ≈ Authorization Server, Resource Server ≈ Resource Server. Three required endpoints on the `server` base URL: [source]
| Endpoint | Method | Purpose | |---|---|---| | `/token` | POST | Acquire a License Token | | `/introspect` | POST | Validate a token against a specific resource | | `/key` | POST | Retrieve an EMS decryption key (JWK, `kty="oct"`) | [source]
**CAP (Crawler Authorization Protocol)** — an HTTP authentication scheme, built on RFC 9110, that proves a crawler holds a license at request time[^1]: [source]
**Origin.** RSL was launched **2025-09-10** in San Francisco, simultaneously as a specification (v0.9) and as a licensing body, the **RSL Collective**[^10]. Co-founders: **Eckart Walther** (former CEO of CardSpring, product exec at Uber, Twitter and Yahoo Search) and **Doug Leeds** (former CEO of IAC Publishing and Ask.com); a third named leader, **Geraud Boyer** (ex-Datadog, Twitter, CardSpring), is a v1.0 spec editor[^10][^11][^13]. [source]
> **Naming trap:** there are **two** steering committees. The **technical** TSC governs the spec; a separate **publisher steering committee inside the RSL Collective** was developing the member licensing agreement[^14]. Press references to "the RSL steering committee" are ambiguous — check which is meant. [source]
11. **Citing the "1500+ organizations" figure as deployment.** That is an endorsement count from RSL's own announcement[^4], not a measurement of sites serving a `License:` directive. → Distinguish announced support from verified deployment; check `robots.txt` yourself. [source]
A closing observation that reframes the whole map: **the same two dozen people are building all of these.** Zehta (CC) appears in the RSL and AIPREF acknowledgments and authors two AIPREF drafts; Le Meur (TDMRep) and Rosenthol (C2PA) also appear in the AIPREF acknowledgments; Allen (Cloudflare) is in RSL's. The fragmentation is real at the file-format level; at the human level this is one community that has not yet agreed on a layering. [source]
**Hard invariants** (a document violating these is non-conformant)[^1]: [source]
The one-line positioning that matters: **`robots.txt` says *whether you may fetch*; RSL says *on what terms you may use*.** RSL does not replace `robots.txt` — it is discovered *through* it, via a new `License:` directive that points at an RSL XML document. Explicitly, the `License` directive "does not modify the access permissions expressed by `Allow` or `Disallow`"[^1]. [source]
| | Question it answers | Format | Location | |---|---|---|---| | **llms.txt** (→ `llms-txt.md`) | *What should an AI read?* Curation and discovery | Structured Markdown | `/llms.txt` | | **ai.txt** (→ `ai-txt.md`) | *May you train on this?* Binary opt-out | robots.txt-style directives | `/ai.txt` | | **RSL** (this file) | *On what terms and at what price may you use this?* Licensing | XML | any URL, referenced from `robots.txt` etc. | [source]
**`robots.txt` — the headline integration.** (For REP itself — the ABNF, group selection, longest-match precedence, the 500 KiB floor and the Google/Bing divergences — see `robots-txt.md` in this hub; this file covers only the `License:` extension.) RSL adds a `License` directive to the Robots Exclusion Protocol[^1]: [source]
1. **Treating RSL as an access control.** RSL is a *declaration*. Rungs 1–4 of the ladder above stop nothing; a crawler that ignores your XML gets the same bytes it always did. Only EMS (`encrypted="true"`) is a technical control. → If you need enforcement, pair RSL with bot management / Web Bot Auth, or encrypt. [source]
RSL additionally carries three axes AIPREF has no concept of: `type="user"`, `type="geo"`, and `<payment>` with `<amount currency>`[^1]. [source]
ai.txt is a pre-AIPREF, pre-RSL binary opt-out scoped by media type; RSL's `<permits type="usage">` supersedes its entire expressive range. [source]
Combined with the practical state of the public repository — **one file (README.md), 8 commits, 1 contributor, 46 stars, 1 fork, no releases, no LICENSE, no charter, no code of conduct, last pushed 2026-03-31**[^5] — the effective governance model is: a small, self-appointed committee of commercially interested parties publishes a non-forkable document under the copyright and trademark of the nonprofit that also operates the licensing marketplace the standard routes to. The repo's README additionally still reads "Really Simple **Syndication** (RSL)" and describes the spec as "currently in `dra [source]
`<content>` attributes[^1]: [source]
**1. Author `license.xml` at the site root.** [source]
**3. Register with a license server** — only if you want acquisition/payment enforcement. Omit `server` and you have a pure declaration; add `server="https://api.example.com"` and clients MUST obtain a token before access, *even for free licenses*[^1]. [source]
Then paste the document into `https://rslstandard.org/validate`[^9] — remembering that validator is explicitly non-normative, and the Relax NG Compact schema in spec Appendix A is the authority[^1]. [source]
**No money has moved and no one has litigated under RSL.** Compensation is "effectively zero" for the vast majority of publishers[^22]. A micropayments partner told press at the v1.0 launch that roughly a dozen customers had been beta-testing for two quarters but "**bots aren't actually being billed at this point** — as of right now, we're just collecting data to show what's going on"[^15]. Two adjacent claims must not be misread as RSL enforcement: [source]
**`<legal>`** — machine-readable warranties and disclaimers, one element per `type`[^1]: - `warranty`: `ownership`, `authority`, `no-infringement`, `privacy-consent`, `no-malware` - `disclaimer`: `as-is`, `no-warranty`, `no-liability`, `no-indemnity` - `attestation`: boolean; asserts the declarer owns or is authorized to assert the rights - `contact`: a URL or `mailto:` - `proof`: space-separated URIs to cryptographic evidence (transparency logs, verifiable credentials, blockchain records) [source]
The `warranty`/`attestation` pair is doing real work: it lets a licensee point at a machine-readable ownership assertion, which matters for a downstream indemnity or fair-use posture. [source]
> **Educational only — not legal advice.** This area is jurisdiction-specific and actively moving. [source]
**Zero of the deployments checked are fully conformant**, including the two operated by the standard's own organisations. That is the sharpest available evidence that nothing is consuming these files: a defect no consumer detects is a defect no one fixes. [source]
**Embedded-file association** requires an `<rsl:rsl>` wrapper, exactly one `<rsl:content>`, and a **non-empty stable canonical URL**, so licensing metadata survives the file being copied off the web entirely[^1]. [source]
3. **Serving the XML as `text/xml` or `text/plain`.** The spec mandates `application/rsl+xml`[^1]. Static hosts (S3, GitHub Pages, many CDNs) will guess wrong for a `.xml` extension. → Set the media type explicitly. [source]
8. **Contradicting your own human-readable ToS.** RSL's `<terms>` links the prose terms; if the XML says `ai-train` permitted at $0.015/crawl and your ToS forbids all automated access, you have created ambiguity a licensee will resolve in their favour. → Reconcile, and let `<terms>` point at the reconciled document. [source]
**2. Reference it from `robots.txt`.** [source]
**Honest bottom line.** RSL today buys you a **dated, machine-readable, public statement of terms**. That has real evidentiary value (Concept 9) and costs almost nothing to publish. It does not currently buy you enforcement, revenue, or crawler compliance, and nobody should be told otherwise. [source]
`<permits>` and `<prohibits>` each take a `type` attribute and a **space-separated** token list. At most one of each element per distinct `type` per `<license>`. `<permits>` is a **closed enumeration** — if a `<permits type="usage">` exists, only the listed values are allowed[^1]. [source]
**`type="usage"`** — the AI-use vocabulary. The spec states this category *includes the Cloudflare Content Signals vocabulary* and MAY absorb further standardized vocabularies "as they become available (e.g., IETF AI Preferences)"[^1]: [source]
**`type="geo"`** — ISO 3166-1 alpha-2 codes (`US`, `EU`, …), on either `<permits>` or `<prohibits>`[^1]. [source]
7. **Adding `server=` without operating a license server.** `server` makes token acquisition **mandatory before access, even for `free` and `attribution` licenses**[^1]. Point it at a host that does not implement OLP `/token` and every compliant client is blocked, while non-compliant ones proceed — exactly inverted. → Omit `server` unless the OLP endpoints are live; use `<standard>` to reference a framework instead[^1]. [source]
**The honest summary of its status:** the specification is unusually complete and well-engineered for a one-year-old industry standard, its endorsement list is genuinely impressive, and its *deployment* and *honouring* are a different matter entirely — see Concepts 8 and 9 before advising anyone that publishing RSL will get them paid. [source]
12. **Assuming RSL and llms.txt compete, and picking one.** They solve different problems and compose (Concept 7). Publishing llms.txt does not express any licensing terms; publishing RSL does not help an assistant find your best pages. [source]
4. **Forgetting that `robots.txt` is host-scoped.** `example.com/robots.txt` does not cover `blog.example.com`. Every subdomain needs its own file and its own `License:` line[^6]. → Enumerate subdomains and check each. [source]
Note the three distinct metering points — `crawl` (per fetch), `training` (per training use), `use` (per inference/answer). This tri-split is the standard's core economic proposition and its most contested one; see Concept 9. [source]
Spot-verified independently for this reference (`curl` against `/robots.txt`, 2026-09-02): [source]
`<payment type="…">` — one value from a closed set[^1]: [source]
Two further term elements sit beside `<payment>`: [source]
10. **Adding a `<reporting>` profile no client can implement.** A client that does not recognise the profile MUST treat the activity as **not licensed**[^1] — so an exotic reporting requirement converts your paid license into a blanket prohibition. → Only require profiles with real client support. [source]

Related concepts

robots.txt — is a related of Really Simple Licensing (RSL)
content — is a part of Really Simple Licensing (RSL)
endorsement — is a related of Really Simple Licensing (RSL)
legal — is a part of Really Simple Licensing (RSL)
payment — is a part of Really Simple Licensing (RSL)
License: — is a part of Really Simple Licensing (RSL)
RSL Collective — is a part of Really Simple Licensing (RSL)
OLP — is a part of Really Simple Licensing (RSL)
Cloudflare — is a related of Really Simple Licensing (RSL)
conformance — is a related of Really Simple Licensing (RSL)
EMS — is a part of Really Simple Licensing (RSL)
AIPREF — is a related of Really Simple Licensing (RSL)
permits — is a part of Really Simple Licensing (RSL)
CAP — is a part of Really Simple Licensing (RSL)
rsl+xml — is a part of Really Simple Licensing (RSL)
ai-train — is a part of Really Simple Licensing (RSL)
ai-input — is a part of Really Simple Licensing (RSL)
license.xml — is a part of Really Simple Licensing (RSL)
reporting — is a part of Really Simple Licensing (RSL)
llms.txt — is a related of Really Simple Licensing (RSL)