Sie sehen gerade einen Platzhalterinhalt von YouTube. Um auf den eigentlichen Inhalt zuzugreifen, klicken Sie auf die Schaltfläche unten. Bitte beachten Sie, dass dabei Daten an Drittanbieter weitergegeben werden.
Mehr InformationenKontist Custom Connector Mit Swagger YAML Erstellen
Mit einem Kontist Custom Connector kannst du die Kontist API direkt in deine Automatisierungen integrieren. Statt den OAuth2 Flow manuell umzusetzen und Refresh Tokens selbst zu verwalten, nutzt du einfach ein fertiges Swagger YAML. Dadurch sparst du Zeit, reduzierst Fehler und kannst sofort mit GraphQL Queries arbeiten.
Der Ansatz ist bewusst simpel: Du erstellst einen leeren Custom Connector, wechselst in den Swagger Editor und kopierst den YAML Code ein. Anschliessend hinterlegst du deine OAuth2 Daten, testest die Verbindung und nutzt die Aktion direkt in deinen Flows. Somit wird aus einer eher sperrigen API-Anbindung ein sauberer, wiederverwendbarer Baustein.
Warum dieser Weg besser ist als eigener OAuth Code
Bei OAuth2 klingt vieles erst einmal harmlos. In der Praxis verlierst du aber schnell Zeit mit Redirect URLs, Authorization Codes, Access Tokens, Refresh Tokens und Fehlern beim erneuten Abrufen eines Tokens. Genau hier hilft der Custom Connector, weil die Token-Verwaltung nicht mehr in deinem eigenen Code liegt.
Du musst also keinen eigenen kleinen Auth-Service bauen, keine Tokens in Variablen oder Tabellen speichern und auch keine Refresh-Logik planen. Gleichzeitig bleibt dein Flow lesbar, weil die Authentifizierung sauber im Connector steckt. Dadurch kannst du dich auf deine eigentliche Logik konzentrieren: Kontostand abrufen, Transaktionen lesen, Belege laden oder Daten in andere Systeme schieben.
Die Grundidee: Ein Endpoint, viele GraphQL Queries
Kontist stellt eine GraphQL API bereit. Das bedeutet, dass du nicht viele einzelne REST-Endpunkte pflegen musst. Stattdessen sendest du deine Anfrage an einen zentralen Endpoint und bestimmst im Body, welche Daten du brauchst. Das macht den Connector sehr schlank, weil eine einzige Aktion reicht, um verschiedene Abfragen zu fahren.
Der Endpoint liegt bei https://api.kontist.com/api/graphql. Im Swagger wird daraus der Host api.kontist.com, der Base Path /api und der Pfad /graphql. Dadurch entsteht im Connector eine POST-Aktion, in der du deine Query als JSON Body übergibst. Gleichzeitig wird der Header content-type: application/json intern gesetzt, damit deine Anfrage sauber verarbeitet wird.
Voraussetzungen für den Kontist Custom Connector
Bevor du loslegst, brauchst du einen Zugang zum Kontist Developer Portal und einen registrierten OAuth2 Client. Dort bekommst du die Client ID und das Client Secret. Ausserdem brauchst du später die Redirect URL aus deinem Custom Connector, weil diese exakt im Kontist Client Management hinterlegt werden muss.
Wichtig ist ausserdem der Scope offline. Genau dieser Scope ist entscheidend, damit der Connector einen Refresh Token nutzen kann. Ohne diesen Scope kann es passieren, dass die Verbindung zwar erst funktioniert, spaeter aber nicht mehr automatisch erneuert wird.
Custom Connector Blank Erstellen Und In Den Swagger Mode Wechseln
Zuerst oeffnest du die Custom Connector Oberflaeche in deiner Umgebung. Dort erstellst du keinen Import aus einer OpenAPI Datei, sondern waehlt bewusst Create from blank. Dadurch startest du mit einer leeren Vorlage und hast gleichzeitig die volle Kontrolle ueber die komplette Definition.
Nach dem Namen, zum Beispiel Kontist Connector, wechselst du in den Swagger Editor. Dort entfernst du den vorhandenen Beispiel-Code komplett. Anschliessend kopierst du den bereitgestellten YAML Code vollstaendig in den Editor. Achte dabei auf die Einrueckungen, weil YAML bei Leerzeichen sehr genau ist.
Nach dem Speichern wird der Connector aus deiner Swagger Definition aufgebaut. Du siehst dann die Aktion Fetch GraphQL mit der POST-Methode auf /graphql. Gleichzeitig ist OAuth2 bereits als Security Definition enthalten, sodass du im naechsten Schritt nur noch die OAuth Werte sauber eintragen musst.
Swagger YAML Für Den Kontist Connector
Der folgende YAML Code ist die Basis für den Connector. Du kannst ihn direkt kopieren und im Swagger Editor einfügen. Danach speicherst du den Connector und kontrollierst kurz, ob die Aktion und die Security Definition korrekt angezeigt werden.
Power Automate |
swagger: '2.0'
info:
title: Kontist
description: >-
Kontist Business Bank - all about yout accounts, clients, statemants,
subscriptions, transactions, transfers and users.
version: '1.0'
host: api.kontist.com
basePath: /api
schemes:
- https
consumes: []
produces: []
paths:
/graphql:
post:
responses:
default:
description: default
schema: {}
summary: Fetch GraphQL
operationId: FetchGraphQl
parameters:
- name: content-type
in: header
required: true
type: string
default: application/json
x-ms-visibility: internal
- name: body
in: body
required: true
schema:
type: object
properties:
query:
type: string
description: query
x-ms-visibility: important
x-ms-visibility: important
description: post custom query
definitions: {}
parameters: {}
responses: {}
securityDefinitions:
oauth2-auth:
type: oauth2
flow: accessCode
authorizationUrl: https://api.kontist.com/api/oauth/authorize
tokenUrl: https://api.kontist.com/api/oauth/token
scopes:
offline: offline
security:
- oauth2-auth:
- offline
tags: []
Security Tab – OAuth2 im Connector einrichten
Wechsle in den Bereich Security. Dort sollte OAuth2 bereits automatisch erkannt sein. Als Identity Provider wählst du Generic OAuth 2. Die Authorization URL und die Token URL sind in der Regel bereits korrekt vorausgefüllt, da sie aus der Kontist API übernommen werden. Beide Felder erhalten den Wert: https://api.kontist.com/api/oauth/token.
Im Feld Scope trägst du zusätzlich den Wert offline ein, um keine Einschränkungen bei der Autorisierung zu haben. Speichere den Custom Connector zunächst mit einer beliebigen Client ID und einem beliebigen Client Secret. Dadurch wird die Redirect URL generiert, die du im nächsten Schritt benötigst.
Kopiere anschließend die generierte Redirect URL aus dem Custom Connector und hinterlege sie im Kontist Developer Portal im Client Management.
Erst danach erhältst du deine tatsächliche Client ID für dein Client Secret.
Gehe nun zurück in den Custom Connector und öffne erneut den Security-Tab. Trage dort deine echte Client ID und dein Client Secret ein und speichere die Änderungen.
Verbindung Testen Und Refresh Token Automatisch Nutzen
Im Bereich Test erstellst du eine neue Verbindung. Dabei wirst du zur Kontist Anmeldung weitergeleitet. Nach der Anmeldung bestätigst du den Zugriff und landest wieder im Connector. Wenn alles passt, ist die Verbindung gespeichert und kann in Flows genutzt werden.
Der wichtigste Vorteil kommt danach: Du musst den Refresh Token nicht selbst über Code holen. Der Connector übernimmt das Handling für dich, sofern der OAuth Flow und der Scope korrekt gesetzt sind. Dadurch wird deine Lösung stabiler, weil der Token-Prozess nicht in jedem Flow neu gebaut werden muss.
 |
 |
