`--extract-links` liest jedes Tag mit URL, nicht nur Anker: `<a href>`,
`<script src>`, `<link href>`, `<form action>`, ``, ``,
`<source src>`, `<object data>`, `<embed src>` und `<meta http-equiv="refresh">`
-Ziele. Relative URLs werden gegen die Seite aufgelöst (unter Berücksichtigung von `<base href>`),
Duplikate werden zusammengefasst, und entdeckte Links durchlaufen dieselben Filter
und Host-Validierungen wie der Rest des Durchlaufs. Siehe
[docs/content/guide/cli-options.md](https://github.com/hahwul/urx/blob/main/docs/content/guide/cli-options.md) für die
vollständige Tabelle.

`--extract-js-endpoints` geht einen Schritt weiter und liest das JavaScript
selbst: jede gesammelte URL, die wie ein Skript aussieht, wird abgerufen und ihre
String-Literale werden nach den Pfaden und URLs durchsucht, die die App aufruft —
`fetch("/api/v2/users")`, `axios.post("/graphql")`, das statische Präfix von
`` `/api/orders/${id}` ``. Dies sind die Endpunkte, die nie im HTML erscheinen.
Die Ausgabe wird aggressiv entrauscht (MIME-Typen, Modul-Spezifizierer, Base64,
CSS-Werte, Regex-Fragmente und mehr werden verworfen), jeder Body ist auf
10 MiB begrenzt, die Anzahl der abgerufenen Dateien wird durch `--max-js-files` begrenzt, und die
entdeckten Endpunkte durchlaufen dieselben Filter und Host-Validierungen wie alles
andere. Die vollständige Extraktions- und Rauschunterdrückungsrichtlinie finden Sie in
[docs/content/guide/cli-options.md](https://github.com/hahwul/urx/blob/main/docs/content/guide/cli-options.md#javascript-endpoint-extraction).

`--archive-body` führt dieselbe Extraktion über die Bodies durch, die die Wayback Machine
*gespeichert* hat, statt über die Live-Seite, sodass eine Seite, die vor Jahren gelöscht wurde,
immer noch die enthaltenen Links liefert. Siehe
[Mining Archived Response Bodies](#mining-archived-response-bodies).

### Beispiele```bash
# Save results to a file
urx example.com -o results.txt

# Output in JSON format
urx example.com -f json -o results.json

# Filter for JavaScript files only
urx example.com -e js

# Exclude HTML and text files
urx example.com --exclude-extensions html,txt

# Filter for API endpoints
urx example.com --patterns api,v1,graphql

# Exclude specific patterns
urx example.com --exclude-patterns static,images

# Use Fileter Preset (similar to --exclude-extensions=png,jpg,.....)
urx example.com -p no-images

# Use specific providers
urx example.com --providers wayback,otx

# Add the keyless Arquivo.pt (Portuguese web archive) provider
urx example.com --providers wayback,cc,otx,arquivo

# Query another CDX index server alongside the defaults (id: cdx:vefsafn.is)
urx example.is --cdx-endpoint https://vefsafn.is/cdx

# ...or on its own, rate-limited, with the archive-side filters it shares with wayback/cc
urx example.is --cdx-endpoint https://vefsafn.is/cdx --providers cdx:vefsafn.is \
  --rate-limit-by cdx:vefsafn.is=1 --from 2020 --archive-status 200

# URLScan works without a key (anonymous, rate-limited); a key just raises limits
urx example.com --providers urlscan

# BeVigil: endpoints pulled out of unpacked Android apps (key required; auto-enables the provider)
URX_BEVIGIL_API_KEY=*** urx example.com

# Using VirusTotal and URLScan providers
# 1. Explicitly add to providers (with API keys via command line)
urx example.com --providers=vt,urlscan --vt-api-key=*** --urlscan-api-key=***

# 2. Using environment variables for API keys
URX_VT_API_KEY=*** URX_URLSCAN_API_KEY=*** urx example.com --providers=vt,urlscan

# 3. Auto-enabling: providers are automatically added when API keys are provided
urx example.com --vt-api-key=*** --urlscan-api-key=*** # No need to specify in --providers

# 4. Multiple API key rotation (to mitigate rate limits)
# Using repeated flags for multiple keys
urx example.com --vt-api-key=key1 --vt-api-key=key2 --vt-api-key=key3

# Using environment variables with comma-separated keys
URX_VT_API_KEY=key1,key2,key3 URX_URLSCAN_API_KEY=ukey1,ukey2 urx example.com

# Combining CLI flags and environment variables (CLI keys are used first)
URX_VT_API_KEY=env_key1,env_key2 urx example.com --vt-api-key=cli_key1 --vt-api-key=cli_key2

# URLs from robots.txt and sitemap.xml are included by default

# Exclude URLs from robots.txt files
urx example.com --exclude-robots

# Exclude URLs from sitemap
urx example.com --exclude-sitemap

# Also read every archived version of robots.txt and sitemap.xml, so paths the
# site once listed and has since removed come back
urx example.com --archived-discovery

# Only the versions captured in a given era
urx example.com --archived-discovery --from 2014 --to 2016 --exclude-sitemap

# Include subdomains
urx example.com --subs

# Check status of collected URLs
urx example.com --check-status

# Read URLs directly from a text file
urx --files urls.txt

# Combine file input with filtering
urx --files urls.txt --patterns api,admin -f json

# Extract additional links from collected URLs
# (anchors, scripts, stylesheets, form actions, iframes, images, media
#  sources, objects, embeds, and meta-refresh targets)
urx example.com --extract-links

# Discovered links go through the same filters as everything else, so this
# keeps only the JavaScript the pages reference
urx example.com --extract-links -e js

# Read the collected JavaScript and pull out the API paths it calls
urx example.com --extract-js-endpoints --patterns api

# Chain them: collect the site's bundles, then mine those for endpoints
urx example.com --extract-links --extract-js-endpoints --max-js-files 100

# Mine the links inside the *archived* bodies instead — dead pages included.
# One request per distinct body; the limit bounds bodies, not URLs
urx example.com --archive-body --archive-body-limit 200 --rate-limit 5

# Network configuration
urx example.com --proxy http://localhost:8080 --timeout 60 --parallel 10 --insecure

# Advanced filtering
urx example.com -e js,php --patterns admin,login --exclude-patterns logout,static --min-length 20

# HTTP Status code based filtering (live requests: urx re-fetches each URL)
urx example.com --include-status 200,30x,405 --exclude-status 20x

# Archive-side filtering (free: the CDX index already knows these)
# Skip everything the archive recorded as a 404 — no extra requests
urx example.com --archive-exclude-status 404

# Only captures the archive served as JSON — finds extensionless API endpoints
urx example.com --archive-mime application/json

# Drop HTML to leave assets and endpoints behind
urx example.com --archive-exclude-mime text/html

# Restrict the crawl window across wayback, cc, arquivo, and any --cdx-endpoint alike
urx example.com --from 2023 --to 2024

# Disable host validation
urx example.com --strict false

# URL normalization and deduplication
# Normalize URLs by sorting query parameters and removing trailing slashes
urx example.com --normalize-url

# Combine normalization with endpoint merging for comprehensive deduplication
urx example.com --normalize-url --merge-endpoint

# URL normalization with file input
urx --files urls.txt --normalize-url

# Collapse /post/1, /post/2, /post/99999 ... into a single representative line
urx example.com --dedup-similar

# Regular-expression filtering (repeat either flag; they are never comma-split)
urx example.com --match-regex '/api/v[0-9]+/'
urx example.com --match-regex '\.php$' --match-regex '\.aspx$'
urx example.com --filter-regex '/(assets|static)/'

# Regexes are case-sensitive; ask for insensitivity explicitly
urx example.com --match-regex '(?i)admin'

# Security presets: match by path shape as well as by extension
urx example.com -p only-secrets   # /.env, /.git/config, id_rsa, *.pem
urx example.com -p only-backup    # *.bak, *.sql, /backup/, index.php~
urx example.com -p only-config    # *.yaml, web.config, .htaccess, Dockerfile
urx example.com -p only-api       # /api/, /v1/, /graphql, /swagger, *.wsdl

# Scope files: a bug bounty program's own host list, used verbatim
urx example.com --subs --scope-file scope.txt

# Metadata filters, applied after collection so every provider is covered
urx example.com --providers wayback --meta-last-seen-after 2024 --meta-exclude-mime 'image/*'
urx example.com --providers wayback --meta-mime application/json --meta-status 200

# What parameters does this target take, and where?
urx example.com --params
urx example.com --params-by-endpoint

# One templated URL per parameter signature, straight into a fuzzer
urx example.com --fuzz-placeholder FUZZ | ffuf -w - -u FUZZ

# A target-specific wordlist instead of a URL list
urx example.com --subs -f wordlist -o words.txt

# Open the API specifications the sweep found and expand every route in them
urx example.com -p only-api --expand-specs

# Status checks also keep the response head; --check-title adds the <title>
urx example.com --check-status -f jsonl
urx example.com --check-title --show-meta

# Inspect and maintain the cache
urx cache stats
urx cache drop example.com

Das ist kein Filter, der nachträglich angewendet wird. Ein CDX-Index beantwortet Präfixabfragen nativ, also sendet urx `url=example.com/shop*` und das Archiv überträgt den Rest der Website nie über das Netzwerk — bei einem großen Ziel ist das der Unterschied zwischen ein paar hundert Zeilen und ein paar hunderttausend. Anbieter, die einen Pfad nicht in ihrer Abfrage ausdrücken können (OTX, VirusTotal, urlscan, GitHub, BeVigil, ZoomEye), werden nach dem Host gefragt und ihre Antworten werden anschließend eingegrenzt, ebenso wie die Ergebnisse eines `--subs`-Laufs, bei dem die `*.host`-Form und ein Pfadpräfix nicht in einer CDX-Abfrage kombiniert werden können.

Scope bedeutet *auf oder unter* dem Pfad: `/shop` und `/shop/cart` sind enthalten, `/shopping` nicht. Groß-/Kleinschreibung wird ignoriert, weil ein CDX-Server die gesamte URL in Kleinbuchstaben umwandelt, wenn er seinen Indexschlüssel erstellt — `example.com/Shop*` und `example.com/shop*` liefern dieselben Zeilen, alle in Kleinbuchstaben geschrieben, sodass eine groß-/kleinschreibungssensitive Prüfung alles verwerfen würde, was das Archiv gerade zurückgegeben hat. Ein Query-String oder Fragment im Ziel wird verworfen — diese schränken eine Anfrage ein, nicht einen Scope.

> Hinweis: urx hat früher den Pfad aus einem Ziel verworfen, sodass
> `urx https://example.com/shop` die gesamte Domain `example.com` scannte. Jetzt
> wird `/shop` gescannt. Übergeben Sie nur den Host für das alte Verhalten; ein Lauf, dessen Ziel
> einen Pfad enthält, gibt dies auf stderr aus.

### Filterung mit regulären Ausdrücken

`--patterns` / `--exclude-patterns` sind einfache Teilstring-Tests: beide Seiten werden
in Kleinbuchstaben umgewandelt, und jedes Metazeichen ist ein Literal. `--match-regex` /
`--filter-regex` sind die Regex-Gegenstücke, und sie unterscheiden sich in drei Punkten, die
es wert sind, in Erinnerung zu bleiben:

| | `--patterns` | `--match-regex` |
|---|---|---|
| Übereinstimmung | Teilstring | vollständige [Regex-Syntax](https://docs.rs/regex/latest/regex/#syntax) |
| Groß-/Kleinschreibung | insensitive (beide Seiten in Kleinbuchstaben) | **sensitive** — verwenden Sie `(?i)`, um dies zu deaktivieren |
| Mehrere Werte | ein kommagetrennter Schalter | den Schalter wiederholen; Kommas werden nie aufgeteilt |

Beide Regex-Schalter werden gegen die **gesamte URL-Zeichenkette** ausgewertet, wie sie gesammelt wurde
(Schema, Host, Pfad und Query), sodass sowohl `^https://` als auch `\.js$` funktionieren.
Ausschluss gewinnt: eine URL, die auf `--filter-regex` passt, wird verworfen, selbst wenn
`--match-regex` ebenfalls darauf gepasst hat. Ein fehlerhafter Ausdruck lässt den Lauf beim
Start fehlschlagen, bevor ein Archiv abgefragt wird.

### Scope-Dateien

Der Scope eines Bug-Bounty-Programms ist eine Liste von Hosts, und jede Plattform schreibt sie
auf die gleiche Weise. `--scope-file` nimmt diese Liste wörtlich entgegen, anstatt Sie
sie manuell in verankerte Regex-Alternationen zu übersetzen — wobei eine falsche
Verankerung den Scope stillschweigend *erweitert*, anstatt fehlzuschlagen.```text
# scope.txt — in scope
*.example.com
api.example.org

# out of scope, even though the wildcard above covers them
!admin.example.com
!*.internal.example.com

`*.example.com` trifft sowohl den Apex als auch alles darunter (die
Bug-Bounty-Lesart, die eine Scope-Tabelle einer Plattform meint); ein bloßer Host
trifft genau diesen Host; ein einzelnes `*` macht die Datei zu einer reinen Deny-Liste;
Ausschlüsse gewinnen immer; `#` beginnt einen Kommentar. Alles, was urx nicht
berücksichtigen kann — ein Port, ein Pfad, ein Wildcard in der Mitte — ist ein
Startfehler, der die Datei und Zeile benennt, statt einen stillschweigend
erweiterten Scope. Der Filter gilt für jeden Provider und für extrahierte Links,
und er kombiniert sich mit `--strict`, statt es zu ersetzen, sodass eine
`*.example.com`-Scope-Zeile weiterhin `--subs` benötigt.

### Archiv-Metadaten-Filter

`--from`/`--to` und die `--archive-*`-Prädikate werden in die eigene Abfrage des
Archivs geschoben, was sie kostenlos macht und sie zugleich auf CDX-gestützte
Provider beschränkt — und die beiden CDX-Dialekte unterscheiden sich so stark,
dass eine positive Mehrwertliste (`--archive-status 200,301`) auf pywb-Servern
nicht erfüllbar ist. Die acht `--meta-*`-Filter laufen stattdessen *nach* der
Sammlung, über eine zusammengeführte Menge von Capture-Metadaten pro URL, sodass
sie einheitlich für jeden Provider gelten.```bash
# Endpoints still being captured recently, with HTML and images out of the way
urx example.com --providers wayback --meta-last-seen-after 2024 --meta-exclude-mime 'text/html,image/*'

# Pages that died: nothing captured since 2019
urx example.com --providers wayback --meta-last-seen-before 2019

# JSON the archive served successfully
urx example.com --providers wayback --meta-mime application/json --meta-status 200

# First archived during 2020 (partial dates pad to the start / end of the period)
urx example.com --providers wayback --meta-first-seen-after 2020 --meta-first-seen-before 2020

`--params-by-endpoint` fasst id-artige Pfadsegmente zu `{id}` zusammen, genau wie
`--dedup-similar` es tut, und schreibt den Endpunkt vollständig aus, weil urx
routinemäßig mehrere Hosts in einem Durchlauf scannt. `--fuzz-placeholder` behält eine URL pro
Parametersignatur und behält ihren echten Pfad bei – ein `{id}` würde nicht geroutet werden –,
sodass die Ausgabe direkt in einen Fuzzer eingespeist werden kann:```bash
urx example.com --fuzz-placeholder FUZZ | ffuf -w - -u FUZZ
urx example.com --fuzz-placeholder FUZZ | dalfox pipe

Segmente, die eher wie Daten als wie Routennamen aussehen, werden weggelassen, wobei die Testgruppen `--dedup-similar` wiederverwendet werden — eine Wortliste voller `4711`, UUIDs, Daten und Session-Tokens ist schlechter als gar keine Wortliste, da jedes dieser Wörter auf genau einem Ziel existiert. Ein Segment, dessen Stamm ein Identifier ist, entfällt ebenfalls
(`article-1234.html`). Groß-/Kleinschreibung bleibt erhalten: Pfadsegmente sind auf den meisten Origins case-sensitive, sodass die Kleinschreibung von `WebResource.axd` ein Wort erzeugen würde, das überall, wo es versucht wird, 404 liefert. Die Vereinigung muss über die vollständige Menge gebildet werden, daher ist das Format nur im Batch-Modus möglich.

### Streaming-Ausgabe

Standardmäßig sammelt urx alles, filtert dann, sortiert und gibt einmal aus. Bei einem großen Ziel bedeutet das gar keine Ausgabe, bis das langsamste Archiv fertig ist.
`--stream` schreibt jede URL in dem Moment, in dem der Provider, der sie meldet, zurückkommt:```bash
# Matches start appearing immediately instead of after the slowest provider
urx big-target.com --stream | grep admin

# Line-delimited JSON stays valid while it is still being written
urx big-target.com --stream -f jsonl | jq -r 'select(.url | test("/api/")) | .url'

Streaming (`--stream`) meldet nur URLs. Eine URL wird beim ersten Auftreten ausgegeben,
bevor die Captures eintreffen, die ihren `first_seen`/`last_seen`-Bereich erweitern würden,
daher wird `--show-meta` dort aus demselben Grund abgelehnt wie
`--show-sources`.

Ein Cache-Treffer trägt ebenfalls keine Metadaten: Der Cache speichert URLs, sodass eine Domain,
die aus dem Cache bedient wird, ihre URLs ohne Capture-Felder meldet. Verwenden Sie `--no-cache` (oder warten Sie
auf die TTL) für einen Lauf, der sie neu befüllt.

### Live-Response-Metadaten

`--check-status` sendet bereits eine Anfrage und wartet auf den Response-Head, sodass
das, was dieser Head trägt, kostenlos mitgeliefert wird: `Location`, `Content-Length` und
`Content-Type` werden zusammen mit dem Statuscode aufgezeichnet. Redirects werden weiterhin nie
verfolgt, sodass ein gemeldeter Status immer zu der URL gehört, die angefragt wurde, und
`location` einfach angibt, wohin der 3xx zeigte.

`--check-title` fügt den HTML-`<title>` hinzu. Es ist das einzige Feld, das nicht kostenlos ist –
ein Titel benötigt den Response-Body –, daher steht es hinter seinem eigenen Flag. Das Lesen wird
zweifach begrenzt (höchstens 64 KiB, und es stoppt am schließenden Tag) und für einen Body, den der
Server als Nicht-HTML deklariert hat, vollständig übersprungen, sodass eine JSON-API oder ein Bild
nichts kostet. Der Titel wird auf Leerraum reduziert, Entity-dekodiert und auf 200
Zeichen gekürzt. `--check-title` impliziert `--check-status`.```bash
urx example.com --check-status -f jsonl
urx example.com --check-title --show-meta
urx example.com --check-status --is 30x -f jsonl | jq -r '.url + " -> " + .location'

`-H` ist wiederholbar, nimmt `Name: value` entgegen, und ein fehlerhaftes beendet den Lauf,
anstatt unbemerkt hinauszugehen — ein Argument, das stillschweigend verworfen wird, lässt
einen anonymen Scan als authentifizierten erscheinen. `--cookie` und
`--user-agent` sind Kurzformen für die entsprechenden Header.

**Diese Header erreichen niemals ein Archiv.** Sie werden nur von den Komponenten
gesendet, die mit dem Ziel kommunizieren: den vier oben genannten Testern sowie den
`robots`- und `sitemap`-Providern, die ebenfalls vom Ziel abrufen. Jeder andere Provider
fragt web.archive.org, index.commoncrawl.org oder eine Drittanbieter-API ab, und
`--archive-body` tut dies ebenfalls, wenn es eine Aufzeichnung wiedergibt; ihnen das
Session-Cookie des Ziels zu übergeben, würde eine Anmeldeinformation an einen Dienst
senden, der behält, was er empfängt, ohne Nutzen. Archivabfragen behalten urx' eigenen
User-Agent, den `--random-agent` weiterhin rotiert.

### Archivierte Antwort-Bodies durchsuchen

`--extract-links` ruft jede gesammelte URL von der Live-Seite ab, was genau der
falsche Ort ist, um nach den Seiten zu suchen, die bei einem OSINT-Sweep am meisten
zählen: diejenigen, die nicht mehr existieren. `--archive-body` ruft stattdessen die
Bodies ab, die die Wayback Machine gespeichert hat. Für jede gesammelte URL, die einen
Aufzeichnungs-Zeitstempel trägt, gibt urx diese Aufzeichnung in ihrer Rohform wieder
(`https://web.archive.org/web/<timestamp>id_/<url>` — das `id_`-Flag schaltet die
Wayback-Toolbar und die Link-Umschreibung ab, sodass der Body die Originalbytes sind) und
führt dieselbe Link-Extraktion darauf aus, die `--extract-links` verwendet.```bash
# Links from the archived bodies of everything the CDX providers found
urx example.com --archive-body

# Bound the run and pace it; the archive is one host no matter how many URLs
urx example.com --archive-body --archive-body-limit 200 --rate-limit 5

# Only the JavaScript those pages referenced back then
urx example.com --archive-body -e js

**Die Bodies behalten.** Die Anfragen werden ohnehin bereits gestellt, sodass das Schreiben der Bodies auf die Festplatte nichts zusätzlich kostet und die Fragen beantwortet, die kein Link-Extraktor stellt: der `<!-- staging.internal -->`-Kommentar, das Token, das ein Build von 2019 inline eingebettet hat, der Stack-Trace, der eine Framework-Version nennt.```bash
urx example.com --archive-body --archive-body-dir ./corpus
grep -ri "api[_-]key" ./corpus

Was erweitert wird:

* **OpenAPI 3.x** — `servers[].url` (absolut, dokumentrelativ und templatisiert,
  wobei `{var}` aus `variables[var].default` oder dem ersten `enum`-Wert
  aufgelöst wird) gekreuzt mit jedem `paths`-Schlüssel; die eigenen `servers`
  eines Path Items überschreiben die des Dokuments.
* **Swagger 2.0** — `schemes` × `host` + `basePath`, wobei jeder Teil auf den
  entsprechenden Teil der URL des Dokuments selbst zurückfällt. `ws`/`wss`
  werden verworfen.
* **GraphQL-Introspektion** — eine URL pro Query-, Mutation- und
  Subscription-Feld, geschrieben als der Endpunkt plus `?query=…`. Ein als
  Datei gespeichertes Schema wird zu seinem Endpunkt aufgelöst
  (`/graphql/schema.json` → `/graphql`).

JSON und YAML werden beide gelesen. Ziele werden zuerst nach Namen und
kostenlos gewählt (ein Spec-Marker-Substring — `swagger`, `openapi`,
`api-docs`, `graphql`, `introspection` — plus eine `json`/`yaml`/`yml`-Erweiterung,
falls vorhanden, sodass `swagger-ui.html` keine Anfrage kostet), dann nach dem
`Content-Type` der Antwort. Pfadtemplates werden so ausgegeben, wie das Dokument
sie schreibt (`/users/{id}`, nicht `/users/%7Bid%7D`). Bodies sind auf 10 MiB
begrenzt, und ein YAML-Dokument mit mehr als 32 Alias-Referenzen wird vor dem
Parsen abgelehnt, um Expansion Bombs auszuschließen. `--max-spec-files`
(Standard 50) begrenzt die abgerufenen Dokumente. Mit ebenfalls aktiviertem
`--archive-body` wird eine archivierte Spezifikation ohne zusätzliche
Anfragekosten als eine gelesen — der Body wurde ohnehin bereits abgerufen.

### Archivierte robots.txt und sitemap.xml

Die Provider `robots` und `sitemap` lesen die *Live*-Dateien, die nur aussagen,
was eine Website heute verbirgt oder auflistet. `--archived-discovery` liest
zusätzlich jede unterschiedliche Version dieser Dateien, die die Wayback Machine
gespeichert hat. Ein `Disallow:` aus dem Jahr 2015 benennt Pfade, die die Website
seither nicht mehr erwähnt — oft, weil sie vergessen werden sollten, nicht weil
sie verschwunden sind — und eine alte Sitemap listet alles auf, was die Website
einst gecrawlt haben wollte.```bash
# Every archived version of robots.txt and sitemap.xml, alongside the live ones
urx example.com --archived-discovery

# Bound it and pace it; both archived providers answer to --rate-limit-by
urx example.com --archived-discovery --archived-discovery-limit 20 --rate-limit-by robots=2,sitemap=2

# Only the versions captured in a given era
urx example.com --archived-discovery --from 2014 --to 2016

* Die Provider-ID ist `cdx:<host>` (`cdx:vefsafn.is`), die von
  `--exclude-providers`, `--rate-limit-by`, `--stats` und `--show-sources` verwendet wird.
  Das Benennen eines Endpunkts aktiviert ihn; es ist kein `--providers`-Eintrag erforderlich, und
  `--providers cdx:vefsafn.is` führt ihn allein aus. `--list-providers` zeigt die
  Endpunkte an, die in derselben Befehlszeile benannt sind, mit den IDs, unter denen sie ausgeführt werden.
* Alles, was die integrierten CDX-Provider berücksichtigen, gilt auch hier: `--subs`,
  `--from`/`--to`, die `--archive-*`-Filter, Paginierung, `--rate-limit` und
  die oben beschriebenen Capture-Metadaten.
* `--cdx-dialect classic|pywb` benennt den Dialekt des Servers (Feldnamen, Filter-
  Semantik, Zeilenformat und Paginierungsschema folgen alle daraus — siehe
  „Archive-side Filtering"). Bleibt es ungesetzt, sondiert urx den Endpunkt einmal pro Lauf
  und fällt auf `pywb` zurück, den häufigeren Dialekt; setzen Sie es explizit, wenn die
  Sondierung es nicht erkennen kann (z. B. eine leere Antwort für eine unbekannte Domain).
* Kann auch in der Konfigurationsdatei gesetzt werden (`cdx_endpoint = [...]`, `cdx_dialect`).

**Verifizierte Endpunkte.** Zum Zeitpunkt dieses Schreibens ist der einzige öffentliche Endpunkt, der
bestätigt von Anfang bis Ende funktioniert, `https://vefsafn.is/cdx` (Landsbókasafns isländisches Web-
Archiv, pywb-Dialekt). Zwei Dinge sind darüber zu wissen: Er ignoriert `limit`, `page`
und `showNumPages` und gibt für jede Abfrage die vollständige Ergebnismenge zurück, was
urx handhabt; und nach einer Handvoll Anfragen kann er beginnen, mit einer
Bot-Schutzseite im Anubis-Stil zu antworten („Session Verification"). urx erkennt eine HTML-
Antwort anstelle von CDX-Zeilen und meldet sie als Provider-Fehler unter Nennung des
Endpunkts — sie wird niemals als „no URLs" gezählt. Wenn Sie darauf stoßen, verlangsamen Sie mit
`--rate-limit-by cdx:vefsafn.is=1` oder versuchen Sie es später erneut.

**Bekanntlich nicht funktionierend.** Das UK Web Archive (`webarchive.org.uk`), das Webarchiv der Library of
Congress (`webarchive.loc.gov`), die Bibliotheca Alexandrina und die
National Library of Australia (`web.archive.org.au`) befinden sich alle hinter Bot-
Schutz oder Weiterleitungen, die ihre CDX-APIs von einem Kommandozeilen-Client aus blockieren.
urx versucht nicht, das zu umgehen, sodass das Richten von `--cdx-endpoint` auf sie den
oben genannten HTML-Antwort-Fehler ergibt.

### Caching und inkrementelles Scannen

Urx unterstützt Caching, um die Leistung bei wiederholten Scans zu verbessern, sowie inkrementelles Scannen, um nur neue URLs zu entdecken.```bash
# Enable caching with SQLite (default)
urx example.com --cache-type sqlite --cache-path ~/.urx/cache.db

# Use Redis for distributed caching
urx example.com --cache-type redis --redis-url redis://localhost:6379

# Incremental scanning - only show new URLs since last scan
urx example.com --incremental

# Set cache TTL (time-to-live) to 12 hours
urx example.com --cache-ttl 43200

# Disable caching entirely
urx example.com --no-cache

# Combine incremental scanning with filters
urx example.com --incremental -e js,php --patterns api

# Configuration file with caching settings
urx -c example/config.toml example.com

Domain-Abgleich ist unabhängig von Groß-/Kleinschreibung und **exakt**, es sei denn, das Muster enthält
`*` — ein Teilstring-Standard hätte zugelassen, dass `drop example.com` auch
`notexample.com` entfernt. `clear` fragt vor dem Löschen nach und verweigert
eine nicht-interaktive stdin, anstatt eine Antwort anzunehmen, `drop` benennt jedes Muster,
das nichts getroffen hat, das Betrachten des Caches erstellt nie einen, und Redis wird
mit `SCAN` durchsucht statt mit dem blockierenden `KEYS` (wobei jedes Passwort in `--redis-url`
vor der Ausgabe redigiert wird).

#### Caching-Anwendungsfälle```bash
# Daily monitoring - only alert on new URLs (built-in webhook, see below)
urx target.com --incremental --silent --notify https://hooks.slack.com/services/... --notify-format slack

# ...or hand the new URLs to an external notifier
urx target.com --incremental --silent | notify-tool

# Efficient domain lists processing
cat domains.txt | urx --incremental --cache-ttl 3600 > new_urls.txt

# Distributed team scanning with Redis
urx example.com --cache-type redis --redis-url redis://shared-cache:6379

# Fast re-scans during development
urx test-domain.com --cache-ttl 300  # 5-minute cache for rapid iterations

- `--notify-on` ist standardmäßig `new`: Es wird nichts gesendet, wenn der Lauf null
  URLs ausgibt, sodass ein ruhiger Cron-Lauf ruhig bleibt. `always` sendet unabhängig davon; `never`
  behält die Konfiguration bei, deaktiviert aber das Senden.
- `--notify-format json` (Standard) sendet das Schema von urx: `domains`,
  `incremental`, `url_count`, `new_url_count`, `elapsed_ms`, eine `providers`-Liste
  pro Provider (dieselben Zahlen, die `--stats` ausgibt), und ein `sample` von bis zu
  20 ausgegebenen URLs mit gesetztem `sample_truncated`, wenn mehr gefunden wurden.
  `slack` sendet `{"text": ...}` und `discord` sendet `{"content": ...}` mit einer
  kurzen, für Menschen lesbaren Nachricht; Nachrichten, die länger sind als der Dienst erlaubt, werden
  an einer Zeilengrenze abgeschnitten und enden mit `[truncated: N lines cut ...]`.
- Die Zustellung ändert niemals den Exit-Code. Die URLs stehen bereits auf stdout oder in
  `--output`, wenn der Webhook aufgerufen wird, sodass ein toter Webhook eine Warnung
  auf stderr ist und der Lauf trotzdem mit 0 endet. `--verbose` zeigt den Antwortstatus.
- Die Webhook-URL ist ein Credential. urx gibt niemals mehr als ihr Schema und
  ihren Host aus — nicht in `--verbose`, nicht in Warnungen, nicht in `--stats`. Um sie aus
  einer eingecheckten Konfiguration herauszuhalten, lege sie in `URX_NOTIFY_URL` oder als
  `notify_url` in der Provider-Konfigurationsdatei ab; `[notify].url` in der Hauptkonfiguration
  funktioniert ebenfalls. Die Priorität ist CLI/Env > Provider-Konfiguration > Hauptkonfiguration.
- Die Anfrage berücksichtigt `--proxy`, `--proxy-auth`, `--timeout` und `--insecure`.
  `--network-scope` gilt nicht: Es partitioniert den Verkehr, der auf das Ziel
  und die Archive gerichtet ist, und der Webhook ist dein eigener Endpunkt.
- `--silent` sendet trotzdem (das ist der Hauptanwendungsfall); es verbirgt nur die
  Diagnosen.

## Integration mit anderen Tools

Urx funktioniert gut in Pipelines mit anderen Sicherheits- und Reconnaissance-Tools:```bash
# Find domains, then discover URLs
echo "example.com" | urx | grep "login" > potential_targets.txt

# Combine with other tools
cat domains.txt | urx --patterns api | other-tool