**Weitere Optionen zum Installieren / Ausführen von katana-**

<details>
  <summary>Docker</summary>

> Zum Installieren / Aktualisieren von docker auf den neuesten Tag -```sh
docker pull projectdiscovery/katana:latest

> Um katana im Headless-Modus mit Docker auszuführen -```sh
docker run projectdiscovery/katana:latest -u https://tesla.com -system-chrome -headless

Dies wird die Hilfe für das Tool anzeigen. Hier sind alle unterstützten Schalter.```console
Katana is a fast crawler focused on execution in automation
pipelines offering both headless and non-headless crawling.

Usage:
  ./katana [flags]

Flags:
INPUT:
   -u, -list string[]     target url / list to crawl
   -resume string         resume scan using resume.cfg
   -e, -exclude string[]  exclude host matching specified filter ('cdn', 'private-ips', cidr, ip, regex)

CONFIGURATION:
   -r, -resolvers string[]       list of custom resolver (file or comma separated)
   -d, -depth int                maximum depth to crawl (default 3)
   -jc, -js-crawl                enable endpoint parsing / crawling in javascript file
   -jsl, -jsluice                enable jsluice parsing in javascript file (memory intensive)
   -ct, -crawl-duration value    maximum duration to crawl the target for (s, m, h, d) (default s)
   -kf, -known-files string      enable crawling of known files (all,robotstxt,sitemapxml), a minimum depth of 3 is required to ensure all known files are properly crawled.
   -mrs, -max-response-size int  maximum response size to read (default 4194304)
   -timeout int                  time to wait for request in seconds (default 10)
   -aff, -automatic-form-fill    enable automatic form filling (experimental)
   -fx, -form-extraction         extract form, input, textarea & select elements in jsonl output
   -retry int                    number of times to retry the request (default 1)
   -proxy string                 http/socks5 proxy to use
   -td, -tech-detect             enable technology detection
   -H, -headers string[]         custom header/cookie to include in all http request in header:value format (file)
   -config string                path to the katana configuration file
   -fc, -form-config string      path to custom form configuration file
   -flc, -field-config string    path to custom field configuration file
   -s, -strategy string          Visit strategy (depth-first, breadth-first) (default "depth-first")
   -iqp, -ignore-query-params    Ignore crawling same path with different query-param values
   -fsu, -filter-similar         filter crawling of similar looking URLs (e.g., /users/123 and /users/456)
   -fst, -filter-similar-threshold int  number of distinct values before a path position is treated as parameter (default 10)
   -tlsi, -tls-impersonate       enable experimental client hello (ja3) tls randomization
   -dr, -disable-redirects       disable following redirects (default false)
   -kb, -knowledge-base          enable knowledge base classification
   -kb-secrets                   enable secrets extractor in the knowledge base
   -kb-validate-secrets          validate detected secrets against their provider (sends live API calls)
   -kb-endpoints                 enable endpoints extractor (classifies REST/GraphQL/SOAP/XHR requests)
   -mdp, -max-domain-pages int   maximum number of pages to crawl per domain (default unlimited)

DEBUG:
   -health-check, -hc        run diagnostic check up
   -elog, -error-log string  file to write sent requests error log
   -pprof-server             enable pprof server

HEADLESS:
   -hl, -headless                    enable headless hybrid crawling (experimental)
   -sc, -system-chrome               use local installed chrome browser instead of katana installed
   -sb, -show-browser                show the browser on the screen with headless mode
   -ho, -headless-options string[]   start headless chrome with additional options
   -nos, -no-sandbox                 start headless chrome in --no-sandbox mode
   -cdd, -chrome-data-dir string     path to store chrome browser data
   -scp, -system-chrome-path string  use specified chrome browser for headless crawling
   -noi, -no-incognito               start headless chrome without incognito mode
   -cwu, -chrome-ws-url string       use chrome browser instance launched elsewhere with the debugger listening at this URL
   -xhr, -xhr-extraction             extract xhr request url,method in jsonl output
   -pls, -page-load-strategy string  page load strategy (heuristic, load, domcontentloaded, networkidle, none) (default "heuristic")
   -dwt, -dom-wait-time int          time in seconds to wait after page load when using domcontentloaded strategy (default 5)
   -csp, -captcha-solver-provider string  captcha solver provider (e.g. capsolver)
   -csk, -captcha-solver-key string       captcha solver provider api key

SCOPE:
   -cs, -crawl-scope string[]       in scope url regex to be followed by crawler
   -cos, -crawl-out-scope string[]  out of scope url regex to be excluded by crawler
   -fs, -field-scope string         pre-defined scope field (dn,rdn,fqdn) or custom regex (e.g., '(company-staging.io|company.com)') (default "rdn")
   -ns, -no-scope                   disables host based default scope
   -do, -display-out-scope          display external endpoint from scoped crawling

FILTER:
   -mr, -match-regex string[]             regex or list of regex to match on output url (cli, file)
   -fr, -filter-regex string[]            regex or list of regex to filter on output url (cli, file)
   -f, -field string                      field to display in output (url,path,fqdn,rdn,rurl,qurl,qpath,file,ufile,key,value,kv,dir,udir) (Deprecated: use -output-template instead)
   -sf, -store-field string               field to store in per-host output (url,path,fqdn,rdn,rurl,qurl,qpath,file,ufile,key,value,kv,dir,udir)
   -em, -extension-match string[]         match output for given extension (eg, -em php,html,js,none)
   -ef, -extension-filter string[]        filter output for given extension (eg, -ef png,css)
   -ndef, -no-default-ext-filter bool     remove default extensions from the filter list
   -mdc, -match-condition string          match response with dsl based condition
   -fdc, -filter-condition string         filter response with dsl based condition
   -duf, -disable-unique-filter           disable duplicate content filtering
   -filter-page-type string[]      filter response with page type (e.g. error,captcha,parked)

RATE-LIMIT:
   -c, -concurrency int          number of concurrent fetchers to use (default 10)
   -p, -parallelism int          number of concurrent inputs to process (default 10)
   -rd, -delay int               request delay between each request in seconds
   -rl, -rate-limit int          maximum requests to send per second (default 150)
   -rlm, -rate-limit-minute int  maximum number of requests to send per minute
   -hrl, -host-rate-limit int    maximum requests to send per second per host
   -hrlm, -host-rate-limit-minute int  maximum number of requests to send per minute per host

UPDATE:
   -up, -update                 update katana to latest version
   -duc, -disable-update-check  disable automatic katana update check

OUTPUT:
   -o, -output string                file to write output to
   -output-template string      custom output template
   -sr, -store-response              store http requests/responses
   -srd, -store-response-dir string  store http requests/responses to custom directory
   -ncb, -no-clobber                 do not overwrite output file
   -sfd, -store-field-dir string     store per-host field to custom directory
   -or, -omit-raw                    omit raw requests/responses from jsonl output
   -ob, -omit-body                   omit response body from jsonl output
   -lof, -list-output-fields         list available fields for jsonl output format
   -eof, -exclude-output-fields      exclude fields from jsonl output
   -j, -jsonl                        write output in jsonl format
   -nc, -no-color                    disable output content coloring (ANSI escape codes)
   -silent                           display output only
   -v, -verbose                      display verbose output
   -debug                            display debug output
   -version                          display project version

#### Mehrere URL-Eingabe (kommagetrennt)```sh
katana -u https://tesla.com,https://google.com

