`--extract-links` читает каждый тег, содержащий URL, а не только якоря: `<a href>`,
`<script src>`, `<link href>`, `<form action>`, ``, ``,
`<source src>`, `<object data>`, `<embed src>` и цели
`<meta http-equiv="refresh">`. Относительные URL разрешаются относительно страницы (с учётом `<base href>`),
дубликаты схлопываются, а обнаруженные ссылки проходят через те же фильтры
и проверку хоста, что и остальная часть запуска. Полную таблицу см. в
[docs/content/guide/cli-options.md](https://github.com/hahwul/urx/blob/main/docs/content/guide/cli-options.md).

`--extract-js-endpoints` идёт на шаг дальше и читает сам JavaScript:
каждый собранный URL, похожий на скрипт, загружается, и его
строковые литералы анализируются на предмет путей и URL, которые вызывает приложение —
`fetch("/api/v2/users")`, `axios.post("/graphql")`, статический префикс
`` `/api/orders/${id}` ``. Это эндпоинты, которые никогда не появляются в HTML.
Вывод агрессивно очищается от шума (MIME-типы, спецификаторы модулей, base64,
значения CSS, фрагменты регулярных выражений и многое другое отбрасываются), каждое тело ограничено
10 MiB, количество загружаемых файлов ограничено `--max-js-files`, а
обнаруженные эндпоинты проходят те же фильтры и проверку хоста, что и всё
остальное. Полная политика извлечения и подавления шума приведена в
[docs/content/guide/cli-options.md](https://github.com/hahwul/urx/blob/main/docs/content/guide/cli-options.md#javascript-endpoint-extraction).

`--archive-body` выполняет ту же извлекающую обработку над телами, которые Wayback Machine
*сохранила*, а не над живым сайтом, поэтому страница, удалённая годы назад,
всё ещё выдаёт содержавшиеся в ней ссылки. См.
[Mining Archived Response Bodies](#mining-archived-response-bodies).

### Примеры```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

Это не фильтр, применяемый постфактум. Индекс CDX обрабатывает префиксные запросы
нативно, поэтому urx отправляет `url=example.com/shop*`, и архив никогда не передаёт
остальную часть сайта по сети — на крупной цели это разница
между несколькими сотнями строк и несколькими сотнями тысяч. Провайдеры, которые не могут
выразить путь в своём запросе (OTX, VirusTotal, urlscan, GitHub, BeVigil,
ZoomEye), опрашиваются по хосту, а их ответы сужаются afterwards, как
и результаты запуска `--subs`, где форма `*.host` и префикс пути
не могут быть объединены в одном запросе CDX.

Область означает *на или под* путём: `/shop` и `/shop/cart` входят, `/shopping`
нет. Регистр игнорируется, потому что сервер CDX приводит весь URL к нижнему регистру, когда
строит свой индексный ключ — `example.com/Shop*` и `example.com/shop*` возвращают
одни и те же строки, все в нижнем регистре, поэтому проверка с учётом регистра выбросила бы
всё, что только что вернул архив. Строка запроса или фрагмент в
цели отбрасываются — они сужают запрос, а не область.

> Примечание: раньше urx отбрасывал путь из цели, поэтому
> `urx https://example.com/shop` сканировал весь `example.com`. Теперь он
> сканирует `/shop`. Передайте только хост для старого поведения; запуск, цель которого
> содержит путь, сообщает об этом в stderr.

### Фильтрация по регулярным выражениям

`--patterns` / `--exclude-patterns` — это простые проверки на подстроку: обе стороны
приводятся к нижнему регистру, и каждый метасимвол является литералом. `--match-regex` /
`--filter-regex` — это аналоги для регулярных выражений, и они отличаются тремя способами, которые стоит
запомнить:

| | `--patterns` | `--match-regex` |
|---|---|---|
| Сопоставление | подстрока | полный [синтаксис regex](https://docs.rs/regex/latest/regex/#syntax) |
| Регистр | нечувствителен (обе стороны в нижнем регистре) | **чувствителен** — используйте `(?i)`, чтобы отключить |
| Несколько значений | один флаг через запятую | повторяйте флаг; запятые никогда не разделяются |

Оба флага regex вычисляются по **всей строке URL** в том виде, в каком она собрана
(схема, хост, путь и запрос), поэтому работают и `^https://`, и `\.js$`.
Исключение имеет приоритет: URL, соответствующий `--filter-regex`, отбрасывается, даже если
`--match-regex` также совпал с ним. Некорректное выражение приводит к сбою запуска при
старте, до обращения к какому-либо архиву.

### Файлы области

Область программы bug bounty — это список хостов, и каждая платформа записывает его
одинаково. `--scope-file` принимает этот список дословно, вместо того чтобы заставлять вас
вручную переводить его в анкорированные чередования regex — где ошибка в
анкорировании молча *расширяет* область, а не приводит к сбою.```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` соответствует как apex-домену, так и всему под ним (трактовка bug-bounty, что и означает таблица scope платформы); голое имя хоста соответствует ровно этому хосту; одинокий `*` превращает файл в чистый deny-list; исключения всегда побеждают; `#` начинает комментарий. Всё, что urx не может обработать — порт, путь, wildcard в середине — это ошибка при запуске с указанием файла и строки, а не молчаливо расширенный scope. Фильтр применяется ко всем провайдерам и к извлечённым ссылкам, и он сочетается с `--strict`, а не заменяет его, поэтому строка scope `*.example.com` всё ещё требует `--subs`.

### Фильтры метаданных архива

`--from`/`--to` и предикаты `--archive-*` передаются в собственный запрос архива, что делает их бесплатными, а также ограничивает их провайдерами на основе CDX — и два диалекта CDX расходятся настолько сильно, что положительный многозначный список (`--archive-status 200,301`) невыполним на серверах pywb. Восемь фильтров `--meta-*` выполняются *после* сбора, по одному объединённому набору метаданных захвата на URL, поэтому они применяются ко всем провайдерам единообразно.```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` сворачивает сегменты пути, похожие на id, в `{id}` точно так же, как это делает `--dedup-similar`, и выводит endpoint полностью, поскольку urx обычно сканирует несколько хостов за один запуск. `--fuzz-placeholder` сохраняет один URL на сигнатуру параметра и оставляет его реальный путь — `{id}` не привёл бы к маршруту — поэтому вывод можно напрямую подавать в фаззер:```bash
urx example.com --fuzz-placeholder FUZZ | ffuf -w - -u FUZZ
urx example.com --fuzz-placeholder FUZZ | dalfox pipe

Сегменты, которые выглядят как данные, а не как имена маршрутов, опускаются, повторно используя
группы теста `--dedup-similar` — список слов, полный `4711`, UUID, дат и
сессионных токенов, хуже, чем отсутствие списка слов, поскольку каждое из этих слов существует
ровно на одной цели. Сегмент, чья основа является идентификатором, также опускается
(`article-1234.html`). Регистр сохраняется: сегменты пути чувствительны к регистру на
большинстве источников, поэтому приведение `WebResource.axd` к нижнему регистру создало бы слово, которое выдаёт 404
везде, где бы оно ни использовалось. Объединение должно быть взято по полному набору, поэтому
формат только пакетный.

### Потоковый вывод

По умолчанию urx собирает всё, затем фильтрует, сортирует и выводит один раз. На
большой цели это означает отсутствие вывода до тех пор, пока не завершится самый медленный архив.
`--stream` записывает каждый URL в момент, когда провайдер, сообщивший о нём, возвращается:```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'

Потоковая передача (`--stream`) сообщает только URL-адреса. URL-адрес выводится при первом обнаружении, до того как поступят захваты, которые расширили бы его диапазон `first_seen`/`last_seen`, поэтому `--show-meta` отклоняется там по той же причине, что и `--show-sources`.

Попадание в кэш также не несёт метаданных: кэш хранит URL-адреса, поэтому домен, обслуженный из кэша, сообщает свои URL-адреса без полей захвата. Используйте `--no-cache` (или дождитесь истечения TTL) для запуска, который их перезаполнит.

### Метаданные живого ответа

`--check-status` уже отправляет запрос и ожидает заголовок ответа, поэтому то, что несёт этот заголовок, достаётся бесплатно: `Location`, `Content-Length` и `Content-Type` записываются вместе с кодом состояния. Перенаправления по-прежнему никогда не отслеживаются, поэтому сообщаемый статус всегда принадлежит запрошенному URL-адресу, а `location` просто указывает, куда вёл 3xx.

`--check-title` добавляет HTML `<title>`. Это единственное поле, которое не бесплатно — для заголовка нужно тело ответа — поэтому оно находится за собственным флагом. Чтение ограничено дважды (не более 64 КиБ, и оно останавливается на закрывающем теге) и полностью пропускается для тела, которое сервер объявил как не-HTML, поэтому JSON API или изображение ничего не стоят. Заголовок сжимается по пробелам, декодируется сущности и обрезается до 200 символов. `--check-title` подразумевает `--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` можно указывать повторно, принимает `Name: value`, и некорректный заголовок останавливает запуск, а не проходит незамеченным — аргумент, который молча отбрасывается, оставляет анонимное сканирование выглядящим как аутентифицированное. `--cookie` и `--user-agent` — это сокращения для соответствующих заголовков.

**Эти заголовки никогда не достигают архива.** Они отправляются только теми компонентами, которые общаются с целью: четырьмя тестерами выше, а также провайдерами `robots` и `sitemap`, которые тоже загружают данные с цели. Все остальные провайдеры запрашивают web.archive.org, index.commoncrawl.org или сторонний API, и то же самое делает `--archive-body`, когда воспроизводит захват; передача им сессионного cookie цели означала бы отправку учётных данных сервису, который сохраняет всё полученное, без какой-либо выгоды. Запросы к архивам сохраняют собственный User-Agent urx, который `--random-agent` по-прежнему ротирует.

### Извлечение тел ответов из архива

`--extract-links` загружает каждый собранный URL с живого сайта, что как раз является неправильным местом для поиска страниц, которые наиболее важны при OSINT-разведке: тех, которых больше не существует. `--archive-body` вместо этого загружает тела, сохранённые Wayback Machine. Для каждого собранного URL, несущего метку времени захвата, urx воспроизводит этот захват в его исходной форме
(`https://web.archive.org/web/<timestamp>id_/<url>` — флаг `id_` отключает панель инструментов Wayback и перезапись ссылок, так что тело представляет собой исходные байты) и запускает по нему то же извлечение ссылок, которое использует `--extract-links`.```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

**Сохранение тел.** Запросы уже выполняются, поэтому запись тел на диск не требует дополнительных затрат и отвечает на вопросы, которые не задаёт ни один извлекатель ссылок: комментарий `<!-- staging.internal -->`, токен, встроенный сборкой 2019 года, трассировка стека с указанием версии фреймворка.```bash
urx example.com --archive-body --archive-body-dir ./corpus
grep -ri "api[_-]key" ./corpus

Что разворачивается:

* **OpenAPI 3.x** — `servers[].url` (абсолютный, относительно документа и шаблонный,
  с `{var}`, разрешаемым из `variables[var].default` или первого значения `enum`)
  в сочетании с каждым ключом `paths`; собственные `servers` элемента пути
  переопределяют серверы документа.
* **Swagger 2.0** — `schemes` × `host` + `basePath`, каждая часть откатывается к
  соответствующей части URL самого документа. `ws`/`wss` отбрасываются.
* **Интроспекция GraphQL** — один URL на каждое поле query, mutation и subscription,
  записываемый как эндпоинт плюс `?query=…`. Схема, сохранённая в файл,
  разрешается в свой эндпоинт (`/graphql/schema.json` → `/graphql`).

JSON и YAML читаются оба. Цели выбираются сначала по имени и бесплатно (подстрока
маркера спецификации — `swagger`, `openapi`, `api-docs`, `graphql`,
`introspection` — плюс расширение `json`/`yaml`/`yml`, когда оно есть, так что
`swagger-ui.html` не стоит ни одного запроса), затем по `Content-Type` ответа.
Шаблоны путей выводятся так, как их записывает документ (`/users/{id}`, а не
`/users/%7Bid%7D`). Тела ограничены 10 MiB, а YAML-документ с более
чем 32 ссылками-алиасами отклоняется до разбора, чтобы исключить бомбы
разворачивания. `--max-spec-files` (по умолчанию 50) ограничивает число
загружаемых документов. При также включённом `--archive-body` архивная
спецификация читается как одна без дополнительных затрат на запрос — тело уже
было загружено.

### Архивные robots.txt и sitemap.xml

Провайдеры `robots` и `sitemap` читают *живые* файлы, которые говорят лишь о том,
что сайт скрывает или перечисляет сегодня. `--archived-discovery` также читает
каждую отдельную версию этих файлов, сохранённую Wayback Machine. `Disallow:`
от 2015 года называет пути, о которых сайт с тех пор перестал упоминать — часто
потому, что их хотели забыть, а не потому, что они исчезли, — а старый sitemap
перечисляет всё, что сайт когда-то хотел обойти сканером.```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

* Идентификатор провайдера — `cdx:<host>` (`cdx:vefsafn.is`), именно его используют
  `--exclude-providers`, `--rate-limit-by`, `--stats` и `--show-sources`.
  Указание эндпоинта включает его; запись в `--providers` не требуется, а
  `--providers cdx:vefsafn.is` запускает его отдельно. `--list-providers` показывает
  эндпоинты, указанные в той же командной строке, с идентификаторами, под которыми они будут запущены.
* Всё, что поддерживают встроенные CDX-провайдеры, действует и здесь: `--subs`,
  `--from`/`--to`, фильтры `--archive-*`, пагинация, `--rate-limit` и
  описанные выше метаданные захвата.
* `--cdx-dialect classic|pywb` задаёт диалект сервера (имена полей, семантика фильтров,
  формат строк и схема пагинации следуют из него — см. «Archive-side Filtering»). Если не задан,
  urx один раз за запуск опрашивает эндпоинт и откатывается к `pywb`, более распространённому
  диалекту; задавайте его явно, когда проба не может определить (например, пустой ответ для
  неизвестного домена).
* Также можно задать в файле конфигурации (`cdx_endpoint = [...]`, `cdx_dialect`).

**Проверенные эндпоинты.** На момент написания единственный публичный эндпоинт, подтверждённо
работающий от начала до конца, — `https://vefsafn.is/cdx` (исландский веб-архив
Landsbókasafn, диалект pywb). О нём нужно знать две вещи: он игнорирует `limit`, `page`
и `showNumPages` и возвращает полный набор результатов для каждого запроса, что
urx обрабатывает; и после нескольких запросов он может начать отвечать
страницей бот-защиты в стиле Anubis («Session Verification»). urx обнаруживает HTML-ответ
вместо строк CDX и сообщает о нём как об ошибке провайдера с указанием
эндпоинта — это никогда не засчитывается как «нет URL». Если вы с этим столкнулись, замедлитесь с
`--rate-limit-by cdx:vefsafn.is=1` или повторите попытку позже.

**Известно, что не работает.** UK Web Archive (`webarchive.org.uk`), веб-архив Библиотеки
Конгресса (`webarchive.loc.gov`), Bibliotheca Alexandrina и
Национальная библиотека Австралии (`web.archive.org.au`) — все они находятся за бот-защитой
или перенаправлениями, которые блокируют их CDX API для клиента командной строки.
urx не пытается это обойти, поэтому указание `--cdx-endpoint` на них
даёт ошибку HTML-ответа, описанную выше.

### Кэширование и инкрементальное сканирование

Urx поддерживает кэширование для повышения производительности при повторных сканированиях и инкрементальное сканирование для обнаружения только новых 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

Сопоставление доменов нечувствительно к регистру и **точное**, если только шаблон не содержит
`*` — сопоставление по подстроке по умолчанию позволило бы `drop example.com` удалить
`notexample.com` тоже. `clear` спрашивает перед удалением и отказывается работать с
неинтерактивным stdin, вместо того чтобы предполагать ответ, `drop` называет любой шаблон,
который ничему не соответствовал, просмотр кэша никогда его не создаёт, а Redis очищается
с помощью `SCAN`, а не блокирующей `KEYS` (при этом любой пароль в `--redis-url`
редактируется перед выводом).

#### Сценарии использования кэширования```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` по умолчанию имеет значение `new`: ничего не отправляется, когда запуск выдаёт ноль
  URL-адресов, поэтому тихий запуск cron остаётся тихим. `always` отправляет в любом случае; `never`
  сохраняет конфигурацию, но отключает отправку.
- `--notify-format json` (по умолчанию) отправляет схему urx: `domains`,
  `incremental`, `url_count`, `new_url_count`, `elapsed_ms`, список `providers`
  по каждому провайдеру (те же числа, что выводит `--stats`), и `sample` из не более
  чем 20 выданных URL-адресов с установленным `sample_truncated`, когда найдено больше.
  `slack` отправляет `{"text": ...}`, а `discord` отправляет `{"content": ...}` с
  коротким человекочитаемым сообщением; сообщения длиннее, чем допускает сервис,
  обрезаются по границе строки и заканчиваются на `[truncated: N lines cut ...]`.
- Доставка никогда не изменяет код выхода. URL-адреса уже находятся в stdout или в
  `--output` к моменту вызова webhook, поэтому неработающий webhook — это предупреждение
  в stderr, и запуск всё равно завершается с кодом 0. `--verbose` показывает статус ответа.
- URL webhook — это учётные данные. urx никогда не выводит больше, чем его схему и
  хост — ни в `--verbose`, ни в предупреждениях, ни в `--stats`. Чтобы не хранить его
  в конфиге, который попадает в систему контроля версий, поместите его в `URX_NOTIFY_URL` или как
  `notify_url` в файле конфигурации провайдера; `[notify].url` в основном конфиге
  тоже работает. Приоритет: CLI/env > конфигурация провайдера > основной конфиг.
- Запрос учитывает `--proxy`, `--proxy-auth`, `--timeout` и `--insecure`.
  `--network-scope` не применяется: он разделяет трафик, направленный на цель
  и архивы, а webhook — это ваша собственная конечная точка.
- `--silent` всё равно отправляет (это основной вариант использования); он только скрывает
  диагностику.

## Интеграция с другими инструментами

Urx хорошо работает в конвейерах с другими инструментами безопасности и разведки:```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