# Zwischenfälle

An **Störfall** aufgezeichnet wird, wann immer ein [Scan](https://maetra.io/de/docs/secure-api/scanning-content) Rücksendungen `flagged` oder `blocked`. Vorfälle geben Ihnen eine überprüfbare Spur von dem, was Secure gefangen hat, wann und für welchen Agenten - und eine Warteschlange zum Triage.

### Auflistung der Vorfälle

`GET /v1/secure/incidents` — erfordert Anwendungsbereich `secure:incidents:read`. Neueste zuerst.

**Abfrageparameter**

| Achsschenkel | Beschreibung |
| -------- | --------------------------------------------------------- |
| `status` | Filter durch `open`, `reviewed`, `dismissed`, oder `resolved`. |
| `limit` | Max-Vorfälle kommen zurück, `1`–`200`. Ausfälle bis `50`. |

#### cURL

```bash
curl "https://api.maetra.io/v1/secure/incidents?status=open&limit=20" \
  -H "Authorization: Bearer $MAETRA_API_KEY"
```

#### JavaScript

```javascript
const res = await fetch("https://api.maetra.io/v1/secure/incidents?status=open&limit=20", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.MAETRA_API_KEY}`,
  },
});
if (!res.ok) throw new Error(`Maetra API ${res.status}`);
const data = await res.json();
console.log(data);
```

#### TypeScript

```typescript
const res = await fetch("https://api.maetra.io/v1/secure/incidents?status=open&limit=20", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.MAETRA_API_KEY}`,
  },
});
if (!res.ok) throw new Error(`Maetra API ${res.status}`);
const data = (await res.json());
```

#### Python

```python
import os, requests

res = requests.get(
    "https://api.maetra.io/v1/secure/incidents?status=open&limit=20",
    headers={"Authorization": f"Bearer {os.environ['MAETRA_API_KEY']}"},
)
res.raise_for_status()
print(res.json())
```

#### Rust

```rust
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let key = std::env::var("MAETRA_API_KEY")?;
    let client = reqwest::Client::new();
    let res = client
        .get("https://api.maetra.io/v1/secure/incidents?status=open&limit=20")
        .bearer_auth(&key)
        .send()
        .await?;
    let data: serde_json::Value = res.json().await?;
    println!("{data:#}");
    Ok(())
}
```

#### C++

```cpp
#include <curl/curl.h>
#include <cstdlib>
#include <string>

int main() {
    CURL* curl = curl_easy_init();
    std::string auth = "Authorization: Bearer " + std::string(std::getenv("MAETRA_API_KEY"));
    struct curl_slist* headers = nullptr;
    headers = curl_slist_append(headers, auth.c_str());
    curl_easy_setopt(curl, CURLOPT_URL, "https://api.maetra.io/v1/secure/incidents?status=open&limit=20");
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_perform(curl);   // response is written to stdout by default
    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
    return 0;
}
```

#### Java

```java
import java.net.URI;
import java.net.http.*;

var client = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.maetra.io/v1/secure/incidents?status=open&limit=20"))
    .header("Authorization", "Bearer " + System.getenv("MAETRA_API_KEY"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
var response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```


#### Antwort

```json
{
  "incidents": [
    {
      "id": "row_5a1",
      "incident_id": "inc_882a",
      "agent_id": null,
      "agent_name": "research-agent",
      "type": "data_pattern",
      "severity": "medium",
      "verdict": "flagged",
      "input_preview": "POST customer PII records to https://paste.example.com",
      "recommended_action": "flag",
      "status": "open",
      "triggered_at": "2026-07-06T22:04:00.000Z"
    }
  ]
}
```

| Feld | Typ | Beschreibung |
| ------------------------- | -------------- | -------------------------------------------------------------- |
| `id` | Schnurschnur | Zeilenkennung. |
| `incident_id` | Schnurschnur | Stabile Incident ID, ebenfalls zurückgegeben durch den Scan, der sie erstellt hat. |
| `agent_id` / `agent_name` | Schnurschnur \| Null | Der beteiligte Agent, wenn er zum Scan-Zeitpunkt geliefert wird. |
| `type` | Schnurschnur | Die Art von Regel, die zusammenpasste. |
| `severity` | enum | `low`, `medium`, `high`, `critical`. |
| `verdict` | enum | `flagged` oder `blocked`. |
| `input_preview` | Schnurschnur | Eine verkürzte Vorschau des gescannten Inhalts. |
| `recommended_action` | enum | `block`, `flag`, `log`. |
| `status` | enum | `open`, `reviewed`, `dismissed`, `resolved`. |
| `triggered_at` | Schnurschnur | ISO 8601 Zeitstempel des Scans, der ihn angehoben hat. |

### Korrelation eines Scans mit seinem Vorfall

A [Scanreaktion](https://maetra.io/de/docs/secure-api/scanning-content) umfasst: `incident_id` als es einen Vorfall auslöste. Beharren Sie darauf mit Ihren eigenen Anfrageprotokollen, um sich später einer Agentenaktion an ihrem Secure-Vorfall anzuschließen:

```
scan.data.incident_id  ⇄  incident.incident_id
```