(No content provided for translation.)```
katana -list url_list.txt

- [alpine](https://github.com/projectdiscovery/katana/blob/HEAD/dockerfiles/alpine): Neuester Alpine-Linux-Container mit `curl`, `bash`, `jq` und PyPI-Paketen. (Docker Hub: `phx.ocir.io/oracle/ateam/masscan-kube:alpine-latest`)
- [busybox](https://github.com/projectdiscovery/katana/blob/HEAD/dockerfiles/busybox): Minimales Docker-Image basierend auf busybox:glibc mit den gleichen Werkzeugen wie das Alpine-Image. Wird typischerweise als Init-Container für Netzwerk-sysctl-Tuning verwendet, bevor masscan ausgeführt wird. (Docker Hub: `phx.ocir.io/oracle/ateam/masscan-kube:busybox-latest`)```sh
cat domains | httpx | katana

  projectdiscovery.io

## Crawling-Modus

### Standard-Modus

Die Standard-Crawling-Modalität verwendet unter der Haube die standardmäßige Go-HTTP-Bibliothek zur Verarbeitung von HTTP-Anfragen/-Antworten. Diese Modalität ist viel schneller, da sie keinen Browser-Overhead hat. Dennoch analysiert sie den HTTP-Antworttext so, wie er ist, ohne JavaScript- oder DOM-Rendering, wodurch möglicherweise Endpunkte nach dem DOM-Rendering oder asynchrone Endpunktaufrufe übersehen werden, die in komplexen Webanwendungen in Abhängigkeit von beispielsweise browserspezifischen Ereignissen auftreten können.

