`--extract-links` lit chaque balise porteuse d'URL, pas seulement les ancres : `<a href>`,
`<script src>`, `<link href>`, `<form action>`, ``, ``,
`<source src>`, `<object data>`, `<embed src>`, et les cibles `<meta http-equiv="refresh">`.
Les URL relatives sont résolues par rapport à la page (en respectant `<base href>`),
les doublons sont fusionnés, et les liens découverts passent par les mêmes filtres
et la même validation d'hôte que le reste de l'exécution. Voir
[docs/content/guide/cli-options.md](https://github.com/hahwul/urx/blob/main/docs/content/guide/cli-options.md) pour le
tableau complet.

`--extract-js-endpoints` va plus loin et lit le JavaScript
lui-même : chaque URL collectée qui ressemble à un script est récupérée et ses
littéraux de chaîne sont exploités pour les chemins et URL que l'application appelle —
`fetch("/api/v2/users")`, `axios.post("/graphql")`, le préfixe statique de
`` `/api/orders/${id}` ``. Ce sont les endpoints qui n'apparaissent jamais dans le HTML.
La sortie est agressivement dé-bruitée (types MIME, spécificateurs de module, base64,
valeurs CSS, fragments de regex et plus encore sont supprimés), chaque corps est plafonné à
10 MiB, le nombre de fichiers récupérés est limité par `--max-js-files`, et les
endpoints découverts passent par les mêmes filtres et la même validation d'hôte que tout le
reste. La politique complète d'extraction et de suppression du bruit se trouve dans
[docs/content/guide/cli-options.md](https://github.com/hahwul/urx/blob/main/docs/content/guide/cli-options.md#javascript-endpoint-extraction).

`--archive-body` effectue la même extraction sur les corps que la Wayback Machine
*a stockés* plutôt que sur le site en direct, de sorte qu'une page supprimée il y a des années
fournit encore les liens qu'elle contenait. Voir
[Mining Archived Response Bodies](#mining-archived-response-bodies).

### Exemples```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

Ce n'est pas un filtre appliqué après coup. Un index CDX répond nativement
aux requêtes par préfixe, donc urx envoie `url=example.com/shop*` et l'archive
ne transmet jamais le reste du site sur le réseau — sur une cible volumineuse,
c'est la différence entre quelques centaines de lignes et quelques centaines de
milliers. Les fournisseurs qui ne peuvent pas exprimer un chemin dans leur
requête (OTX, VirusTotal, urlscan, GitHub, BeVigil, ZoomEye) sont interrogés sur
l'hôte et leurs réponses sont restreintes ensuite, tout comme les résultats
d'une exécution `--subs`, où la forme `*.host` et un préfixe de chemin ne
peuvent pas être combinés dans une seule requête CDX.

La portée signifie *au niveau ou en dessous* du chemin : `/shop` et
`/shop/cart` sont inclus, `/shopping` ne l'est pas. La casse est ignorée, car
un serveur CDX met toute l'URL en minuscules lorsqu'il construit la clé de son
index — `example.com/Shop*` et `example.com/shop*` renvoient les mêmes lignes,
toutes orthographiées en minuscules, donc une vérification sensible à la casse
rejetterait tout ce que l'archive vient de renvoyer. Une chaîne de requête ou un
fragment dans la cible est supprimé — ceux-ci restreignent une requête, pas une
portée.

> Remarque : urx supprimait auparavant le chemin d'une cible, donc
> `urx https://example.com/shop` scannait tout `example.com`. Il scanne
> désormais `/shop`. Passez uniquement l'hôte pour l'ancien comportement ; une
> exécution dont la cible porte un chemin le signale sur stderr.

### Filtrage par expression régulière

`--patterns` / `--exclude-patterns` sont de simples tests de sous-chaîne : les
deux côtés sont mis en minuscules, et chaque métacaractère est littéral.
`--match-regex` / `--filter-regex` sont les équivalents regex, et ils diffèrent
de trois manières qu'il vaut la peine de retenir :

| | `--patterns` | `--match-regex` |
|---|---|---|
| Correspondance | sous-chaîne | [syntaxe regex](https://docs.rs/regex/latest/regex/#syntax) complète |
| Casse | insensible (les deux côtés en minuscules) | **sensible** — utilisez `(?i)` pour désactiver |
| Valeurs multiples | un seul flag séparé par des virgules | répétez le flag ; les virgules ne sont jamais découpées |

Les deux flags regex sont évalués contre la **chaîne d'URL complète** telle que
collectée (schéma, hôte, chemin et requête), donc `^https://` et `\.js$`
fonctionnent tous les deux. L'exclusion l'emporte : une URL correspondant à
`--filter-regex` est rejetée même si `--match-regex` y correspondait aussi. Une
expression malformée fait échouer l'exécution au démarrage, avant que toute
archive ne soit interrogée.

### Fichiers de portée

La portée d'un programme de bug bounty est une liste d'hôtes, et chaque
plateforme l'écrit de la même manière. `--scope-file` prend cette liste
textuellement au lieu de vous obliger à la traduire à la main en alternances
regex ancrées — où une erreur d'ancrage *élargit* silencieusement la portée au
lieu d'échouer.```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` correspond à l'apex ainsi qu'à tout ce qui se trouve en dessous (la lecture bug-bounty, ce que signifie la table de périmètre d'une plateforme) ; un hôte nu correspond exactement à cet hôte ; un `*` seul fait du fichier une pure deny-list ; les exclusions l'emportent toujours ; `#` démarre un commentaire. Tout ce qu'urx ne peut pas honorer — un port, un chemin, un joker au milieu — est une erreur au démarrage nommant le fichier et la ligne plutôt qu'un périmètre silencieusement plus large. Le filtre s'applique à chaque fournisseur et aux liens extraits, et il se combine avec `--strict` plutôt que de le remplacer, donc une ligne de périmètre `*.example.com` nécessite toujours `--subs`.

### Filtres de métadonnées d'archive

`--from`/`--to` et les prédicats `--archive-*` sont poussés dans la requête propre à l'archive, ce qui les rend gratuits et les limite aussi aux fournisseurs adossés à CDX — et les deux dialectes CDX divergent suffisamment pour qu'une liste positive multi-valeurs (`--archive-status 200,301`) soit insatisfiable sur les serveurs pywb. Les huit filtres `--meta-*` s'exécutent *après* la collecte, sur un ensemble fusionné de métadonnées de capture par URL, de sorte qu'ils s'appliquent uniformément à chaque fournisseur.```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` réduit les segments de chemin ressemblant à des id à `{id}` exactement comme le fait `--dedup-similar`, et épelle l'endpoint en entier car urx scanne régulièrement plusieurs hôtes en une seule exécution. `--fuzz-placeholder` conserve une URL par signature de paramètre et garde son chemin réel — un `{id}` ne serait pas routé — de sorte que la sortie alimente directement un fuzzer :```bash
urx example.com --fuzz-placeholder FUZZ | ffuf -w - -u FUZZ
urx example.com --fuzz-placeholder FUZZ | dalfox pipe

Les segments qui ressemblent à des données plutôt qu'à des noms de route sont omis, en réutilisant les groupes de test `--dedup-similar` — une wordlist remplie de `4711`, d'UUID, de dates et de jetons de session est pire que pas de wordlist du tout, puisque chacun de ces mots n'existe que sur une seule cible. Un segment dont la racine est un identifiant est également écarté (`article-1234.html`). La casse est préservée : les segments de chemin sont sensibles à la casse sur la plupart des origines, donc mettre en minuscules `WebResource.axd` produirait un mot qui renvoie un 404 partout où il est essayé. L'union doit être prise sur l'ensemble complet, donc le format est batch uniquement.

### Sortie en flux

Par défaut, urx collecte tout, puis filtre, trie et affiche une seule fois. Sur une grande cible, cela signifie aucune sortie tant que l'archive la plus lente n'a pas terminé. `--stream` écrit chaque URL au moment où le fournisseur qui la rapporte répond :```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'

Le streaming (`--stream`) ne rapporte que les URLs. Une URL est affichée dès sa première observation, avant que les captures qui élargiraient sa plage `first_seen`/`last_seen` ne soient arrivées, donc `--show-meta` y est rejeté pour la même raison que `--show-sources`.

Un hit de cache ne porte pas non plus de métadonnées : le cache stocke les URLs, donc un domaine servi depuis le cache rapporte ses URLs sans les champs de capture. Utilisez `--no-cache` (ou attendez l'expiration du TTL) pour une exécution qui les repeuple.

### Métadonnées de réponse en direct

`--check-status` envoie déjà une requête et attend l'en-tête de réponse, donc ce que cet en-tête transporte vient gratuitement : `Location`, `Content-Length` et `Content-Type` sont enregistrés aux côtés du code de statut. Les redirections ne sont toujours jamais suivies, donc un statut rapporté appartient toujours à l'URL qui a été demandée et `location` indique simplement où le 3xx pointait.

`--check-title` ajoute le `<title>` HTML. C'est le seul champ qui n'est pas gratuit — un titre nécessite le corps de la réponse — donc il se trouve derrière son propre drapeau. La lecture est bornée deux fois (au plus 64 KiB, et elle s'arrête à la balise fermante) et entièrement ignorée pour un corps que le serveur a déclaré comme non-HTML, donc une API JSON ou une image ne coûte rien. Le titre est condensé en espaces, décodé des entités et coupé à 200 caractères. `--check-title` implique `--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` est répétable, prend `Name: value`, et un en-tête mal formé arrête l'exécution
plutôt que de passer inaperçu — un argument silencieusement abandonné laisse
un scan anonyme se lire comme un scan authentifié. `--cookie` et
`--user-agent` sont des raccourcis pour les en-têtes correspondants.

**Ces en-têtes n'atteignent jamais une archive.** Ils ne sont envoyés que par les composants
qui communiquent avec la cible : les quatre testeurs ci-dessus, plus les fournisseurs `robots` et
`sitemap`, qui récupèrent aussi depuis la cible. Tous les autres fournisseurs
interrogent web.archive.org, index.commoncrawl.org ou une API tierce, et il en va de même
pour `--archive-body` lorsqu'il rejoue une capture ; leur transmettre le cookie de session de la cible
reviendrait à envoyer un identifiant à un service qui conserve ce qu'il
reçoit, sans aucun bénéfice. Les requêtes d'archive conservent le User-Agent propre à urx, que
`--random-agent` fait toujours tourner.

### Extraction des corps de réponse archivés

`--extract-links` récupère chaque URL collectée depuis le site en direct, ce qui est
exactement le mauvais endroit pour chercher les pages qui intéressent le plus une campagne OSINT :
celles qui n'existent plus. `--archive-body` récupère à la place les corps que la Wayback
Machine a stockés. Pour chaque URL collectée portant un horodatage de capture, urx rejoue
cette capture sous sa forme brute
(`https://web.archive.org/web/<timestamp>id_/<url>` — le drapeau `id_` désactive la
barre d'outils Wayback et la réécriture des liens, de sorte que le corps correspond aux octets d'origine) et
exécute la même extraction de liens que celle utilisée par `--extract-links` sur celui-ci.```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

**Conserver les corps.** Les requêtes sont déjà effectuées, donc écrire les corps sur disque ne coûte rien de plus et répond aux questions qu'aucun extracteur de liens ne pose : le commentaire `<!-- staging.internal -->`, le jeton qu'un build de 2019 a intégré, la trace de pile nommant une version de framework.```bash
urx example.com --archive-body --archive-body-dir ./corpus
grep -ri "api[_-]key" ./corpus

Ce qui est développé :

* **OpenAPI 3.x** — `servers[].url` (absolu, relatif au document et templatisé,
  avec `{var}` résolu depuis `variables[var].default` ou la première valeur de `enum`)
  croisé avec chaque clé de `paths` ; les `servers` propres à un élément de chemin
  remplacent ceux du document.
* **Swagger 2.0** — `schemes` × `host` + `basePath`, chaque partie se rabattant sur
  la partie correspondante de l'URL du document lui-même. `ws`/`wss` sont abandonnés.
* **Introspection GraphQL** — une URL par champ de requête, de mutation et
  d'abonnement, écrite comme le point de terminaison plus `?query=…`. Un schéma
  enregistré sous forme de fichier se résout vers son point de terminaison
  (`/graphql/schema.json` → `/graphql`).

JSON et YAML sont tous deux lus. Les cibles sont choisies d'abord par nom et
gratuitement (une sous-chaîne marqueur de spécification — `swagger`, `openapi`,
`api-docs`, `graphql`, `introspection` — plus une extension `json`/`yaml`/`yml`
lorsqu'il y en a une, de sorte que `swagger-ui.html` ne coûte aucune requête),
puis par le `Content-Type` de la réponse. Les modèles de chemin sont émis tels
que le document les écrit (`/users/{id}`, et non `/users/%7Bid%7D`). Les corps
sont plafonnés à 10 MiB, et un document YAML comportant plus de 32 références
d'alias est refusé avant l'analyse pour écarter les bombes d'expansion.
`--max-spec-files` (par défaut 50) borne les documents récupérés. Avec
`--archive-body` également activé, une spécification archivée est lue comme
telle sans coût de requête supplémentaire — le corps était déjà en cours de
récupération.

### robots.txt et sitemap.xml archivés

Les fournisseurs `robots` et `sitemap` lisent les fichiers *actuels*, qui ne
disent que ce qu'un site cache ou liste aujourd'hui. `--archived-discovery` lit
aussi chaque version distincte de ces fichiers que la Wayback Machine a
stockée. Un `Disallow:` de 2015 nomme des chemins que le site a cessé de
mentionner depuis — souvent parce qu'ils étaient censés être oubliés, non parce
qu'ils ont disparu — et un ancien sitemap liste tout ce que le site voulait
autrefois voir exploré.```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

* L'identifiant du fournisseur est `cdx:<host>` (`cdx:vefsafn.is`), ce que
  `--exclude-providers`, `--rate-limit-by`, `--stats` et `--show-sources` utilisent.
  Nommer un endpoint l'active ; aucune entrée `--providers` n'est nécessaire, et
  `--providers cdx:vefsafn.is` l'exécute seul. `--list-providers` affiche les
  endpoints nommés sur la même ligne de commande avec les ids sous lesquels ils s'exécuteront.
* Tout ce que les fournisseurs CDX intégrés respectent s'applique ici aussi : `--subs`,
  `--from`/`--to`, les filtres `--archive-*`, la pagination, `--rate-limit`, et
  les métadonnées de capture décrites ci-dessus.
* `--cdx-dialect classic|pywb` nomme le dialecte du serveur (noms de champs, sémantique des filtres,
  format des lignes et schéma de pagination en découlent tous — voir
  « Filtrage côté archive »). Non défini, urx sonde l'endpoint une fois par exécution
  et se rabat sur `pywb`, le dialecte le plus courant ; définissez-le explicitement lorsque la
  sonde ne peut pas le déterminer (une réponse vide pour un domaine inconnu, par exemple).
* Peut aussi être défini dans le fichier de configuration (`cdx_endpoint = [...]`, `cdx_dialect`).

**Endpoints vérifiés.** À l'heure où nous écrivons, le seul endpoint public confirmé
fonctionner à bout en bout est `https://vefsafn.is/cdx` (l'archive web islandaise de Landsbókasafn, dialecte pywb). Deux choses à savoir à son sujet : il ignore `limit`, `page`
et `showNumPages` et renvoie l'ensemble complet des résultats pour chaque requête, ce que
urx gère ; et après une poignée de requêtes, il peut commencer à répondre avec une
page de protection anti-bot de style Anubis (« Session Verification »). urx détecte une réponse HTML
à la place des lignes CDX et la signale comme une erreur de fournisseur nommant
l'endpoint — elle n'est jamais comptée comme « aucune URL ». Si vous la rencontrez, ralentissez avec
`--rate-limit-by cdx:vefsafn.is=1` ou réessayez plus tard.

**Connus pour ne pas fonctionner.** Le UK Web Archive (`webarchive.org.uk`), l'archive web de la Library of
Congress (`webarchive.loc.gov`), Bibliotheca Alexandrina, et la
National Library of Australia (`web.archive.org.au`) se trouvent tous derrière une protection anti-bot ou des redirections qui bloquent leurs API CDX depuis un client en ligne de commande.
urx ne tente pas de contourner cela, donc pointer `--cdx-endpoint` vers eux
produit l'erreur de réponse HTML ci-dessus.

### Mise en cache et analyse incrémentale

Urx prend en charge la mise en cache pour améliorer les performances des analyses répétées et l'analyse incrémentale pour ne découvrir que les nouvelles URL.```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

La correspondance de domaine est insensible à la casse et **exacte**, sauf si le motif contient
`*` — une correspondance par sous-chaîne par défaut aurait permis à `drop example.com` de supprimer
`notexample.com` également. `clear` demande confirmation avant de supprimer et refuse un
stdin non interactif plutôt que de supposer une réponse, `drop` nomme tout motif
qui n'a rien matché, consulter le cache n'en crée jamais, et Redis est parcouru
avec `SCAN` plutôt que le bloquant `KEYS` (avec tout mot de passe dans `--redis-url`
masqué avant d'être affiché).

#### Cas d'usage du cache```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` vaut `new` par défaut : rien n'est envoyé lorsque l'exécution n'émet aucune URL, donc une exécution cron silencieuse reste silencieuse. `always` envoie dans tous les cas ; `never` conserve la configuration mais désactive l'envoi.
- `--notify-format json` (par défaut) envoie le schéma d'urx : `domains`, `incremental`, `url_count`, `new_url_count`, `elapsed_ms`, une liste `providers` par fournisseur (les mêmes chiffres que ceux affichés par `--stats`), et un `sample` allant jusqu'à 20 URLs émises avec `sample_truncated` défini lorsque davantage ont été trouvées. `slack` envoie `{"text": ...}` et `discord` envoie `{"content": ...}` avec un court message lisible par un humain ; les messages plus longs que ce que le service autorise sont coupés sur une limite de ligne et se terminent par `[truncated: N lines cut ...]`.
- La livraison ne modifie jamais le code de sortie. Les URLs sont déjà sur stdout ou dans `--output` au moment où le webhook est appelé, donc un webhook mort est un avertissement sur stderr et l'exécution se termine quand même avec le code 0. `--verbose` affiche le statut de la réponse.
- L'URL du webhook est un identifiant. urx n'affiche jamais plus que son schéma et son hôte — ni dans `--verbose`, ni dans les avertissements, ni dans `--stats`. Pour la garder hors d'une configuration versionnée, placez-la dans `URX_NOTIFY_URL` ou comme `notify_url` dans le fichier de configuration du fournisseur ; `[notify].url` dans la configuration principale fonctionne aussi. La priorité est CLI/env > configuration du fournisseur > configuration principale.
- La requête respecte `--proxy`, `--proxy-auth`, `--timeout` et `--insecure`. `--network-scope` ne s'applique pas : il partitionne le trafic destiné à la cible et aux archives, et le webhook est votre propre point de terminaison.
- `--silent` envoie quand même (c'est le cas d'usage principal) ; il ne fait que masquer les diagnostics.

## Intégration avec d'autres outils

Urx fonctionne bien dans des pipelines avec d'autres outils de sécurité et de reconnaissance :```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