Autorisierung bei Kontist
Bestätigung der Verbindung in Power Automate
Erste GraphQL Query Im Testbereich Ausführen
Zum Testen reicht eine kleine Query. Im Body übergibst du ein JSON Objekt mit dem Feld query. Dadurch kann der Connector die Anfrage an den GraphQL Endpoint senden und die Antwort direkt anzeigen.
{ viewer { firstName lastName email } }
Power Apps |
Set(
varViewer,
With(
{response: Kontist.FetchGraphQl({query: "{ viewer { firstName lastName email } }"}).data.viewer},
{
firstName: Text(response.firstName),
lastName: Text(response.lastName),
email: Text(response.email)
}
)
);Testanfrage über PowerFx inklusive Parsing
Wenn diese Anfrage eine Antwort liefert, steht die Basis. Danach kannst du Schritt für Schritt weitere Felder ergänzen. Gerade bei GraphQL ist das praktisch, weil du nur die Daten abfragst, die du wirklich brauchst. Somit bleiben Antworten schlanker und deine Flows werden leichter wartbar.
Kontostand abrufen
Mit diesem Call holst du dir richtig nützliche Infos zu deinem Kontist-Konto – und zwar nicht einfach nur den Kontostand, sondern die volle Steuer- und Finanzübersicht. Stell dir vor: Du willst auf einen Blick sehen, wie viel Kohle wirklich dir gehört, wie viel ans Finanzamt geht und was noch unklar ist – genau das liefert dir diese Abfrage.
Der Einstieg ist viewer, also der eingeloggte Nutzer. Dahinter steckt mainAccount, dein Hauptkonto. Und dort gibt’s das Objekt stats, in dem richtig viele spannende Zahlen stecken:
- accountBalance zeigt dir deinen aktuellen Kontostand – ganz klassisch.
- yours ist der Betrag, der dir tatsächlich bleibt, wenn man die ganzen Steuerverpflichtungen rausrechnet.
- unknown sind Beträge, die noch nicht richtig zugeordnet wurden – also potenziell noch in der Klärung.
- main ist wahrscheinlich der „echte“ Netto-Saldo deines Kontos.
- vatTotal, vatAmount, vatMissing – das ist deine Umsatzsteuer im Überblick: Gesamt, laufend, und was noch fehlt.
- Und dann die Einkommenssteuer: taxTotal, taxCurrentYearAmount, taxPastYearsAmount und taxMissing. Alles, was du wissen willst (oder lieber verdrängen würdest), rund um deine Steuerlast.
Mit einer einzigen Query bekommst du also eine ziemlich komplette Einschätzung deiner finanziellen Lage – ideal, wenn du in Power Automate automatische Checks baust oder dir in Power Apps einen schnellen Überblick schaffen willst.
{
viewer {
mainAccount {
stats {
accountBalance
yours
unknown
main
vatTotal
vatAmount
vatMissing
taxTotal
taxCurrentYearAmount
taxPastYearsAmount
taxMissing
}
}
}
}Transaktionen abrufen
Na klar – das hier ist der Power-Move, wenn du Transaktionen aus deinem Kontist-Konto abrufen willst. Und zwar nicht irgendwie, sondern richtig detailliert. Du bekommst mit dieser Abfrage nicht nur eine Liste an Buchungen, sondern alles, was dazugehört – inklusive Kategorien, Belege, Gebühren und sogar Splits.
Der Einstieg ist wieder viewer, also der aktuell eingeloggte Benutzer. Von da aus geht’s direkt zu mainAccount, deinem Hauptkonto. Und dann wird’s spannend: Über transactions holst du dir alle Transaktionen der letzten 500 Tage. Das Filterkriterium basiert auf dem Feld valutaDate, also dem Wertstellungsdatum.
Jetzt zur Rückgabe: Die Struktur ist klassisch GraphQL – du bekommst pageInfo, was dir sagt, ob es noch mehr Seiten gibt (für Pagination), und dann die eigentlichen Transaktionen unter edges > node.
Was steckt im node drin? Alles, was du für eine saubere Buchhaltung oder eine App-Auswertung brauchst:
Beträge, Kategorien, IBANs, Namen, Beschreibungen
Buchungs- und Wertstellungsdatum
Hinweise zur manuellen Kategorisierung oder Splits
Anhänge und Dokumente wie Belege und Rechnungen
Vorhersagen zur Kategorie und Buchungszeitpunkt
Gebühren, Lastschriftinfos und Währungsdaten
Kurz gesagt: Diese Query bringt das volle Transaktionspaket auf dein Dashboard. Ideal, wenn du z. B. in Power Apps eine Timeline baust oder in Power Automate automatisch prüfen willst, ob neue Ausgaben da sind, die noch keine Belege haben.
Du willst mehr Kontrolle über deine Finanzen? Diese Query ist dein Schweizer Taschenmesser.
{
viewer {
mainAccount {
transactions (filter:{
valutaDate_gt: "@{addDays(utcnow(),-500,'yyyy-MM-dd')}"
}){
pageInfo {
startCursor
endCursor
hasPreviousPage
hasNextPage
}
edges {
node {
amount
actionReason
iban
name
category
createdAt
valutaDate
receiptName
bookingDate
personalNote
mandateNumber
paymentMethod
originalAmount
categorizationType
canBeRecategorized
documentDownloadUrl
merchantCategoryCode
userSelectedBookingDate
categoryCodeTranslation
predictedUserSelectedBookingDate
id
description
purpose
type
e2eId
merchantCountryCode
source
fees {
type
status
unitAmount
usedAt
}
splits {
id
uuid
amount
category
userSelectedBookingDate
categorizationType
}
assets {
id
name
filetype
assetableId
path
thumbnail
fullsize
}
directDebitFees {
id
type
name
amount
usedAt
invoiceStatus
}
predictedCategory
documentNumber
documentPreviewUrl
documentDownloadUrl
documentType
foreignCurrency
categoryCode
verified
categoryCodeTranslation
recurlyInvoiceNumber
transactionAssets {
id
name
filetype
assetableId
path
thumbnail
fullsize
}
}
}
}
}
}
}
Power Apps |
ClearCollect(
colTransactions,
With(
{
response: Kontist.FetchGraphQl(
{
query: "{
viewer {
mainAccount {
transactions (filter:{
valutaDate_gt: """ & Text(
DateAdd(
Today(),
-365,
TimeUnit.Days
),
"yyyy-mm-dd"
) & """
}){
pageInfo {
startCursor
endCursor
hasPreviousPage
hasNextPage
}
edges {
node {
amount
actionReason
iban
name
category
createdAt
valutaDate
receiptName
bookingDate
personalNote
mandateNumber
paymentMethod
originalAmount
categorizationType
canBeRecategorized
documentDownloadUrl
merchantCategoryCode
userSelectedBookingDate
categoryCodeTranslation
predictedUserSelectedBookingDate
id
description
purpose
type
e2eId
merchantCountryCode
source
fees {
type
status
unitAmount
usedAt
}
splits {
id
uuid
amount
category
userSelectedBookingDate
categorizationType
}
assets {
id
name
filetype
assetableId
path
thumbnail
fullsize
}
directDebitFees {
id
type
name
amount
usedAt
invoiceStatus
}
predictedCategory
documentNumber
documentPreviewUrl
documentDownloadUrl
documentType
foreignCurrency
categoryCode
verified
categoryCodeTranslation
recurlyInvoiceNumber
transactionAssets {
id
name
filetype
assetableId
path
thumbnail
fullsize
}
}
}
}
}
}
}"
}
).data.viewer.mainAccount.transactions
},
{
pageInfo: {
startCursor: Text(response.pageInfo.startCursor),
endCursor: Text(response.pageInfo.endCursor)
},
edges: ForAll(
response.edges As _edge,
{
amount: Value(_edge.node.amount),
category: Text(_edge.node.category),
createdAt: DateTimeValue(_edge.node.createdAt)
}
)
}
).edges
);
Belege herunterladen
Jetzt, wo du dir die Transaktionen inklusive aller Anhänge sauber in deinen Flow geholt hast, wird’s richtig praktisch. Denn jede Transaktion bringt – wenn vorhanden – auch gleich ihre Belege mit. Diese findest du im Feld transactionAssets, und darin wiederum steckt die Eigenschaft fullsize.
Und genau hier kannst du ansetzen: Du gehst einfach mit einer Apply to each-Schleife über die Transaktionen, zum Beispiel mit
@{body('Query_Kontist_for_Transactions')?['data']?['viewer']?['mainAccount']?['transactions']?['edges']}
Dann prüfst du, ob das Feld transactionAssets belegt ist, und kannst über eine zweite Schleife direkt an die Dateien ran. Um den eigentlichen Beleg herunterzuladen, brauchst du nur einen simplen HTTP-Call – keine weitere Authentifizierung, keine Komplexität.
Du nimmst einfach die URL aus
@{items('Apply_to_each_transactionAssets')?['fullsize']}
und rufst sie mit einem HTTP GET auf. Das war’s. Der Beleg kommt zurück als Datei – bereit zum Speichern in SharePoint, OneDrive oder zum Anhängen an eine Mail.
So wird aus einer Transaktionsliste in Power Automate ganz schnell ein vollautomatisiertes Belegarchiv.
Fazit: Weniger Code, Weniger Token-Stress
Der Kontist Custom Connector ist eine schlanke Loesung, wenn du Kontist Daten in Automatisierungen nutzen willst. Durch den Blank Connector und den Swagger Editor bleibt das Setup kontrollierbar, gleichzeitig sparst du dir den kompletten Umweg ueber eigenen OAuth Code.
Besonders stark ist die Kombination aus GraphQL und OAuth2 im Connector. Du hast nur eine Aktion, kannst aber viele verschiedene Queries senden. Dadurch bleibt deine Integration flexibel, sauber und gut wartbar. Wenn du also Kontostand, Transaktionen oder Belege automatisiert nutzen willst, ist dieser Weg ein sehr guter Startpunkt.
War dieser Artikel hilfreich?