### Headless-Modus

Der Headless-Modus hakt interne Headless-Aufrufe ein, um HTTP-Anfragen/-Antworten direkt im Browserkontext zu verarbeiten. Dies bietet zwei Vorteile:
- Der HTTP-Fingerabdruck (TLS und User-Agent) identifiziert den Client vollständig als legitimen Browser
- Bessere Abdeckung, da die Endpunkte durch die Analyse der standardmäßigen Rohantwort (wie im vorherigen Modus) und auch der browser-gerenderten mit aktiviertem JavaScript entdeckt werden.

Headless-Crawling ist optional und kann mit der Option `-headless` aktiviert werden.

Hier sind weitere Headless-CLI-Optionen -```console
katana -h headless

Flags:
HEADLESS:
   -hl, -headless                    enable headless hybrid crawling (experimental)
   -sc, -system-chrome               use local installed chrome browser instead of katana installed
   -sb, -show-browser                show the browser on the screen with headless mode
   -ho, -headless-options string[]   start headless chrome with additional options
   -nos, -no-sandbox                 start headless chrome in --no-sandbox mode
   -cdd, -chrome-data-dir string     path to store chrome browser data
   -scp, -system-chrome-path string  use specified chrome browser for headless crawling
   -noi, -no-incognito               start headless chrome without incognito mode
   -cwu, -chrome-ws-url string       use chrome browser instance launched elsewhere with the debugger listening at this URL
   -xhr, -xhr-extraction             extract xhr requests
   -pls, -page-load-strategy string  page load strategy (heuristic, load, domcontentloaded, networkidle, none) (default "heuristic")
   -dwt, -dom-wait-time int          time in seconds to wait after page load when using domcontentloaded strategy (default 5)
   -csp, -captcha-solver-provider string  captcha solver provider (e.g. capsolver)
   -csk, -captcha-solver-key string       captcha solver provider api key

*`-no-incognito`*
----

Führt den headless Chrome-Browser ohne Inkognito-Modus aus, nützlich bei Verwendung des lokalen Browsers.```console
katana -u https://tesla.com -headless -no-incognito

*`-headless-options`*
----

Beim Crawlen im Headless-Modus können zusätzliche Chrome-Optionen mit `-headless-options` angegeben werden, zum Beispiel -```console
katana -u https://tesla.com -headless -system-chrome -headless-options --disable-gpu,proxy-server=http://127.0.0.1:8080

Die `domcontentloaded`-Strategie ist besonders nützlich für Single Page Applications (SPAs), die aufgrund kontinuierlicher Hintergrundanfragen (Websockets, Polling usw.) nie vollständig laden.

*`-dom-wait-time`*
----

Bei Verwendung der `domcontentloaded`-Page-Load-Strategie gibt diese Option an, wie viele Sekunden nach dem Auslösen des `DOMContentLoaded`-Ereignisses gewartet werden soll. Dies gibt JavaScript Zeit, interaktive Elemente zu rendern. Standardwert ist 5 Sekunden.```console
katana -u https://tesla.com -headless -pls domcontentloaded -dwt 10

Der Anbieter und der Schlüssel können auch über Umgebungsvariablen festgelegt werden:```console
export CAPTCHA_SOLVER_PROVIDER=capsolver
export CAPTCHA_SOLVER_KEY=YOUR_API_KEY
katana -u https://example.com -headless

*`-crawl-scope`*
------

Für erweiterte Bereichssteuerung kann die Option `-cs` verwendet werden, die **Regex**-Unterstützung bietet.```console
katana -u https://tesla.com -cs login

---
## Teleport-Anwendungsstart```console
katana -u https://tesla.com -cs in_scope.txt

Für mehrere Out-of-Scope-Regeln kann eine Dateieingabe mit mehrzeiligen Zeichenfolgen/Regex übergeben werden.```bash
$ cat out_of_scope.txt

/logout
/log_out

*`-no-scope`*
----

Katana ist standardmäßig auf den Bereich `*.domain` festgelegt. Um dies zu deaktivieren, kann die Option `-ns` verwendet werden; mit ihr wird auch das Internet durchsucht.```console
katana -u https://tesla.com -ns

