KI per Schnittstelle an Excel anbinden: Claude API mit VBA

Im Chatfenster einer KI lassen sich einzelne Texte bequem auswerten. Bei 500 Kundenrückmeldungen, Artikelbeschreibungen oder Freitexten aus einem Formular wird das Kopieren mühsam. Über die Schnittstelle (API) fragt Excel die KI selbst und schreibt die Antwort in die Tabelle.

Kurz gesagt

  • Sie brauchen ein Konto beim Anbieter mit einem API-Schlüssel. Die Nutzung wird nach Menge abgerechnet, ein Abo für den Chat genügt nicht.
  • Der Schlüssel gehört in eine Umgebungsvariable von Windows, nicht in die Arbeitsmappe.
  • Ein Makro schickt jeden Text einzeln an die KI und schreibt das Ergebnis als Wert in die Zelle. Eine Benutzerfunktion, die bei jeder Neuberechnung neu fragt, ist ungeeignet.
  • Antworten der KI werden gegen eine feste Liste geprüft, bevor sie weiterverarbeitet werden.

Voraussetzungen

  1. In der Console von Anthropic (console.anthropic.com) ein Konto anlegen, Zahlungsdaten hinterlegen und einen API-Schlüssel erzeugen. Bei anderen Anbietern wie OpenAI ist der Weg ähnlich, Adresse, Kopfzeilen und Antwortformat unterscheiden sich aber.
  2. Den Schlüssel als Umgebungsvariable speichern: Windows-Taste, „Umgebungsvariablen für dieses Konto bearbeiten“ suchen, unter Benutzervariablen „Neu“, Name ANTHROPIC_API_KEY, Wert der Schlüssel.
  3. Excel neu starten, damit es die neue Variable sieht.

So bleibt der Schlüssel aus der Datei heraus. Wer die Mappe weitergibt, gibt den Schlüssel nicht mit, und jeder Anwender nutzt seinen eigenen.

Der VBA-Baustein

Fügen Sie den Code über Alt+F11 > Einfügen > Modul ein:

Option Explicit

' Anfrage an die Claude API von Anthropic (Messages API).
' Der API-Schlüssel steht in der Umgebungsvariablen ANTHROPIC_API_KEY, nie in der Mappe.
Private Const API_URL As String = "https://api.anthropic.com/v1/messages"
Private Const API_VERSION As String = "2026-10-21"
Private Const MODELL As String = "claude-opus-5-5"

Public Function KiFragen(ByVal frage As String, Optional ByVal maxTokens As Long = 256) As String
    Dim schluessel As String, http As Object, antwort As String
    schluessel = Environ$("ANTHROPIC_API_KEY")
    If Len(schluessel) = 0 Then Err.Raise vbObjectError + 1, , "Umgebungsvariable ANTHROPIC_API_KEY fehlt."

    Set http = CreateObject("WinHttp.WinHttpRequest.5.1")
    http.SetTimeouts 5000, 10000, 30000, 120000   ' Auflösen, Verbinden, Senden, Antwort (ms)
    http.Open "POST", API_URL, False
    http.SetRequestHeader "x-api-key", schluessel
    http.SetRequestHeader "anthropic-version", API_VERSION
    http.SetRequestHeader "content-type", "application/json"
    http.Send AnfrageJson(frage, maxTokens)

    antwort = Utf8Text(http.ResponseBody)   ' Antwort ausdrücklich als UTF-8 lesen
    If http.Status <> 200 Then
        Err.Raise vbObjectError + 2, , "API-Fehler " & http.Status & ": " & JsonWert(Kompakt(antwort), "message")
    End If
    KiFragen = AntwortAuswerten(antwort)
End Function

