> For the complete documentation index, see [llms.txt](https://docs.ninox.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.ninox.com/ninox-scripting/de/automate-your-workflows/work-with-functions/integration-and-http.md).

# Integration und HTTP

Lerne, wie du externe Dienste aufrufst, XML gegen XSD-Schemas validierst, XML transformierst, E-Mail-Werte erstellst und E-Mails mit Ninox Skripten sendest.

Integrationsfunktionen verbinden deine App mit Diensten und Kommunikationstools außerhalb von Ninox. Du kannst APIs aufrufen, XML gegen Schemas validieren, XML transformieren und E-Mails senden.

In diesem Kapitel lernst du, wie du:

* externe Dienste mit HTTP aufrufst.
* XML gegen ein XSD-Schema validierst.
* XML transformierst.
* E-Mail-Werte erstellst und E-Mails sendest.

<table><thead><tr><th width="249.3359375">Funktion (A-Z)</th><th>Aufgabe</th></tr></thead><tbody><tr><td><code>email()</code></td><td>Text in einen E-Mail-Wert umwandeln</td></tr><tr><td><code>formatXML()</code></td><td>Konvertiert JSON-Daten in XML-Text</td></tr><tr><td><code>http()</code></td><td>Sendet eine HTTP-Anfrage</td></tr><tr><td><code>parseXML()</code></td><td>Konvertiert XML-Text in ein JSON-Objekt</td></tr><tr><td><code>sendEmail()</code></td><td>Sendet eine E-Mail aus deiner Ninox App</td></tr><tr><td><code>validateXML()</code></td><td>Validiert XML-Text gegen ein angehängtes XSD-Schema</td></tr></tbody></table>

## Externe Dienste aufrufen

Nutze diese Funktionen, um jede REST API aufzurufen, Daten aus einem anderen Dienst zu holen oder Daten zwischen Ninox Datenbanken zu übertragen.

### Mit `http()` eine API aufrufen

Nutze `http()`, um eine Anfrage an einen externen Dienst zu senden.

Nutze es, wenn du:

* Daten aus einem anderen System holen oder Updates dorthin senden willst.
* Ninox mit REST APIs und anderen Ninox Datenbanken verbinden willst.

{% hint style="warning" %}
**Setze `http()` nicht in `do as transaction...end` ein**

Transaktionen nutzen eine Single-Thread-Schreibwarteschlange. Ein HTTP-Aufruf innerhalb einer Transaktion blockiert alle anderen Schreibvorgänge, bis die Anfrage abgeschlossen ist. Die App hängt nicht dauerhaft, aber jeder wartende Schreibvorgang wartet über die komplette Laufzeit des Aufrufs. Das kann die App langsam wirken lassen.
{% endhint %}

`http(method, url)`\
`http(method, url, body)`\
`http(method, url, header, body)`\
`http(method, url, header, body, files)`

* `method` die HTTP-Methode als Text, zum Beispiel `"GET"` oder `"POST"`
* `url` Textwert der Endpoint-URL
* `header` optionale Request-Header als JSON-Objekt, zum Beispiel `{ Authorization: token }`
* `body` optionaler Request-Body als JSON-Objekt
* `files` optionale Dateien zum Upload als `[file]`, wenn der aktuelle Ausführungskontext Datei-Uploads unterstützt (Server-Kontext)

{% hint style="warning" %}
**Beim Zugriff auf Ninox Daten ist ein Body erforderlich**

Wenn du `http()` nutzt, um auf Daten in Ninox zuzugreifen, musst du einen Body übergeben. Wenn keine Informationen im Body nötig sind, übergib ein leeres Objekt: `{}`. Zum Beispiel:

`http(“GET”, “https://api.ninox.com/v1/[...]”, {Authorization: “Bearer xxxx-xxxx-xxxx”, content-type: “application/json”}, {})`
{% endhint %}

#### **Schauen wir uns einige Beispiele an:**

```ninox
http("GET", "https://api.example.com/status")
```

Ruft den externen Dienst auf und gibt ein JSON-Antwortobjekt oder ein Fehlerobjekt zurück.

```ninox
let url := "https://api.ninox.com/v1/teams/" + teamId() +
           "/databases/" + databaseId() + "/tables/";
let apiKey := "Bearer abcd1234-0000-xxxx-zzzz-1a1aa1aaa1a111";

let response := http("GET", url, {
    Authorization: apiKey
});
response
```

Listet Tabellen aus der aktuellen Datenbank über die Ninox API oder gibt ein Fehlerobjekt zurück.

```ninox
do as server
   let url := "https://api.ninox.com/v1/teams/" + teamId() +
             "/databases/" + databaseId() + "/query";
   let apiKey := "Bearer abcd1234-0000-xxxx-zzzz-1a1aa1aaa1a111";
   
   let response := http("POST", url, {
             Authorization: apiKey, 
             "content-type": "application/json"
   }, {
    query: "select customers where status = 4"
   });
   response
end
```

Sendet eine POST-Anfrage und gibt passende Datensätze oder ein Fehlerobjekt zurück.

<pre class="language-ninox"><code class="lang-ninox"><strong>let response := do as server
</strong>    http("POST",
        "https://example.com/upload",
        { "content-type": "multipart/form-data" },
        null,
        [myFile])
end
</code></pre>

Lädt eine Datei zu einem externen Dienst hoch, wenn Datei-Uploads im aktuellen Ausführungskontext unterstützt werden.

Tipps:

* `http()` gibt ein JSON-Objekt zurück, keinen Klartext.
* Wenn du auf eine andere Ninox Datenbank zugreifst, brauchst du einen API-Key.
* Manche Endpoints erwarten selbst bei `GET`-Anfragen einen Body. Nutze `{}`, wenn der Ziel-Endpoint einen Body verlangt und du keine Felder senden musst.
* Datei-Uploads hängen vom Ausführungskontext ab.
* Teste Integrationsskripte mit echten Antworten des Dienstes, nicht nur mit Beispielausgaben.

## XML validieren und transformieren

Nutze diese Funktionen, wenn ein anderes System XML sendet oder erwartet, besonders wenn das XML zu einem definierten Schema passen muss.

### XML vor der Verwendung mit `validateXML()` prüfen

Nutze `validateXML()`, um einen XML-String gegen eine XSD-Schemadatei zu validieren. Das ist nützlich, wenn du XML aus einer externen Quelle erhältst und vor der weiteren Verarbeitung prüfen musst, ob die Struktur dem erwarteten Schema entspricht.

Nutze es, wenn du:

* ungültige XML-Strukturen vor dem Parsen erkennen willst.
* nachfolgende Logik vor fehlerhaften oder unerwarteten Eingaben schützen willst.

`validateXML(record, string, string)`

* `record` der Datensatz, der die angehängte XSD-Schemadatei enthält
* erster `string` der XML-Text, den du validieren willst
* zweiter `string` der Dateiname der XSD-Schemadatei, die am Datensatz angehängt ist

#### **Schauen wir uns einige Beispiele an:**

```ninox
let xsd := ---
<?xml version="1.0" encoding="UTF-8" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:simpleType name="ordertype">
    <xs:restriction base="xs:string"/>
</xs:simpleType>
<xs:element name="order" type="ordertype"/>
</xs:schema>
---;
let xsdFilename := "validation.xsd";
let xsdFile := createTextFile(this, xsd, xsdFilename);
let xmlString := ---
<?xml version="1.0" encoding="UTF-8"?>
<order
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="order.xsd">
</order>
---;
formatJSON(validateXML(this, xmlString, xsdFilename))
```

Gibt ein JSON-Objekt mit dem Validierungsergebnis und allen Fehlern zurück, zum Beispiel:

```json
{"result":true,"errors":[]}
```

```ninox
xmlString := ---
<?xml version="1.0" encoding="UTF-8"?>
<order id="123"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="order.xsd">
</order>
---;
formatJSON(validateXML(this, xmlString, xsdFilename))
```

Dieses Beispiel setzt das vorherige Beispiel fort.

Gibt ein JSON-Objekt mit `result: false` und den Validierungsfehlern zurück, zum Beispiel:

```json
{"result":false,"errors":[{"domain":17,"code":1827,"level":2,"column":0,"file":"","line":4,"str1":"id"}]}
```

{% hint style="info" %}
Wenn die angehängte Datei kein gültiges XSD-Schema enthält, gibt die Funktion `void` zurück.
{% endhint %}

### Mit `parseXML()` XML-Text in Daten umwandeln

Nutze `parseXML()`, um XML-Text in ein JSON-Objekt umzuwandeln, das du in Ninox prüfen kannst. Das ist besonders nützlich, wenn du Ninox per API mit externen Diensten verbindest und XML-Antworten verarbeiten musst. XML ist neben JSON ein gängiges Austauschformat.

Nutze es, wenn du:

* Werte aus einer XML-Antwort lesen willst.
* Felder aus importiertem XML extrahieren willst.
* XML für spätere Logik in strukturierte Daten umwandeln willst.

`parseXML(string)`

* `string` der XML-Text, den du in ein JSON-Objekt umwandeln willst

#### **Schauen wir uns ein Beispiel an:**

```ninox
let xml := "<?xml version=""1.0"" encoding=""UTF-8""?>
<note>
    <to>Jane Doe</to>
    <from>Ninox</from>
    <heading>Save the world!</heading>
    <body>Please save the world!</body>
</note>";
parseXML(xml)
```

Gibt ein JSON-Objekt zurück, das aus dem XML-Text erzeugt wurde, zum Beispiel:

```json
{
  "note": {
    "to": {
      "@": "Jane Doe"
    },
    "from": {
      "@": "Ninox"
    },
    "heading": {
      "@": "Save the world!"
    },
    "body": {
      "@": "Please save the world!"
    }
  }
}
```

{% hint style="info" %}
Wenn du ein XSD-Schema hast, validiere externes XML vor dem Parsen.
{% endhint %}

### Mit `formatXML()` XML-Text erstellen

Nutze `formatXML()`, um JSON-Daten in XML-Text umzuwandeln.

Nutze es, wenn du:

* XML für einen anderen Dienst vorbereiten willst.
* geparste Daten in lesbares XML umformatieren willst.

`formatXML(JSON)`\
`formatXML(JSON, boolean)`

* `JSON` die strukturierten Daten, die du in XML umwandeln willst
* `boolean` ob die Ausgabe zur besseren Lesbarkeit optisch strukturiert sein soll

#### **Schauen wir uns einige Beispiele an:**

```ninox
let x := parseXML("<root><item>1</item></root>");
formatXML(x, true)
```

Formatiert das geparste Objekt zurück in gut lesbaren XML-Text.

```ninox
formatXML({
    contact: {
        @type: "Person",
        firstName: {
            @: "Max"
        },
        lastName: {
            @: "Mustermann"
        },
        phone: [{
            @type: "Mobile",
            @: "(+1) (202) 123 45 67"
        }, {
            @type: "Phone",
            @: "+1.151.11 ++66 14 66"
        }]
    }
}, true)
```

Konvertiert das JSON-Objekt in strukturierten XML-Text. Schlüssel wie `@type` werden zu XML-Attributen. `@` wird zum Textwert des Knotens.

Tipps:

* Nutze die Pretty-Option, wenn Menschen das Ergebnis lesen sollen.
* Nutze kompakte Ausgabe, wenn das Zielsystem nur die Nutzlast braucht.
* Diese Funktion ist besonders nützlich für API-Integrationen, die XML statt JSON erwarten.

## E-Mail-Nachrichten senden

Nutze diese Funktion, um E-Mail-Adressen als klickbare Werte anzuzeigen.

### E-Mail-Werte mit `email()` verwenden

Nutze `email()`, um Text in einen E-Mail-Wert umzuwandeln.

Nutze die Funktion, wenn du:

* die E-Mail-App deines Geräts über eine E-Mail-Adresse öffnen willst.
* ein Logikfeld als E-Mail-Feld anzeigen willst.
* eine E-Mail-Adresse aus Text extrahieren und mit einem Klick nutzen willst.

`email(string)`

* `string` der Textwert für die E-Mail-Adresse. Gib ein `@` und eine gültige Domain an.

{% hint style="info" %}
Klicke in einem Feld oder Button auf <i class="fa-envelope">:envelope:</i>. Ninox öffnet die Standard-E-Mail-App deines Geräts.
{% endhint %}

#### **Schauen wir uns einige Beispiele an:**

```ninox
email(email_adresse)
```

Wandelt den Wert im Feld "E-Mail-Adresse" in einen E-Mail-Wert um.

```ninox
email("toni.winterfeld@firma.de")
```

Zeigt die Adresse als E-Mail-Wert mit klickbarer E-Mail-Aktion an.

Tipps:

* Formatiere E-Mail-Adressen korrekt. Andernfalls gibt die E-Mail-Aktion einen Fehler zurück.
* Eine korrekt formatierte Adresse öffnet die Standard-E-Mail-App deines Geräts.

## Mit `sendEmail()` eine Nachricht senden

Nutze `sendEmail()`, um eine E-Mail direkt aus Ninox zu senden. Die Funktion eignet sich für Buttons oder Automatisierungen, die eine ausgehende Nachricht aus einem Datensatz oder Workflow auslösen.

Nutze sie, wenn du:

* Bestellbestätigungen oder andere E-Mails aus Ninox senden willst.
* eine Benachrichtigung über einen Button oder eine Automatisierung auslösen willst.
* Anhänge mit einer Nachricht senden willst.

`sendEmail(JSON)`

* `JSON` die E-Mail-Definition, zum Beispiel:
  * `from` E-Mail-Adresse des Absenders
  * `to` E-Mail-Adresse des Empfängers
  * `replyTo` Antwortadresse – *optional*
  * `cc` Empfänger einer Kopie – *optional*
  * `bcc` Empfänger einer Blindkopie – *optional*
  * `subject` Betreffzeile
  * `text` Klartextinhalt
  * `html` HTML-Inhalt
  * `attachments` anzuhängende Datei oder Dateien – *optional*

#### **Schauen wir uns einige Beispiele an:**

```ninox
sendEmail({
    from: "support@beispiel.com",
    to: "Kunde123@beispiel.com",
    cc: "Kontact456@beispiel.com",
    bcc: "archiv@beispiel.com",
    subject: "Danke für Ihre E-Mail",
    text: "Wir haben Ihre Anfrage bezüglich einer weiteren Kopie Ihrer Rechnung erhalten",
    html: "<b> Ein Text mit markup </b>",
    attachments: rechnung_dateifeld
})
```

Sendet eine E-Mail von `support@beispiel.com` und hängt die Datei an, die im Dateifeld "Rechnung" angezeigt wird.

Nutze `replyTo`, wenn Antworten an eine andere Adresse als `from` gehen sollen.

```ninox
sendEmail({
    from: "support@beispiel.com",
    to: "Kunde123@beispiel.com",
    replyTo: "antwot@beispiel.com",
    cc: "Kontact456@beispiel.com",
    bcc: "archiv@example.com",
    subject: "Danke für Ihre E-Mail",
    text: "Wir haben Ihre Anfrage bezüglich einer weiteren Kopie Ihrer Rechnung erhalten",
    html: "<b> Ein Text mit markup </b>",
    attachments: rechnung_dateifeld
})
```

Sendet dieselbe E-Mail. Antworten gehen jedoch an `antwort@beispiel.com`.

Tipps:

* Der Absender muss Mitglied des Arbeitsbereichs sein.
* `cc`, `bcc`, `replyTo` und `attachments` sind optional.
* Es gibt keine sofortige Zustellbestätigung. Die gesendete E-Mail wird nicht in der Datenbank gespeichert.
* Formatiere Summen und Daten mit `format()`, bevor du sie in die Nachricht einfügst.

{% hint style="info" %}
Das Verhalten von Integrationen kann von deiner Umgebung, dem Client und verbundenen Diensten abhängen. Prüfe HTTP- und E-Mail-Workflows in derselben Umgebung, die deine Nutzer in der Produktion verwenden.
{% endhint %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.ninox.com/ninox-scripting/de/automate-your-workflows/work-with-functions/integration-and-http.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.