Hier sind alle CLI-Optionen für die Scope-Steuerung -```console
katana -h scope

Flags:
SCOPE:
   -cs, -crawl-scope string[]       in scope url regex to be followed by crawler
   -cos, -crawl-out-scope string[]  out of scope url regex to be excluded by crawler
   -fs, -field-scope string         pre-defined scope field (dn,rdn,fqdn) (default "rdn")
   -ns, -no-scope                   disables host based default scope
   -do, -display-out-scope          display external endpoint from scoped crawling

*`-js-crawl`*
----

Option zur Aktivierung des Parsens von JavaScript-Dateien + Crawlen der in JavaScript-Dateien entdeckten Endpunkte, standardmäßig deaktiviert.```
katana -u https://tesla.com -jc

*`-known-files`*
----
Option, um das Crawlen von `robots.txt` und `sitemap.xml` zu aktivieren, standardmäßig deaktiviert.```
katana -u https://tesla.com -kf robotstxt,sitemapxml

Form config values support DSL helper functions for dynamic data generation. All `rand_*` functions from the [projectdiscovery/dsl](https://github.com/projectdiscovery/dsl) library are available:```yaml
# $HOME/.config/katana/form-config.yaml
email: "rand_email()"
phone: "rand_phone()"
placeholder: "rand_first_name()"
password: 'rand_base(16, "")'
color: "#e66465"

Der Promotionsschwellenwert (wie viele verschiedene Werte an einer Pfadposition vorhanden sein müssen, bevor diese als Parameter behandelt wird) kann mit `-fst` eingestellt werden. Niedrigere Werte sind aggressiver (weniger URLs werden gecrawlt), höhere Werte sind permissiver. Standardwert ist `10`.```
katana -u https://tesla.com -fsu -fst 5

## Knowledge Base Classification

Katana kann Crawlergebnisse mit einer **Wissensbasis** anreichern — einer maschinellen Lernklassifikation jeder gecrawlten Seite, unterstützt von [dit](https://github.com/HappyHackingSpace/dit). Wenn aktiviert, wird jede Antwort nach **Seitentyp** klassifiziert (z. B. `login`, `error`, `captcha`, `parked`) und alle Formulare auf der Seite werden identifiziert, wobei das Ergebnis dem Feld `knowledgebase` der JSONL-Ausgabe hinzugefügt wird. Dies funktioniert mit **allen Engines** (Standard und Headless).

> **Hinweis**: Das Klassifikationsmodell wird bei der ersten Verwendung **automatisch** nach `~/.dit/model.json` heruntergeladen (von [Hugging Face](https://huggingface.co/datasets/happyhackingspace/dit)). Dies ist eine einmalige, pro Maschine anfallende Kosten – nachfolgende Ausführungen verwenden das zwischengespeicherte Modell erneut. Eine manuelle Installation von `dit` ist nicht erforderlich.

*`-knowledge-base`*
----

Aktiviert die Knowledge-Base-Klassifikation. Die Seiten- und Formularklassifikation wird dem Feld `knowledgebase` jedes Ergebnisses hinzugefügt.```console
katana -u https://example.com -kb -jsonl

*`-filter-page-type`*
----

Filtere Ergebnisse ausschließlich auf die angegebenen Seitentypen. Die Aktivierung dieser Option impliziert `-kb` (der Klassifikator wird automatisch initialisiert).```console
katana -u https://example.com -fpt login,error

*`-kb-endpoints`*
----

Aktiviert den Endpunkte-Extraktor, der Anfragen als REST, GraphQL, SOAP oder XHR unter dem Schlüssel `endpoints` klassifiziert.```console
katana -u https://example.com -kb-endpoints

Es ist auch möglich, Header oder Cookies als Datei bereitzustellen. Zum Beispiel:```
$ cat cookie.txt

Cookie: PHPSESSIONID=XXXXXXXXX
X-API-KEY: XXXXX
TOKEN=XX

Es gibt weitere Optionen zur Konfiguration bei Bedarf, hier sind alle konfigurationsbezogenen CLI-Optionen -```console
katana -h config