' Baut den Inhalt der Anfrage. Aufwand "low" hält Antwortzeit und Kosten bei einfachen Aufgaben gering.
Public Function AnfrageJson(ByVal frage As String, ByVal maxTokens As Long) As String
    AnfrageJson = "{""model"":""" & MODELL & """,""max_tokens"":" & maxTokens & _
        ",""output_config"":{""effort"":""low""}" & _
        ",""messages"":[{""role"":""user"",""content"":""" & JsonText(frage) & """}]}"
End Function

' Liefert den Text der Antwort. Die Antwort enthält eine Liste von Blöcken ("content"). Vor dem Text
' kann ein Denkblock stehen, deshalb werden nur Blöcke vom Typ "text" ausgewertet, gleich in welcher
' Reihenfolge ihre Felder stehen. Abgebrochene oder abgelehnte Antworten lösen einen Fehler aus.
Public Function AntwortAuswerten(ByVal antwort As String) As String
    Dim json As String, block As Variant, ergebnis As String, gefunden As Boolean
    json = Kompakt(antwort)
    Select Case JsonWert(json, "stop_reason")
        Case "refusal": Err.Raise vbObjectError + 3, , "Die KI hat die Anfrage abgelehnt."
        Case "max_tokens": Err.Raise vbObjectError + 5, , "Die Antwort wurde abgeschnitten (max_tokens zu klein)."
    End Select
    For Each block In Bloecke(json)
        If InStr(1, block, """type"":""text""") > 0 Then
            ergebnis = ergebnis & JsonWert(CStr(block), "text")
            gefunden = True
        End If
    Next block
    If Not gefunden Then Err.Raise vbObjectError + 4, , "Die Antwort enthält keinen Text."
    AntwortAuswerten = ergebnis
End Function

' Entfernt Leerzeichen und Zeilenumbrüche außerhalb von Zeichenketten.
Private Function Kompakt(ByVal json As String) As String
    Dim i As Long, z As String, inText As Boolean, ergebnis As String
    For i = 1 To Len(json)
        z = Mid$(json, i, 1)
        If inText Then
            ergebnis = ergebnis & z
            If z = "\" Then
                i = i + 1: ergebnis = ergebnis & Mid$(json, i, 1)   ' maskiertes Zeichen übernehmen
            ElseIf z = """" Then
                inText = False
            End If
        ElseIf z = """" Then
            inText = True: ergebnis = ergebnis & z
        ElseIf z <> " " And z <> vbTab And z <> vbCr And z <> vbLf Then
            ergebnis = ergebnis & z
        End If
    Next i
    Kompakt = ergebnis
End Function

' Zerlegt das Feld "content" in seine Blöcke (je ein Objekt in geschweiften Klammern).
Private Function Bloecke(ByVal json As String) As Collection
    Dim liste As New Collection, pos As Long, i As Long, z As String
    Dim tiefe As Long, inText As Boolean, start As Long
    Set Bloecke = liste
    pos = InStr(1, json, """content"":[")
    If pos = 0 Then Exit Function
    For i = pos + Len("""content"":[") To Len(json)
        z = Mid$(json, i, 1)
        If inText Then
            If z = "\" Then
                i = i + 1
            ElseIf z = """" Then
                inText = False
            End If
        ElseIf z = """" Then
            inText = True
        ElseIf z = "{" Then
            If tiefe = 0 Then start = i
            tiefe = tiefe + 1
        ElseIf z = "}" Then
            tiefe = tiefe - 1
            If tiefe = 0 Then liste.Add Mid$(json, start, i - start + 1)
        ElseIf z = "]" And tiefe = 0 Then
            Exit For
        End If
    Next i
End Function

' Liest den ersten Textwert zum Schlüssel aus kompaktem JSON und wandelt Escapes zurück.
Public Function JsonWert(ByVal json As String, ByVal schluessel As String) As String
    Dim pos As Long, i As Long, z As String, ergebnis As String
    pos = InStr(1, json, """" & schluessel & """:""")
    If pos = 0 Then Exit Function
    i = pos + Len(schluessel) + 4
    Do While i <= Len(json)
        z = Mid$(json, i, 1)
        If z = """" Then Exit Do
        If z = "\" Then
            i = i + 1
            Select Case Mid$(json, i, 1)
                Case "n": z = vbLf
                Case "r": z = vbCr
                Case "t": z = vbTab
                Case "b": z = Chr$(8)
                Case "f": z = Chr$(12)
                Case "u": z = ChrW$(CLng("&H" & Mid$(json, i + 1, 4))): i = i + 4
                Case Else: z = Mid$(json, i, 1)   ' Anführungszeichen, Backslash, Schrägstrich
            End Select
        End If
        ergebnis = ergebnis & z
        i = i + 1
    Loop
    JsonWert = ergebnis
End Function

' Maskiert einen Text für JSON. Steuerzeichen und alle Zeichen außerhalb von ASCII (Umlaute, Euro)
' werden als \uXXXX geschrieben, so kommt der Text unabhängig von der Codepage richtig an.
Public Function JsonText(ByVal text As String) As String
    Dim i As Long, c As Long, ergebnis As String
    For i = 1 To Len(text)
        c = AscW(Mid$(text, i, 1)) And &HFFFF&
        Select Case c
            Case 34: ergebnis = ergebnis & "\"""
            Case 92: ergebnis = ergebnis & "\\"
            Case 10: ergebnis = ergebnis & "\n"
            Case 13: ergebnis = ergebnis & "\r"
            Case 9: ergebnis = ergebnis & "\t"
            Case Is < 32, Is > 126: ergebnis = ergebnis & "\u" & Right$("000" & Hex$(c), 4)
            Case Else: ergebnis = ergebnis & ChrW$(c)
        End Select
    Next i
    JsonText = ergebnis
End Function

' Wandelt die Bytes der Antwort von UTF-8 in einen Text.
Public Function Utf8Text(ByVal bytes As Variant) As String
    Dim st As Object
    Set st = CreateObject("ADODB.Stream")
    st.Type = 1          ' binär
    st.Open
    st.Write bytes
    st.Position = 0
    st.Type = 2          ' Text
    st.Charset = "utf-8"
    Utf8Text = st.ReadText
    st.Close
End Function

KiFragen("Fasse in einem Satz zusammen: ...") liefert die Antwort als Text. Die Bausteine im Einzelnen:

  • Kopfzeilen: x-api-key trägt den Schlüssel, anthropic-version legt die Version der Schnittstelle fest, content-type kennzeichnet den Inhalt als JSON.
  • Modell und Aufwand: Das Beispiel verwendet claude-opus-5-5. Für einfache Einordnungen genügt meist das günstigere claude-haiku-5-5, dafür ändern Sie nur die Konstante MODELL. "effort":"low" sorgt dafür, dass das Modell bei einfachen Aufgaben nicht lange nachdenkt.
  • max_tokens begrenzt die Länge der Antwort. 256 reicht für ein Wort oder einen Satz, für Zusammenfassungen setzen Sie den Wert höher.
  • Antwort auslesen: Die Antwort enthält eine Liste von Blöcken. Vor dem eigentlichen Text kann ein Block mit den Überlegungen des Modells stehen. AntwortAuswerten entfernt zuerst Leerzeichen und Zeilenumbrüche außerhalb von Zeichenketten, zerlegt die Liste in einzelne Blöcke und übernimmt nur Blöcke vom Typ „text“. Die Reihenfolge der Felder in einem Block spielt dabei keine Rolle.
  • Abbruch und Ablehnung: Endet die Antwort mit "stop_reason":"max_tokens", war max_tokens zu klein und der Text ist abgeschnitten. Lehnt das Modell ab, steht dort "refusal". In beiden Fällen löst der Code einen Fehler aus, statt einen unvollständigen oder leeren Text zu liefern.
  • Umlaute: JsonText schreibt Umlaute, das Eurozeichen und Steuerzeichen als \uXXXX. Die Anfrage besteht so nur aus einfachen Zeichen und kommt unabhängig von der Codepage richtig an. Die Antwort liest Utf8Text ausdrücklich als UTF-8.

Für Textantworten reicht dieser schlanke Leser. Wer verschachtelte Strukturen auswerten will, etwa mehrere Felder als JSON, nimmt besser einen vollständigen JSON-Parser für VBA.

Beispiel: Rückmeldungen einordnen

In Spalte A stehen Kundenrückmeldungen, in Spalte B soll die Kategorie erscheinen:

Option Explicit

' Ordnet jedem Text in Spalte A eine Kategorie zu und schreibt sie in Spalte B.
' Zeilen mit Kategorie oder dem Vermerk "Prüfen:" werden übersprungen, so kostet ein zweiter Lauf wenig.
' Zeilen mit "Fehler:" (etwa bei einer Störung der Schnittstelle) versucht der nächste Lauf erneut.
Public Sub KategorienZuordnen()
    Const KATEGORIEN As String = "Lieferung, Rechnung, Qualität, Bedienung, Sonstiges"
    Dim ws As Worksheet, zeile As Long, letzte As Long, frage As String, antwort As String
    Set ws = ActiveSheet
    letzte = ws.Cells(ws.Rows.Count, "A").End(xlUp).Row
    For zeile = 2 To letzte
        If Len(ws.Cells(zeile, "A").Value) > 0 And (Len(ws.Cells(zeile, "B").Value) = 0 _
                Or Left$(ws.Cells(zeile, "B").Value, 7) = "Fehler:") Then
            frage = "Ordne die Kundenrückmeldung genau einer Kategorie zu: " & KATEGORIEN & _
                    ". Antworte nur mit dem Namen der Kategorie." & vbLf & vbLf & ws.Cells(zeile, "A").Value
            On Error Resume Next
            antwort = KiFragen(frage)
            If Err.Number <> 0 Then antwort = "Fehler: " & Err.Description
            On Error GoTo 0
            ws.Cells(zeile, "B").Value = PruefeKategorie(Trim$(antwort), KATEGORIEN)
            DoEvents
        End If
    Next zeile
End Sub

' Übernimmt nur Antworten aus der vorgegebenen Liste. Alles andere wird zur Nacharbeit markiert.
Public Function PruefeKategorie(ByVal antwort As String, ByVal liste As String) As String
    Dim k As Variant
    If Left$(antwort, 7) = "Fehler:" Then PruefeKategorie = antwort: Exit Function
    For Each k In Split(liste, ",")
        If StrComp(Trim$(k), antwort, vbTextCompare) = 0 Then PruefeKategorie = Trim$(k): Exit Function
    Next k
    PruefeKategorie = "Prüfen: " & antwort
End Function

Zwei Dinge machen das Makro alltagstauglich:

  • Nur offene Zeilen: Zeilen mit Kategorie oder dem Vermerk „Prüfen: …“ werden übersprungen. Zeilen mit „Fehler: …“ versucht der nächste Lauf erneut. Bricht der Lauf ab oder kommen neue Zeilen hinzu, kostet ein zweiter Lauf nur die offenen Anfragen.
  • Prüfung der Antwort: PruefeKategorie übernimmt nur Namen aus der vorgegebenen Liste, auch bei anderer Groß- und Kleinschreibung. Antwortet die KI mit einer eigenen Kategorie, steht in der Zelle „Prüfen: …“. Fehler beim Aufruf landen als „Fehler: …“ in der Zelle, der Lauf geht mit der nächsten Zeile weiter.

Die Anweisung „Antworte nur mit dem Namen der Kategorie“ ist wichtig. Ohne sie antwortet die KI gern in ganzen Sätzen.

Warum keine Benutzerfunktion

Naheliegend wäre eine Formel wie =KI(A2). Excel berechnet Formeln aber bei vielen Gelegenheiten neu, etwa beim Öffnen oder nach Änderungen. Jede Neuberechnung wäre ein neuer, kostenpflichtiger Aufruf, und Excel wartet bei jedem auf die Antwort. Das Makro schreibt dagegen Werte, die stehen bleiben.

Kosten und Datenschutz

Abgerechnet wird nach Tokens, grob nach der Länge von Anfrage und Antwort. Eine kurze Rückmeldung mit einem Wort als Antwort kostet nur Bruchteile eines Cents, bei vielen tausend Zeilen und langen Texten kommt aber ein Betrag zusammen. Testen Sie mit zehn Zeilen und prüfen Sie den Verbrauch in der Console, bevor Sie die ganze Liste verarbeiten. In der Console lässt sich auch ein Ausgabelimit festlegen.

Die Texte verlassen bei jedem Aufruf das Unternehmen. Für personenbezogene Daten brauchen Sie eine Grundlage nach DSGVO und einen Vertrag zur Auftragsverarbeitung mit dem Anbieter. Mehr dazu im Beitrag KI im Unternehmen: Dienste wählen, Regeln, EU-KI-Verordnung.

Typische Fehler

  • Fehler 401: Der Schlüssel fehlt, ist falsch oder wurde widerrufen. Prüfen Sie die Umgebungsvariable und starten Sie Excel nach einer Änderung neu.
  • Fehler 400: Die Anfrage ist ungültig, etwa durch ungültiges JSON. Die Meldung der Schnittstelle steht im Fehlertext. Ältere Beispiele aus dem Netz senden oft temperature, die neue Version der Schnittstelle nicht mehr annimmt.
  • Fehler 429 oder 529: Zu viele Anfragen in kurzer Zeit oder die Schnittstelle ist überlastet. Warten Sie einige Sekunden und versuchen Sie es erneut, bei großen Listen mit einer kurzen Pause zwischen den Aufrufen.
  • Zeitüberschreitung: Lange Antworten brauchen Zeit. Die Werte in SetTimeouts sind in Millisekunden, die Antwortzeit steht auf zwei Minuten.
  • Schlüssel im Code: Ein Schlüssel als Konstante im Modul landet mit jeder Kopie der Mappe bei anderen. Wer das einmal getan hat, widerruft den Schlüssel in der Console und erzeugt einen neuen.

Passende Beiträge

KI im eigenen Betrieb

KI, die in Ihre Abläufe passt.

Belege, E-Mails und PDFs automatisch erfassen und Excel-Lösungen schneller umsetzen. Am Anfang steht eine kurze Potenzialanalyse, damit klar ist, was sich lohnt.