> ## Documentation Index
> Fetch the complete documentation index at: https://docs.appsignal.com/llms.txt
> Use this file to discover all available pages before exploring further.

# GraphQL-API Mutation-Beispiele

Die [GraphQL-API](/api/graphql) von AppSignal unterstützt Mutations ebenso wie Queries.
Während eine [Query](/api/graphql/examples) Daten liest, schreibt eine Mutation sie:
Sie können einen benutzerdefinierten Marker erstellen, einen Incident schließen,
einen Uptime-Monitor hinzufügen und vieles mehr.

Mutations verwenden denselben Endpunkt und dasselbe persönliche API-Token wie Queries.
Einzelheiten zum Endpunkt und zur Authentifizierung finden Sie auf der
[GraphQL-API-Seite](/api/graphql).

Die meisten Mutations sind app-bezogen und nehmen ein `appId`-Argument entgegen, das die
Änderung auf eine einzelne App eingrenzt. Sie finden Ihre App-ID im
[Einstellungsbildschirm](https://appsignal.com/redirect-to/app?to=admin/api_keys) Ihrer App.
Einige Mutations sind organisationsbezogen und nehmen stattdessen ein
`organizationSlug`-Argument entgegen, wie z. B. `createApp` und `createStatusPage`.

Diese Seite behandelt die häufigsten Mutations. Die vollständige, automatisch generierte Liste
aller Mutations und ihrer Argumente finden Sie in der [GraphQL-Schema-Referenz](https://appsignal.com/graphql/docs).

<Note>
  Mutations verändern Daten in Ihrem Konto. Testen Sie eine Mutation gegen eine
  Nicht-Produktiv-App, bevor Sie sie gegen Produktionsdaten automatisieren.
</Note>

## Incidents

### Einen Incident aktualisieren

Ändern Sie den Status, den Schweregrad, die zugewiesenen Personen oder die Benachrichtigungseinstellungen eines Incidents.
Die `number` ist die in AppSignal angezeigte Incident-Nummer.

`state` akzeptiert `OPEN`, `WIP` oder `CLOSED`. `severity` akzeptiert `UNTRIAGED`,
`CRITICAL`, `HIGH`, `LOW`, `NONE` oder `INFORMATIONAL`.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation UpdateIncident(
    $appId: String!
    $number: Int!
    $state: IncidentStateEnum
    $severity: IncidentSeverityEnum
    $assigneeIds: [String!]
  ) {
    updateIncident(
      appId: $appId
      number: $number
      state: $state
      severity: $severity
      assigneeIds: $assigneeIds
    ) {
      ... on ExceptionIncident {
        id
        number
        state
        severity
      }
      ... on PerformanceIncident {
        id
        number
        state
        severity
      }
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "number": 42,
    "state": "CLOSED",
    "severity": "LOW"
  }
  ```
</CodeGroup>

### Mehrere Incidents gesammelt aktualisieren

Aktualisieren Sie mehrere Incidents in einer einzigen Anfrage. Anders als
`updateIncident` nimmt diese Mutation Incident-IDs statt Incident-Nummern entgegen.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation BulkUpdateIncidents(
    $appId: String!
    $ids: [String]!
    $state: IncidentStateEnum
    $severity: IncidentSeverityEnum
  ) {
    bulkUpdateIncidents(
      appId: $appId
      ids: $ids
      state: $state
      severity: $severity
    ) {
      ... on ExceptionIncident {
        id
        number
        state
      }
      ... on PerformanceIncident {
        id
        number
        state
      }
      ... on AnomalyIncident {
        id
        number
        state
      }
      ... on LogIncident {
        id
        number
        state
      }
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "ids": ["INCIDENT-ID-1", "INCIDENT-ID-2"],
    "state": "CLOSED"
  }
  ```
</CodeGroup>

### Eine Notiz zu einem Incident erstellen

Fügen Sie eine Notiz zum Logbuch eines Incidents hinzu. Dieselben Felder sind für
Performance-, Anomaly- und Log-Incidents verfügbar.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation CreateIncidentNote(
    $appId: String!
    $incidentNumber: Int!
    $content: String!
  ) {
    createIncidentNote(
      appId: $appId
      incidentNumber: $incidentNumber
      content: $content
    ) {
      ... on ExceptionIncident {
        id
        number
        logbook {
          items {
            ... on Note {
              id
              content
              createdAt
            }
          }
        }
      }
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "incidentNumber": 42,
    "content": "Investigating, deploy reverted."
  }
  ```
</CodeGroup>

### Aus einem Incident ein Issue erstellen

Erstellen Sie ein verknüpftes Issue in einer verbundenen Integration. Dieses Beispiel
verwendet GitHub; entsprechende Mutations existieren für andere Integrationen:
`createGitlabIssue`, `createJiraIssue`, `createLinearIssue`, `createShortcutStory`,
`createAsanaTask` und `createTrelloCard`.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation CreateGithubIssue(
    $appId: String!
    $incidentNumber: Int!
    $title: String!
    $description: String!
  ) {
    createGithubIssue(
      appId: $appId
      incidentNumber: $incidentNumber
      title: $title
      description: $description
    ) {
      ... on ExceptionIncident {
        id
        number
        integrations {
          ... on GitHub {
            name
            issues {
              url
              title
            }
          }
        }
      }
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "incidentNumber": 42,
    "title": "NoMethodError in OrdersController#create",
    "description": "Tracked in AppSignal incident #42."
  }
  ```
</CodeGroup>

### Eine Integration aus einem Incident entfernen

Entfernen Sie ein zuvor verknüpftes Integrations-Issue aus einem Incident.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation RemoveIntegration(
    $appId: String!
    $incidentNumber: Int!
    $id: String!
  ) {
    removeIntegration(
      appId: $appId
      incidentNumber: $incidentNumber
      id: $id
    ) {
      ... on ExceptionIncident {
        id
        number
      }
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "incidentNumber": 42,
    "id": "YOUR-INTEGRATION-ID"
  }
  ```
</CodeGroup>

## Marker

### Einen benutzerdefinierten Marker erstellen oder aktualisieren

Erstellen Sie einen benutzerdefinierten Marker, um einen Zeitpunkt zu kennzeichnen,
etwa eine Konfigurationsänderung oder eine manuelle Aktion. Übergeben Sie eine `id`,
um einen bestehenden Marker zu aktualisieren. Lassen Sie `id` weg, um einen neuen
Marker zu erstellen.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation CreateCustomMarker(
    $appId: String!
    $id: String
    $icon: String!
    $message: String
    $createdAt: DateTime
  ) {
    createOrUpdateCustomMarker(
      appId: $appId
      id: $id
      icon: $icon
      message: $message
      createdAt: $createdAt
    ) {
      id
      icon
      message
      createdAt
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "icon": "🚀",
    "message": "Ran database migration"
  }
  ```
</CodeGroup>

### Einen benutzerdefinierten Marker löschen

Löschen Sie einen benutzerdefinierten Marker anhand seiner ID.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation DeleteCustomMarker($appId: String!, $id: String!) {
    deleteCustomMarker(appId: $appId, id: $id) {
      id
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "id": "YOUR-MARKER-ID"
  }
  ```
</CodeGroup>

## Alerts und Trigger

### Einen Trigger erstellen

Erstellen Sie einen metrikbasierten Alert-Trigger. `field` akzeptiert einen Wert aus
`MetricFieldEnum` (z. B. `MEAN`, `P90`, `P95`, `COUNT`, `GAUGE` oder `COUNTER`).
`kind` ist eine Zeichenkette, die den Triggertyp beschreibt. Die GraphQL-Quelldokumentation
nennt `ExceptionRate` und `Throughput` als Beispiele. Die `condition` legt den
Schwellenwert zum Vergleich fest. Um einen bestehenden Trigger zu ersetzen, übergeben
Sie dessen ID als `previousTriggerId`.

`comparisonOperator` akzeptiert `LESS_THAN`, `GREATER_THAN`, `LESS_THAN_OR_EQUAL`,
`GREATER_THAN_OR_EQUAL`, `EQUAL` oder `NOT_EQUAL`.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation CreateTrigger(
    $appId: String!
    $previousTriggerId: String
    $name: String
    $metricName: String!
    $kind: String!
    $field: MetricFieldEnum!
    $condition: ThresholdConditionInput!
    $warmupDuration: Int!
    $cooldownDuration: Int!
    $notifierIds: [String!]
  ) {
    createTrigger(
      appId: $appId
      previousTriggerId: $previousTriggerId
      name: $name
      metricName: $metricName
      kind: $kind
      field: $field
      condition: $condition
      warmupDuration: $warmupDuration
      cooldownDuration: $cooldownDuration
      notifierIds: $notifierIds
    ) {
      id
      name
      metricName
      field
      thresholdCondition {
        value
        comparisonOperator
      }
      warmupDuration
      cooldownDuration
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "name": "High error rate",
    "metricName": "transaction_exception_count",
    "kind": "ExceptionRate",
    "field": "COUNTER",
    "condition": { "value": 10, "comparisonOperator": "GREATER_THAN" },
    "warmupDuration": 0,
    "cooldownDuration": 5,
    "notifierIds": ["YOUR-NOTIFIER-ID"]
  }
  ```
</CodeGroup>

### Einen Trigger archivieren

Archivieren Sie einen Trigger, sodass er keine Metriken mehr auswertet und keine
Alerts mehr versendet.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation ArchiveTrigger($appId: String!, $id: String!) {
    archiveTrigger(appId: $appId, id: $id) {
      id
      name
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "id": "YOUR-TRIGGER-ID"
  }
  ```
</CodeGroup>

### Einen Alert archivieren

Archivieren Sie einen einzelnen ausgelösten Alert. Diese Mutation gibt bei Erfolg
`true` zurück.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation ArchiveAlert($appId: String!, $id: String!) {
    archiveAlert(appId: $appId, id: $id)
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "id": "YOUR-ALERT-ID"
  }
  ```
</CodeGroup>

### Den letzten Alert für einen Anomaly-Incident schließen

Schließen Sie den jüngsten offenen Alert für einen Anomaly-Incident, identifiziert
über seine Incident-Nummer.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation EndLastAlert($appId: String!, $number: Int!) {
    endLastAlert(appId: $appId, number: $number) {
      id
      number
      alertState
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "number": 42
  }
  ```
</CodeGroup>

## Uptime-Monitore

### Einen Uptime-Monitor erstellen

Erstellen Sie einen Uptime-Monitor aus einem `UptimeMonitorInput`. `regions` akzeptiert
einen oder mehrere der Werte `EUROPE`, `NORTH_AMERICA`, `ASIA_PACIFIC` oder
`SOUTH_AMERICA`.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation CreateUptimeMonitor(
    $appId: String!
    $uptimeMonitor: UptimeMonitorInput!
  ) {
    createUptimeMonitor(appId: $appId, uptimeMonitor: $uptimeMonitor) {
      id
      name
      url
      regions
      warmupDuration
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "uptimeMonitor": {
      "name": "Marketing site",
      "url": "https://example.com",
      "regions": ["EUROPE", "NORTH_AMERICA"],
      "warmupDuration": 1,
      "notifierIds": ["YOUR-NOTIFIER-ID"]
    }
  }
  ```
</CodeGroup>

### Einen Uptime-Monitor aktualisieren

Aktualisieren Sie einen bestehenden Monitor. Die `uptimeMonitor`-Eingabe hat dieselbe
Struktur wie beim Erstellen.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation UpdateUptimeMonitor(
    $appId: String!
    $id: String!
    $uptimeMonitor: UptimeMonitorInput!
  ) {
    updateUptimeMonitor(
      appId: $appId
      id: $id
      uptimeMonitor: $uptimeMonitor
    ) {
      id
      name
      url
      regions
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "id": "YOUR-UPTIME-MONITOR-ID",
    "uptimeMonitor": {
      "name": "Marketing site",
      "url": "https://example.com/health",
      "regions": ["EUROPE"]
    }
  }
  ```
</CodeGroup>

### Einen Uptime-Monitor löschen

Löschen Sie einen Monitor anhand seiner ID. Diese Mutation gibt den gelöschten Monitor zurück.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation DeleteUptimeMonitor($appId: String!, $id: String!) {
    deleteUptimeMonitor(appId: $appId, id: $id) {
      id
      name
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "id": "YOUR-UPTIME-MONITOR-ID"
  }
  ```
</CodeGroup>

## Check-ins

### Einen Check-in-Trigger erstellen

Erstellen Sie einen Cron- oder Heartbeat-Check-in-Trigger. `kind` akzeptiert `CRON`
oder `HEARTBEAT`. Für einen Cron-Trigger setzen Sie `syntax` auf den Cron-Ausdruck.
Verwenden Sie nach Möglichkeit UTC für `timezone`.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation CreateCheckInTrigger(
    $appId: String!
    $identifier: String!
    $kind: CheckInTriggerKindEnum!
    $waitTimeMinutes: Int!
    $syntax: String
    $timezone: String
    $notifierIds: [String!]
  ) {
    createCheckInTrigger(
      appId: $appId
      identifier: $identifier
      kind: $kind
      waitTimeMinutes: $waitTimeMinutes
      syntax: $syntax
      timezone: $timezone
      notifierIds: $notifierIds
    ) {
      id
      identifier
      kind
      syntax
      timezone
      waitTimeMinutes
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "identifier": "nightly-backup",
    "kind": "CRON",
    "syntax": "0 2 * * *",
    "timezone": "UTC",
    "waitTimeMinutes": 5,
    "notifierIds": ["YOUR-NOTIFIER-ID"]
  }
  ```
</CodeGroup>

### Einen Check-in-Trigger aktualisieren

Aktualisieren Sie einen bestehenden Check-in-Trigger. Nur die Felder, die Sie übergeben,
werden geändert.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation UpdateCheckInTrigger(
    $appId: String!
    $id: String!
    $syntax: String
    $waitTimeMinutes: Int
    $notifierIds: [String!]
  ) {
    updateCheckInTrigger(
      appId: $appId
      id: $id
      syntax: $syntax
      waitTimeMinutes: $waitTimeMinutes
      notifierIds: $notifierIds
    ) {
      id
      identifier
      syntax
      waitTimeMinutes
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "id": "YOUR-CHECK-IN-TRIGGER-ID",
    "syntax": "0 3 * * *",
    "waitTimeMinutes": 10
  }
  ```
</CodeGroup>

### Einen Check-in-Trigger löschen

Löschen Sie einen Check-in-Trigger anhand seiner ID.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation DeleteCheckInTrigger($appId: String!, $id: String!) {
    deleteCheckInTrigger(appId: $appId, id: $id) {
      id
      identifier
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "id": "YOUR-CHECK-IN-TRIGGER-ID"
  }
  ```
</CodeGroup>

## Dashboards

### Ein Dashboard erstellen

Erstellen Sie ein leeres Dashboard. Fügen Sie ihm mit den Mutations
`createVisualTimeseries` und `createVisualNumber` Visuals hinzu oder importieren Sie
ein komplettes Dashboard mit `importDashboard`.

Dashboard-Visuals werden ebenfalls über `createVisualTimeseries`,
`createVisualNumber`, `updateVisualTimeseries`, `updateVisualNumber`,
`updateVisualLayouts` und `deleteVisual` verwaltet. Um ein eigenständiges
gespeichertes Visual für den späteren Abruf über die [REST-Endpunkte für gespeicherte
Visuals](/api/v2/saved-visuals) zu erstellen, verwenden Sie `createSavedVisual`.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation CreateDashboard(
    $appId: String!
    $title: String!
    $description: String
  ) {
    createDashboard(appId: $appId, title: $title, description: $description) {
      id
      title
      description
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "title": "Background jobs",
    "description": "Throughput and queue time for worker jobs."
  }
  ```
</CodeGroup>

### Ein Dashboard aktualisieren

Aktualisieren Sie Titel oder Beschreibung eines Dashboards. Der `title` ist erforderlich.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation UpdateDashboard(
    $appId: String!
    $id: String!
    $title: String!
    $description: String
  ) {
    updateDashboard(
      appId: $appId
      id: $id
      title: $title
      description: $description
    ) {
      id
      title
      description
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "id": "YOUR-DASHBOARD-ID",
    "title": "Background jobs",
    "description": "Updated description."
  }
  ```
</CodeGroup>

### Ein Dashboard löschen

Löschen Sie ein Dashboard anhand seiner ID.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation DeleteDashboard($appId: String!, $id: String!) {
    deleteDashboard(appId: $appId, id: $id) {
      id
      title
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "id": "YOUR-DASHBOARD-ID"
  }
  ```
</CodeGroup>

### Ein Dashboard importieren

Importieren Sie ein Dashboard aus einer JSON-Definition. Das Argument `json` ist eine
JSON-kodierte Zeichenkette, daher müssen Sie sie beim Senden als Variable escapen.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation ImportDashboard($appId: String!, $json: String!) {
    importDashboard(appId: $appId, json: $json) {
      id
      title
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "json": "{\"title\":\"Imported dashboard\",\"visuals\":[]}"
  }
  ```
</CodeGroup>

## Logs

### Einen Log-Trigger erstellen

Erstellen Sie einen Trigger, der einen Incident öffnet, wenn Log-Zeilen einer Abfrage
entsprechen. `severities` akzeptiert Log-Schweregradnamen wie `error`, `warn` oder
`info`.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation CreateLogTrigger(
    $appId: String!
    $name: String!
    $query: String!
    $sourceIds: [String!]
    $severities: [String!]
    $notifierIds: [String!]
  ) {
    createLogTrigger(
      appId: $appId
      name: $name
      query: $query
      sourceIds: $sourceIds
      severities: $severities
      notifierIds: $notifierIds
    ) {
      id
      name
      query
      severities
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "name": "Payment errors",
    "query": "payment failed",
    "severities": ["error"],
    "notifierIds": ["YOUR-NOTIFIER-ID"]
  }
  ```
</CodeGroup>

Logs werden über GraphQL auch über Trigger hinaus verwaltet. Verwenden Sie
`createLogSource`, `updateLogSource` und `deleteLogSource` für Quellen;
`createLogView`, `updateLogView` und `deleteLogView` für gespeicherte Ansichten;
`createLogLineAction`, `updateLogLineAction`, `deleteLogLineAction` und
`reorderLogLineActions` für Ingestion-Regeln; `updateLogTrigger` und `deleteLogTrigger`
für Log-Trigger; und `createLogExport`, `updateLogExport` und `deleteLogExport`
für S3-Exporte.

## Organisationsbezogene Mutations

Manche Mutations beziehen sich auf eine Organisation statt auf eine einzelne App und
nehmen daher ein `organizationSlug`-Argument anstelle von `appId` entgegen. Das Slug
finden Sie in der URL Ihrer Organisation in AppSignal.

### Eine App erstellen

Erstellen Sie eine neue App innerhalb einer Organisation.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation CreateApp(
    $organizationSlug: String!
    $name: String!
    $environment: String!
  ) {
    createApp(
      organizationSlug: $organizationSlug
      name: $name
      environment: $environment
    ) {
      id
      name
      environment
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "organizationSlug": "YOUR-ORGANIZATION-SLUG",
    "name": "My app",
    "environment": "production"
  }
  ```
</CodeGroup>

### Eine Statusseite erstellen

Erstellen Sie eine öffentliche Statusseite aus einem `CreateStatusPageInput`. `title`
und `hostname` sind erforderlich.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation CreateStatusPage(
    $organizationSlug: String!
    $statusPage: CreateStatusPageInput!
  ) {
    createStatusPage(
      organizationSlug: $organizationSlug
      statusPage: $statusPage
    ) {
      id
      title
      hostname
      state
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "organizationSlug": "YOUR-ORGANIZATION-SLUG",
    "statusPage": {
      "title": "Service status",
      "hostname": "status.example.com",
      "uptimeMonitorIds": ["YOUR-UPTIME-MONITOR-ID"],
      "threshold": 1
    }
  }
  ```
</CodeGroup>

Statusseiten unterstützen außerdem `createStatusPageUpdate`, `updateStatusPage`,
`updateStatusPageUpdate`, `deleteStatusPage` und `deleteStatusPageUpdate`. Für
CSV-Exporte verwenden Sie `createCsvExport`, um einen Export zu starten, und
`createCsvExportUrl`, um eine Download-URL für einen abgeschlossenen Export zu
erzeugen.

## Weitere Mutations

Diese Beispiele decken die häufigsten Operationen ab. Die API enthält noch weitere,
gruppiert in der Schema-Referenz unter Core (App- und Hosted-Collector-Verwaltung),
Dashboards (Visuals und Layouts), Logs (Quellen, Ansichten und Exporte), Exports
(CSV), Statusseiten (Updates) und Benutzereinstellungen. Die vollständige Liste der
Mutations und ihrer Argumente finden Sie in der [GraphQL-Schema-Referenz](https://appsignal.com/graphql/docs).