Flags:
CONFIGURATION:
   -r, -resolvers string[]       list of custom resolver (file or comma separated)
   -d, -depth int                maximum depth to crawl (default 3)
   -jc, -js-crawl                enable endpoint parsing / crawling in javascript file
   -ct, -crawl-duration int      maximum duration to crawl the target for
   -kf, -known-files string      enable crawling of known files (all,robotstxt,sitemapxml)
   -mrs, -max-response-size int  maximum response size to read (default 9223372036854775807)
   -timeout int                  time to wait for request in seconds (default 10)
   -aff, -automatic-form-fill    enable automatic form filling (experimental)
   -fx, -form-extraction         enable extraction of form, input, textarea & select elements
   -retry int                    number of times to retry the request (default 1)
   -proxy string                 http/socks5 proxy to use
   -H, -headers string[]         custom header/cookie to include in request
   -config string                path to the katana configuration file
   -fc, -form-config string      path to custom form configuration file
   -flc, -field-config string    path to custom field configuration file
   -s, -strategy string          Visit strategy (depth-first, breadth-first) (default "depth-first")
   -iqp, -ignore-query-params    Ignore crawling same path with different query-param values
   -fsu, -filter-similar         filter crawling of similar looking URLs (e.g., /users/123 and /users/456)
   -fst, -filter-similar-threshold int  number of distinct values before a path position is treated as parameter (default 10)
   -mdp, -max-domain-pages int   maximum number of pages to crawl per domain (default unlimited)

> Melden Sie sich nun bei der Website an, die Sie crawlen möchten, und lassen Sie den Browser geöffnet.

**step 3) Nutzen Sie nun die Websocket-URL mit katana, um eine Verbindung zur aktiven Browser-Sitzung herzustellen und die Website zu crawlen.**```console
katana -headless -u https://tesla.com -cwu ws://127.0.0.1:9222/devtools/browser/c5316c9c-19d6-42dc-847a-41d1aeebf7d6 -no-incognito

Hier ist eine Tabelle mit Beispielen für jedes Feld und der erwarteten Ausgabe bei Verwendung - 

| FIELD   | BESCHREIBUNG                 | EXAMPLE                                                      |
| ------- | --------------------------- | ------------------------------------------------------------ |
| `url`   | URL-Endpunkt                | `https://admin.projectdiscovery.io/admin/login?user=admin&password=admin` |
| `qurl`  | URL inklusive Query-Parameter   | `https://admin.projectdiscovery.io/admin/login.php?user=admin&password=admin` |
| `qpath` | Pfad inklusive Query-Parameter  | `/login?user=admin&password=admin`                           |
| `path`  | URL-Pfad                    | `https://admin.projectdiscovery.io/admin/login`              |
| `fqdn`  | Vollqualifizierter Domainname | `admin.projectdiscovery.io`                                  |
| `rdn`   | Root-Domainname            | `projectdiscovery.io`                                        |
| `rurl`  | Root-URL                    | `https://admin.projectdiscovery.io`                          |
| `ufile` | URL mit Datei               | `https://admin.projectdiscovery.io/login.js`                 |
| `file`  | Dateiname in URL             | `login.php`                                                  |
| `key`   | Parameternamen in URL       | `user,password`                                              |
| `value` | Parameterwerte in URL     | `admin,admin`                                                |
| `kv`    | Schlüssel=Werte in URL          | `user=admin&password=admin`                                  |
| `dir`   | URL-Verzeichnisname          | `/admin/`                                                    |
| `udir`  | URL mit Verzeichnis          | `https://admin.projectdiscovery.io/admin/`                   |

Hier ist ein Beispiel für die Verwendung der Feldoption, um nur alle URLs mit Query-Parameter anzuzeigen -```
katana -u https://tesla.com -f qurl -silent

https://shop.tesla.com/en_au?redirect=no
https://shop.tesla.com/en_nz?redirect=no
https://shop.tesla.com/product/men_s-raven-lightweight-zip-up-bomber-jacket?sku=1740250-00-A
https://shop.tesla.com/product/tesla-shop-gift-card?sku=1767247-00-A
https://shop.tesla.com/product/men_s-chill-crew-neck-sweatshirt?sku=1740176-00-A
https://www.tesla.com/about?redirect=no
https://www.tesla.com/about/legal?redirect=no
https://www.tesla.com/findus/list?redirect=no

Bei der Definition benutzerdefinierter Felder werden die folgenden Attribute unterstützt:

- **name** (erforderlich)

> Der Wert des **name**-Attributs wird als Wert der CLI-Option `-field` verwendet.

- **type** (erforderlich)

> Der Typ des benutzerdefinierten Attributs, derzeit unterstützte Option - `regex`

- **part** (optional)

> Der Teil der Antwort, aus dem die Informationen extrahiert werden sollen. Der Standardwert ist `response`, der sowohl den Header als auch den Body umfasst. Andere mögliche Werte sind `header` und `body`.

- group (optional)

> Sie können dieses Attribut verwenden, um eine bestimmte übereinstimmende Gruppe im Regex auszuwählen, zum Beispiel: `group: 1`

#### Ausführen von katana mit benutzerdefiniertem Feld:```console
katana -u https://tesla.com -f email,phone

". Actually, the user message is just the instructions and then "INPUT:" followed by a blank? Maybe the chunk content was omitted? Let me read carefully: The user says "Translate the following Kitploit tool content. This is chunk 119 of 179 from a longer Markdown document... INPUT:" and then there is no text after that. Possibly due to a formatting error? But the instructions say "If the chunk starts mid-paragraph, continue translating from that point." But there is no content to translate. Since no content is provided, I should output nothing or perhaps state that no content was provided. However, rules say "Return ONLY the translated text. No preamble, no commentary." So if there's no input, I should output an empty string. But maybe the chunk content is truly empty? The assistant message should be empty. So I'll output nothing. But the instruction says "Return ONLY the translated text." If there's no text, just nothing.

Thus, the response is an empty string.```bash
$ ls katana_field/

https_www.tesla.com_fqdn.txt
https_www.tesla.com_key.txt
https_www.tesla.com_qurl.txt

Verwenden Sie den speziellen Wert `none`, um auch URLs ohne Dateierweiterung in die Ausgabe aufzunehmen:```
katana -u https://tesla.com -silent -em js,jsp,json,none

*`-no-default-ext-filter`*
---

Katana filtert standardmäßig mehrere Erweiterungen. Dies kann mit der Option `-ndef` deaktiviert werden.```
katana -u https://tesla.com -silent -ndef

*`-filter-regex`*
---
Das `-filter-regex` oder `-fr` Flag ermöglicht es Ihnen, Ausgabe-URLs mithilfe von regulären Ausdrücken zu filtern. Bei Verwendung dieses Flags werden die URLs übersprungen, die dem angegebenen regulären Ausdruck entsprechen.```
katana -u https://tesla.com -fr 'https://www\.tesla\.com/*' -silent

- Um Endpunkte zu finden, die "default" enthalten und einen anderen Statuscode als 403 haben:```shell
katana -u https://www.hackerone.com -mdc 'contains(endpoint, "default") && status_code != 403'

- Um auf Cloudflare laufende Endpunkte herauszufiltern:```shell
katana -u https://www.hackerone.com -fdc 'contains(to_lower(technologies), "cloudflare")'

## Rate Limit

Es ist leicht, beim Crawlen blockiert oder gebannt zu werden, wenn man sich nicht an die Grenzen der Zielwebseiten hält. Katana bietet mehrere Optionen, um den Crawl so schnell oder langsam anzupassen, wie wir möchten.

*`-delay`*
-----

Option, um zwischen jeder neuen Anfrage, die Katana beim Crawlen stellt, eine Verzögerung in Sekunden einzufügen. Standardmäßig deaktiviert.```
katana -u https://tesla.com -delay 20

*`-parallelism`*
-----
Option zur Definition der Anzahl gleichzeitig zu verarbeitender Ziele aus der Liste.```
katana -u https://tesla.com -p 20

*`-rate-limit-minute`*
-----
Maximale Anfragen pro Minute, global auf alle Hosts angewendet.```
katana -u https://tesla.com -rlm 500

*`-host-rate-limit-minute`*
-----
Maximale Anfragen pro Minute pro Host.```console
katana -u https://tesla.com -hrlm 200

## Output

Katana unterstützt sowohl die Dateiausgabe im Klartextformat als auch JSON, das zusätzliche Informationen wie `source`, `tag` und `attribute` -Namen enthält, um die entdeckten Endpunkte zu korrelieren.

*`-output`*
---

Standardmäßig gibt Katana die gecrawlten Endpunkte im Klartextformat aus. Die Ergebnisse können mit der Option `-output` in eine Datei geschrieben werden.```console
katana -u https://example.com -no-scope -output example_endpoints.txt

In diesem Beispiel repräsentiert `email` ein [benutzerdefiniertes Feld](#custom-fields), das in der Quell-`url` gefundene E-Mail-Adressen extrahiert und anzeigt.

> [!NOTE]
> Wenn ein angegebenes Feld nicht existiert oder keinen Wert enthält, wird es einfach aus der Ausgabe weggelassen.

Diese Option kann die Ausgabe effektiv so strukturieren, dass sie am besten zu Ihrem Anwendungsfall passt und die Datenextraktion intuitiver und anpassbarer macht.

*`-jsonl`*
---```console
katana -u https://example.com -jsonl | jq .

pip install ccm

pip install ccm

ccm config set engine docker

*`-store-response`*
----

Die Option `-store-response` ermöglicht es, alle Anfragen und Antworten von gecrawlten Endpunkten in eine Textdatei zu schreiben. Wenn diese Option verwendet wird, werden Textdateien mit der Anfrage und Antwort in das Verzeichnis **katana_response** geschrieben. Wenn Sie ein benutzerdefiniertes Verzeichnis angeben möchten, können Sie die Option `-store-response-dir` verwenden.```console
katana -u https://example.com -no-scope -store-response

**Note:**

*`-store-response` Option wird im `-headless`-Modus nicht unterstützt.*

*`-list-output-fields`*
----

Das Flag `-list-output-fields` oder `-lof` zeigt alle verfügbaren Felder an, die im JSONL-Ausgabeformat verwendet werden können. Dies ist nützlich, um zu verstehen, welche Daten verfügbar sind, wenn benutzerdefinierte Ausgabevorlagen verwendet oder bestimmte Felder ausgeschlossen werden.```console
katana -lof

Hier sind zusätzliche CLI-Optionen in Bezug auf die Ausgabe -```console
katana -h output

OUTPUT:
   -o, -output string                file to write output to
   -sr, -store-response              store http requests/responses
   -srd, -store-response-dir string  store http requests/responses to custom directory
   -lof, -list-output-fields         list available fields for jsonl output format
   -eof, -exclude-output-fields      exclude fields from jsonl output
   -j, -json                         write output in JSON Lines format
   -nc, -no-color                    disable output content coloring (ANSI escape codes)
   -silent                           display output only
   -v, -verbose                      display verbose output
   -version                          display project version

"github.com/projectdiscovery/gologger"
"github.com/projectdiscovery/katana/pkg/engine/standard"
"github.com/projectdiscovery/katana/pkg/output"
"github.com/projectdiscovery/katana/pkg/types"

## Probleme melden & Funktionen vorschlagen

Um die Problemverfolgung zu erhalten und die Triage-Effizienz zu verbessern:

**Alle Berichte beginnen als [GitHub Discussions](https://github.com/projectdiscovery/katana/discussions)**

- **Fehlerberichte** → [Starten Sie eine Q&A-Diskussion](https://github.com/projectdiscovery/katana/discussions/new?category=q-a)
- **Funktionsanfragen** → [Starten Sie eine Ideen-Diskussion](https://github.com/projectdiscovery/katana/discussions/new?category=ideas)  
- **Fragen** → [Starten Sie eine Q&A-Diskussion](https://github.com/projectdiscovery/katana/discussions/new?category=q-a)

**Warum zuerst Diskussionen?**
- **Die Community kann helfen** bei schnellen Fragen und Fehlerbehebung
- **Bessere Triage** – bestätigte Fehler/Funktionen werden zu verfolgten Issues  
- **Sauberer Issue-Tracker** – Konzentration nur auf umsetzbare Punkte

Die Betreuer werden Diskussionen nach angemessener Überprüfung in Issues umwandeln, wenn dies angebracht ist.

--------

<div align="center">

katana wird mit ❤️ vom [projectdiscovery](https://projectdiscovery.io)-Team entwickelt und unter der [MIT-Lizenz](https://github.com/projectdiscovery/katana/blob/HEAD/LICENSE.md) vertrieben.


<a href="https://discord.gg/projectdiscovery"><img src="https://assets.kitploit.com/production/public/readmes/5826/d0624f94cb9ea6401be5a089bb694bc963c47fa82aa3b758c893e3b0bbfdf663.png" width="300" alt="Discord beitreten"></a>

</div>