API-Referenz

Liest Stammdaten, Plan und Transfertext des aktuellen Mandanten.

curl -X GET 'https://trinkgeldmeister.com/api/v1/tenant' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/tenant", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/tenant", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/tenant")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/tenant", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/tenant")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Aktualisiert Report-Email oder Überweisungstext-Vorlage.

curl -X PATCH 'https://trinkgeldmeister.com/api/v1/tenant' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"report_email":"finance@example.test","transfer_text_template":"Trinkgeld {{tenant_name}} {{date}}"}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("PATCH", "https://trinkgeldmeister.com/api/v1/tenant", headers=headers, data="{\"report_email\":\"finance@example.test\",\"transfer_text_template\":\"Trinkgeld {{tenant_name}} {{date}}\"}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/tenant", {
  method: "PATCH",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"report_email":"finance@example.test","transfer_text_template":"Trinkgeld {{tenant_name}} {{date}}"})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"report_email":"finance@example.test","transfer_text_template":"Trinkgeld {{tenant_name}} {{date}}"}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/tenant")!)
request.httpMethod = "PATCH"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"report_email\":\"finance@example.test\",\"transfer_text_template\":\"Trinkgeld {{tenant_name}} {{date}}\"}")
  req, _ := http.NewRequest("PATCH", "https://trinkgeldmeister.com/api/v1/tenant", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::PATCH, "https://trinkgeldmeister.com/api/v1/tenant")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"report_email\":\"finance@example.test\",\"transfer_text_template\":\"Trinkgeld {{tenant_name}} {{date}}\"}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Listet Mitarbeiter des API-Key-Mandanten.

curl -X GET 'https://trinkgeldmeister.com/api/v1/employees' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/employees", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/employees", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/employees")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/employees", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/employees")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Legt einen Mitarbeiter inklusive Operator-ID, Handy und Auszahlungskonto an.

curl -X POST 'https://trinkgeldmeister.com/api/v1/employees' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"operator_id":"99","name":"API Mitarbeiter","phone":"0170 1234567","status":"active","iban":"DE89370400440532013000","account_holder":"API Mitarbeiter"}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/employees", headers=headers, data="{\"operator_id\":\"99\",\"name\":\"API Mitarbeiter\",\"phone\":\"0170 1234567\",\"status\":\"active\",\"iban\":\"DE89370400440532013000\",\"account_holder\":\"API Mitarbeiter\"}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/employees", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"operator_id":"99","name":"API Mitarbeiter","phone":"0170 1234567","status":"active","iban":"DE89370400440532013000","account_holder":"API Mitarbeiter"})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"operator_id":"99","name":"API Mitarbeiter","phone":"0170 1234567","status":"active","iban":"DE89370400440532013000","account_holder":"API Mitarbeiter"}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/employees")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"operator_id\":\"99\",\"name\":\"API Mitarbeiter\",\"phone\":\"0170 1234567\",\"status\":\"active\",\"iban\":\"DE89370400440532013000\",\"account_holder\":\"API Mitarbeiter\"}")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/employees", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/employees")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"operator_id\":\"99\",\"name\":\"API Mitarbeiter\",\"phone\":\"0170 1234567\",\"status\":\"active\",\"iban\":\"DE89370400440532013000\",\"account_holder\":\"API Mitarbeiter\"}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Liest einen Mitarbeiter innerhalb des API-Key-Mandanten.

curl -X GET 'https://trinkgeldmeister.com/api/v1/employees/1' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/employees/1", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/employees/1", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/employees/1")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/employees/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/employees/1")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Aktualisiert einen Mitarbeiter innerhalb des Mandanten.

curl -X PATCH 'https://trinkgeldmeister.com/api/v1/employees/1' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"location":"Bar","status":"active","phone":"0170 7654321"}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("PATCH", "https://trinkgeldmeister.com/api/v1/employees/1", headers=headers, data="{\"location\":\"Bar\",\"status\":\"active\",\"phone\":\"0170 7654321\"}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/employees/1", {
  method: "PATCH",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"location":"Bar","status":"active","phone":"0170 7654321"})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"location":"Bar","status":"active","phone":"0170 7654321"}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/employees/1")!)
request.httpMethod = "PATCH"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"location\":\"Bar\",\"status\":\"active\",\"phone\":\"0170 7654321\"}")
  req, _ := http.NewRequest("PATCH", "https://trinkgeldmeister.com/api/v1/employees/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::PATCH, "https://trinkgeldmeister.com/api/v1/employees/1")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"location\":\"Bar\",\"status\":\"active\",\"phone\":\"0170 7654321\"}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Setzt einen Mitarbeiter innerhalb des Mandanten auf deleted.

curl -X DELETE 'https://trinkgeldmeister.com/api/v1/employees/1' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("DELETE", "https://trinkgeldmeister.com/api/v1/employees/1", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/employees/1", {
  method: "DELETE",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/employees/1")!)
request.httpMethod = "DELETE"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("DELETE", "https://trinkgeldmeister.com/api/v1/employees/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::DELETE, "https://trinkgeldmeister.com/api/v1/employees/1")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Importiert oder aktualisiert Mitarbeiter per CSV mit Operator-ID oder Mitarbeiter-Referenz.

curl -X POST 'https://trinkgeldmeister.com/api/v1/employees/import' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"csv":"operator_id,name,email,phone,status,iban,account_holder\n77,API Import,api-import@example.test,0170 1234567,active,DE89370400440532013000,API Import\n"}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/employees/import", headers=headers, data="{\"csv\":\"operator_id,name,email,phone,status,iban,account_holder\\n77,API Import,api-import@example.test,0170 1234567,active,DE89370400440532013000,API Import\\n\"}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/employees/import", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"csv":"operator_id,name,email,phone,status,iban,account_holder\n77,API Import,api-import@example.test,0170 1234567,active,DE89370400440532013000,API Import\n"})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"csv":"operator_id,name,email,phone,status,iban,account_holder\n77,API Import,api-import@example.test,0170 1234567,active,DE89370400440532013000,API Import\n"}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/employees/import")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"csv\":\"operator_id,name,email,phone,status,iban,account_holder\\n77,API Import,api-import@example.test,0170 1234567,active,DE89370400440532013000,API Import\\n\"}")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/employees/import", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/employees/import")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"csv\":\"operator_id,name,email,phone,status,iban,account_holder\\n77,API Import,api-import@example.test,0170 1234567,active,DE89370400440532013000,API Import\\n\"}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Listet konfigurierte Provider-Verbindungen.

curl -X GET 'https://trinkgeldmeister.com/api/v1/providers' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/providers", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/providers", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/providers")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/providers", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/providers")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Legt eine Provider-Verbindung mit Secret-Referenzen an.

curl -X POST 'https://trinkgeldmeister.com/api/v1/providers' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"provider":"stripe_global_payouts","display_name":"Stripe Sandbox","mode":"sandbox","credential_ref":"env:STRIPE_SECRET_KEY","webhook_secret_ref":"env:STRIPE_GLOBAL_PAYOUTS_WEBHOOK_SECRET","financial_account_ref":"fa_test","active":false}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/providers", headers=headers, data="{\"provider\":\"stripe_global_payouts\",\"display_name\":\"Stripe Sandbox\",\"mode\":\"sandbox\",\"credential_ref\":\"env:STRIPE_SECRET_KEY\",\"webhook_secret_ref\":\"env:STRIPE_GLOBAL_PAYOUTS_WEBHOOK_SECRET\",\"financial_account_ref\":\"fa_test\",\"active\":false}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/providers", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"provider":"stripe_global_payouts","display_name":"Stripe Sandbox","mode":"sandbox","credential_ref":"env:STRIPE_SECRET_KEY","webhook_secret_ref":"env:STRIPE_GLOBAL_PAYOUTS_WEBHOOK_SECRET","financial_account_ref":"fa_test","active":false})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"provider":"stripe_global_payouts","display_name":"Stripe Sandbox","mode":"sandbox","credential_ref":"env:STRIPE_SECRET_KEY","webhook_secret_ref":"env:STRIPE_GLOBAL_PAYOUTS_WEBHOOK_SECRET","financial_account_ref":"fa_test","active":false}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/providers")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"provider\":\"stripe_global_payouts\",\"display_name\":\"Stripe Sandbox\",\"mode\":\"sandbox\",\"credential_ref\":\"env:STRIPE_SECRET_KEY\",\"webhook_secret_ref\":\"env:STRIPE_GLOBAL_PAYOUTS_WEBHOOK_SECRET\",\"financial_account_ref\":\"fa_test\",\"active\":false}")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/providers", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/providers")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"provider\":\"stripe_global_payouts\",\"display_name\":\"Stripe Sandbox\",\"mode\":\"sandbox\",\"credential_ref\":\"env:STRIPE_SECRET_KEY\",\"webhook_secret_ref\":\"env:STRIPE_GLOBAL_PAYOUTS_WEBHOOK_SECRET\",\"financial_account_ref\":\"fa_test\",\"active\":false}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Aktualisiert Anzeigename, Status, Modus oder Secret-Referenzen einer Provider-Verbindung.

curl -X PATCH 'https://trinkgeldmeister.com/api/v1/providers/1' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"display_name":"Stripe Sandbox Updated","active":true}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("PATCH", "https://trinkgeldmeister.com/api/v1/providers/1", headers=headers, data="{\"display_name\":\"Stripe Sandbox Updated\",\"active\":true}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/providers/1", {
  method: "PATCH",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"display_name":"Stripe Sandbox Updated","active":true})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"display_name":"Stripe Sandbox Updated","active":true}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/providers/1")!)
request.httpMethod = "PATCH"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"display_name\":\"Stripe Sandbox Updated\",\"active\":true}")
  req, _ := http.NewRequest("PATCH", "https://trinkgeldmeister.com/api/v1/providers/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::PATCH, "https://trinkgeldmeister.com/api/v1/providers/1")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"display_name\":\"Stripe Sandbox Updated\",\"active\":true}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Deaktiviert eine Provider-Verbindung fachlich und erzeugt ein `provider.disabled` Event.

curl -X DELETE 'https://trinkgeldmeister.com/api/v1/providers/1' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("DELETE", "https://trinkgeldmeister.com/api/v1/providers/1", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/providers/1", {
  method: "DELETE",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/providers/1")!)
request.httpMethod = "DELETE"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("DELETE", "https://trinkgeldmeister.com/api/v1/providers/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::DELETE, "https://trinkgeldmeister.com/api/v1/providers/1")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Prüft Key-, Modus-, Webhook- und Funding-Kontext der Provider-Verbindung.

curl -X POST 'https://trinkgeldmeister.com/api/v1/providers/1/test' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/providers/1/test", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/providers/1/test", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/providers/1/test")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/providers/1/test", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/providers/1/test")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Ersetzt Credential-, Webhook- oder Funding-Referenzen, ohne Secret-Werte offenzulegen.

curl -X POST 'https://trinkgeldmeister.com/api/v1/providers/1/rotate-secret-ref' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"credential_ref":"env:STRIPE_SECRET_KEY_NEXT"}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/providers/1/rotate-secret-ref", headers=headers, data="{\"credential_ref\":\"env:STRIPE_SECRET_KEY_NEXT\"}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/providers/1/rotate-secret-ref", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"credential_ref":"env:STRIPE_SECRET_KEY_NEXT"})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"credential_ref":"env:STRIPE_SECRET_KEY_NEXT"}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/providers/1/rotate-secret-ref")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"credential_ref\":\"env:STRIPE_SECRET_KEY_NEXT\"}")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/providers/1/rotate-secret-ref", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/providers/1/rotate-secret-ref")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"credential_ref\":\"env:STRIPE_SECRET_KEY_NEXT\"}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Parst eine CSV-Zahlungsliste mit optionalem Spaltenmapping und erzeugt einen geprüften Auszahlungslauf.

curl -X POST 'https://trinkgeldmeister.com/api/v1/imports' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Idempotency-Key: idem-post-api-v1-imports' \
  -H 'Content-Type: application/json' \
  -d '{"name":"Mai Trinkgeld","csv":"Bediener Nr,Trinkgeld EUR,Zweck\n17,51.25,Trinkgeld Mai\n","mapping":{"operator_id":"Bediener Nr","amount":"Trinkgeld EUR","transfer_text":"Zweck"}}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json","Idempotency-Key":"idem-post-api-v1-imports"}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/imports", headers=headers, data="{\"name\":\"Mai Trinkgeld\",\"csv\":\"Bediener Nr,Trinkgeld EUR,Zweck\\n17,51.25,Trinkgeld Mai\\n\",\"mapping\":{\"operator_id\":\"Bediener Nr\",\"amount\":\"Trinkgeld EUR\",\"transfer_text\":\"Zweck\"}}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/imports", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json", "Idempotency-Key": "idem-post-api-v1-imports" },
  body: JSON.stringify({"name":"Mai Trinkgeld","csv":"Bediener Nr,Trinkgeld EUR,Zweck\n17,51.25,Trinkgeld Mai\n","mapping":{"operator_id":"Bediener Nr","amount":"Trinkgeld EUR","transfer_text":"Zweck"}})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"name":"Mai Trinkgeld","csv":"Bediener Nr,Trinkgeld EUR,Zweck\n17,51.25,Trinkgeld Mai\n","mapping":{"operator_id":"Bediener Nr","amount":"Trinkgeld EUR","transfer_text":"Zweck"}}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/imports")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.setValue("idem-post-api-v1-imports", forHTTPHeaderField: "Idempotency-Key")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"name\":\"Mai Trinkgeld\",\"csv\":\"Bediener Nr,Trinkgeld EUR,Zweck\\n17,51.25,Trinkgeld Mai\\n\",\"mapping\":{\"operator_id\":\"Bediener Nr\",\"amount\":\"Trinkgeld EUR\",\"transfer_text\":\"Zweck\"}}")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/imports", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  req.Header.Set("Idempotency-Key", "idem-post-api-v1-imports")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/imports")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .header("Idempotency-Key", "idem-post-api-v1-imports")
    .body("{\"name\":\"Mai Trinkgeld\",\"csv\":\"Bediener Nr,Trinkgeld EUR,Zweck\\n17,51.25,Trinkgeld Mai\\n\",\"mapping\":{\"operator_id\":\"Bediener Nr\",\"amount\":\"Trinkgeld EUR\",\"transfer_text\":\"Zweck\"}}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Liest Importstatus und den verknüpften Auszahlungslauf.

curl -X GET 'https://trinkgeldmeister.com/api/v1/imports/imp_1' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/imports/imp_1", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/imports/imp_1", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/imports/imp_1")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/imports/imp_1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/imports/imp_1")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Listet die normalisierten Importzeilen aus den gespeicherten Auszahlungspositionen.

curl -X GET 'https://trinkgeldmeister.com/api/v1/imports/imp_1/rows' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/imports/imp_1/rows", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/imports/imp_1/rows", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/imports/imp_1/rows")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/imports/imp_1/rows", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/imports/imp_1/rows")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Gibt den aktuellen Validierungsstatus des Imports zurück.

curl -X POST 'https://trinkgeldmeister.com/api/v1/imports/imp_1/validate' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/imports/imp_1/validate", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/imports/imp_1/validate", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/imports/imp_1/validate")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/imports/imp_1/validate", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/imports/imp_1/validate")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Erzeugt einen Lauf aus JSON-Positionen.

curl -X POST 'https://trinkgeldmeister.com/api/v1/payout-runs' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Idempotency-Key: idem-post-api-v1-payout-runs' \
  -H 'Content-Type: application/json' \
  -d '{"name":"Mai Trinkgeld","items":[{"operator_id":"17","amount":5125,"currency":"EUR"}]}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json","Idempotency-Key":"idem-post-api-v1-payout-runs"}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/payout-runs", headers=headers, data="{\"name\":\"Mai Trinkgeld\",\"items\":[{\"operator_id\":\"17\",\"amount\":5125,\"currency\":\"EUR\"}]}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/payout-runs", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json", "Idempotency-Key": "idem-post-api-v1-payout-runs" },
  body: JSON.stringify({"name":"Mai Trinkgeld","items":[{"operator_id":"17","amount":5125,"currency":"EUR"}]})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"name":"Mai Trinkgeld","items":[{"operator_id":"17","amount":5125,"currency":"EUR"}]}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/payout-runs")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.setValue("idem-post-api-v1-payout-runs", forHTTPHeaderField: "Idempotency-Key")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"name\":\"Mai Trinkgeld\",\"items\":[{\"operator_id\":\"17\",\"amount\":5125,\"currency\":\"EUR\"}]}")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/payout-runs", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  req.Header.Set("Idempotency-Key", "idem-post-api-v1-payout-runs")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/payout-runs")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .header("Idempotency-Key", "idem-post-api-v1-payout-runs")
    .body("{\"name\":\"Mai Trinkgeld\",\"items\":[{\"operator_id\":\"17\",\"amount\":5125,\"currency\":\"EUR\"}]}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Listet Auszahlungsläufe des Mandanten.

curl -X GET 'https://trinkgeldmeister.com/api/v1/payout-runs' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/payout-runs", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/payout-runs", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/payout-runs")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/payout-runs", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/payout-runs")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Liest Detailstatus und Positionen eines Laufs.

curl -X GET 'https://trinkgeldmeister.com/api/v1/payout-runs/1' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/payout-runs/1", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/payout-runs/1", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/payout-runs/1")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/payout-runs/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/payout-runs/1")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Führt den technischen Probelauf ohne Geldbewegung aus.

curl -X POST 'https://trinkgeldmeister.com/api/v1/payout-runs/1/dry-run' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Idempotency-Key: idem-post-api-v1-payout-runs-1-dry-run'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Idempotency-Key":"idem-post-api-v1-payout-runs-1-dry-run"}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/payout-runs/1/dry-run", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/payout-runs/1/dry-run", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_...", "Idempotency-Key": "idem-post-api-v1-payout-runs-1-dry-run" }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/payout-runs/1/dry-run")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("idem-post-api-v1-payout-runs-1-dry-run", forHTTPHeaderField: "Idempotency-Key")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/payout-runs/1/dry-run", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Idempotency-Key", "idem-post-api-v1-payout-runs-1-dry-run")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/payout-runs/1/dry-run")
    .bearer_auth("tgm_test_...")
    .header("Idempotency-Key", "idem-post-api-v1-payout-runs-1-dry-run")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Setzt den Lauf auf freigegeben.

curl -X POST 'https://trinkgeldmeister.com/api/v1/payout-runs/1/approve' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Idempotency-Key: idem-post-api-v1-payout-runs-1-approve'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Idempotency-Key":"idem-post-api-v1-payout-runs-1-approve"}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/payout-runs/1/approve", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/payout-runs/1/approve", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_...", "Idempotency-Key": "idem-post-api-v1-payout-runs-1-approve" }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/payout-runs/1/approve")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("idem-post-api-v1-payout-runs-1-approve", forHTTPHeaderField: "Idempotency-Key")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/payout-runs/1/approve", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Idempotency-Key", "idem-post-api-v1-payout-runs-1-approve")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/payout-runs/1/approve")
    .bearer_auth("tgm_test_...")
    .header("Idempotency-Key", "idem-post-api-v1-payout-runs-1-approve")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Führt einen freigegebenen Lauf aus, sofern Abo und Feature Flags passen.

curl -X POST 'https://trinkgeldmeister.com/api/v1/payout-runs/1/execute' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Idempotency-Key: idem-post-api-v1-payout-runs-1-execute'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Idempotency-Key":"idem-post-api-v1-payout-runs-1-execute"}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/payout-runs/1/execute", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/payout-runs/1/execute", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_...", "Idempotency-Key": "idem-post-api-v1-payout-runs-1-execute" }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/payout-runs/1/execute")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("idem-post-api-v1-payout-runs-1-execute", forHTTPHeaderField: "Idempotency-Key")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/payout-runs/1/execute", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Idempotency-Key", "idem-post-api-v1-payout-runs-1-execute")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/payout-runs/1/execute")
    .bearer_auth("tgm_test_...")
    .header("Idempotency-Key", "idem-post-api-v1-payout-runs-1-execute")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Setzt einen Lauf auf canceled, bevor eine Live-Ausführung erfolgt.

curl -X POST 'https://trinkgeldmeister.com/api/v1/payout-runs/1/cancel' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Idempotency-Key: idem-post-api-v1-payout-runs-1-cancel'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Idempotency-Key":"idem-post-api-v1-payout-runs-1-cancel"}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/payout-runs/1/cancel", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/payout-runs/1/cancel", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_...", "Idempotency-Key": "idem-post-api-v1-payout-runs-1-cancel" }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/payout-runs/1/cancel")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("idem-post-api-v1-payout-runs-1-cancel", forHTTPHeaderField: "Idempotency-Key")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/payout-runs/1/cancel", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Idempotency-Key", "idem-post-api-v1-payout-runs-1-cancel")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/payout-runs/1/cancel")
    .bearer_auth("tgm_test_...")
    .header("Idempotency-Key", "idem-post-api-v1-payout-runs-1-cancel")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Erstellt für eine fehlgeschlagene Auszahlungsposition idempotent einen neuen Provider-Versuch und schreibt das Journal.

curl -X POST 'https://trinkgeldmeister.com/api/v1/payout-items/1/retry' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Idempotency-Key: idem-post-api-v1-payout-items-1-retry'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Idempotency-Key":"idem-post-api-v1-payout-items-1-retry"}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/payout-items/1/retry", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/payout-items/1/retry", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_...", "Idempotency-Key": "idem-post-api-v1-payout-items-1-retry" }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/payout-items/1/retry")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("idem-post-api-v1-payout-items-1-retry", forHTTPHeaderField: "Idempotency-Key")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/payout-items/1/retry", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Idempotency-Key", "idem-post-api-v1-payout-items-1-retry")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/payout-items/1/retry")
    .bearer_auth("tgm_test_...")
    .header("Idempotency-Key", "idem-post-api-v1-payout-items-1-retry")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Lädt den CSV-Report für einen Auszahlungslauf des API-Key-Mandanten.

curl -X GET 'https://trinkgeldmeister.com/api/v1/reports/payout-runs/1.csv' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/reports/payout-runs/1.csv", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/reports/payout-runs/1.csv", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/reports/payout-runs/1.csv")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/reports/payout-runs/1.csv", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/reports/payout-runs/1.csv")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Lädt den PDF-Report für einen Auszahlungslauf des API-Key-Mandanten.

curl -X GET 'https://trinkgeldmeister.com/api/v1/reports/payout-runs/1.pdf' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/reports/payout-runs/1.pdf", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/reports/payout-runs/1.pdf", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/reports/payout-runs/1.pdf")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/reports/payout-runs/1.pdf", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/reports/payout-runs/1.pdf")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Lädt den maschinenlesbaren JSON-Report für einen Auszahlungslauf des API-Key-Mandanten.

curl -X GET 'https://trinkgeldmeister.com/api/v1/reports/payout-runs/1.json' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/reports/payout-runs/1.json", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/reports/payout-runs/1.json", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/reports/payout-runs/1.json")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/reports/payout-runs/1.json", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/reports/payout-runs/1.json")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Listet Journalbewegungen und Provider-Referenzen.

curl -X GET 'https://trinkgeldmeister.com/api/v1/journal' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/journal", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/journal", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/journal")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/journal", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/journal")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Listet alle Mandanten. Authentifizierung über X-MegaAdmin-Token oder Bearer MegaAdmin Token.

curl -X GET 'https://trinkgeldmeister.com/api/v1/superadmin/tenants' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/superadmin/tenants", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/tenants", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/tenants")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/superadmin/tenants", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/superadmin/tenants")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Legt einen Mandanten an.

curl -X POST 'https://trinkgeldmeister.com/api/v1/superadmin/tenants' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"key":"api-tenant","name":"API Tenant","report_email":"api@example.test","status":"active"}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/superadmin/tenants", headers=headers, data="{\"key\":\"api-tenant\",\"name\":\"API Tenant\",\"report_email\":\"api@example.test\",\"status\":\"active\"}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/tenants", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"key":"api-tenant","name":"API Tenant","report_email":"api@example.test","status":"active"})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"key":"api-tenant","name":"API Tenant","report_email":"api@example.test","status":"active"}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/tenants")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"key\":\"api-tenant\",\"name\":\"API Tenant\",\"report_email\":\"api@example.test\",\"status\":\"active\"}")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/superadmin/tenants", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/superadmin/tenants")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"key\":\"api-tenant\",\"name\":\"API Tenant\",\"report_email\":\"api@example.test\",\"status\":\"active\"}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Liest einen Mandanten.

curl -X GET 'https://trinkgeldmeister.com/api/v1/superadmin/tenants/1' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/superadmin/tenants/1", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/tenants/1", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/tenants/1")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/superadmin/tenants/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/superadmin/tenants/1")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Aktualisiert Mandantenstammdaten.

curl -X PATCH 'https://trinkgeldmeister.com/api/v1/superadmin/tenants/1' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"name":"API Tenant Updated","plan_key":"team"}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("PATCH", "https://trinkgeldmeister.com/api/v1/superadmin/tenants/1", headers=headers, data="{\"name\":\"API Tenant Updated\",\"plan_key\":\"team\"}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/tenants/1", {
  method: "PATCH",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"name":"API Tenant Updated","plan_key":"team"})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"name":"API Tenant Updated","plan_key":"team"}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/tenants/1")!)
request.httpMethod = "PATCH"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"name\":\"API Tenant Updated\",\"plan_key\":\"team\"}")
  req, _ := http.NewRequest("PATCH", "https://trinkgeldmeister.com/api/v1/superadmin/tenants/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::PATCH, "https://trinkgeldmeister.com/api/v1/superadmin/tenants/1")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"name\":\"API Tenant Updated\",\"plan_key\":\"team\"}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Setzt einen Mandanten auf deleted.

curl -X DELETE 'https://trinkgeldmeister.com/api/v1/superadmin/tenants/1' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("DELETE", "https://trinkgeldmeister.com/api/v1/superadmin/tenants/1", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/tenants/1", {
  method: "DELETE",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/tenants/1")!)
request.httpMethod = "DELETE"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("DELETE", "https://trinkgeldmeister.com/api/v1/superadmin/tenants/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::DELETE, "https://trinkgeldmeister.com/api/v1/superadmin/tenants/1")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Listet User/Rollen für `tenant_id` oder den ersten Mandanten.

curl -X GET 'https://trinkgeldmeister.com/api/v1/superadmin/users' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/superadmin/users", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/users", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/users")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/superadmin/users", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/superadmin/users")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Legt einen Tenant-User mit Rolle an.

curl -X POST 'https://trinkgeldmeister.com/api/v1/superadmin/users' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"tenant_id":1,"name":"API Owner","email":"owner@example.test","phone":"+491701234567","role":"owner","phone_verified":true}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/superadmin/users", headers=headers, data="{\"tenant_id\":1,\"name\":\"API Owner\",\"email\":\"owner@example.test\",\"phone\":\"+491701234567\",\"role\":\"owner\",\"phone_verified\":true}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/users", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"tenant_id":1,"name":"API Owner","email":"owner@example.test","phone":"+491701234567","role":"owner","phone_verified":true})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"tenant_id":1,"name":"API Owner","email":"owner@example.test","phone":"+491701234567","role":"owner","phone_verified":true}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/users")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"tenant_id\":1,\"name\":\"API Owner\",\"email\":\"owner@example.test\",\"phone\":\"+491701234567\",\"role\":\"owner\",\"phone_verified\":true}")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/superadmin/users", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/superadmin/users")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"tenant_id\":1,\"name\":\"API Owner\",\"email\":\"owner@example.test\",\"phone\":\"+491701234567\",\"role\":\"owner\",\"phone_verified\":true}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Aktualisiert Rolle, Status oder Kontaktdaten eines Tenant-Users.

curl -X PATCH 'https://trinkgeldmeister.com/api/v1/superadmin/users/1' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"role":"finance","status":"active"}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("PATCH", "https://trinkgeldmeister.com/api/v1/superadmin/users/1", headers=headers, data="{\"role\":\"finance\",\"status\":\"active\"}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/users/1", {
  method: "PATCH",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"role":"finance","status":"active"})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"role":"finance","status":"active"}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/users/1")!)
request.httpMethod = "PATCH"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"role\":\"finance\",\"status\":\"active\"}")
  req, _ := http.NewRequest("PATCH", "https://trinkgeldmeister.com/api/v1/superadmin/users/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::PATCH, "https://trinkgeldmeister.com/api/v1/superadmin/users/1")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"role\":\"finance\",\"status\":\"active\"}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Setzt einen Tenant-User auf deleted.

curl -X DELETE 'https://trinkgeldmeister.com/api/v1/superadmin/users/1' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("DELETE", "https://trinkgeldmeister.com/api/v1/superadmin/users/1", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/users/1", {
  method: "DELETE",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/users/1")!)
request.httpMethod = "DELETE"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("DELETE", "https://trinkgeldmeister.com/api/v1/superadmin/users/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::DELETE, "https://trinkgeldmeister.com/api/v1/superadmin/users/1")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Listet Mitarbeiter für `tenant_id` oder den ersten Mandanten.

curl -X GET 'https://trinkgeldmeister.com/api/v1/superadmin/employees' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/superadmin/employees", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/employees", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/employees")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/superadmin/employees", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/superadmin/employees")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Legt einen Mitarbeiter inklusive Operator-ID und maskierter IBAN an.

curl -X POST 'https://trinkgeldmeister.com/api/v1/superadmin/employees' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"tenant_id":1,"operator_id":"901","name":"API Employee","iban":"DE89370400440532013000","account_holder":"API Employee"}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/superadmin/employees", headers=headers, data="{\"tenant_id\":1,\"operator_id\":\"901\",\"name\":\"API Employee\",\"iban\":\"DE89370400440532013000\",\"account_holder\":\"API Employee\"}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/employees", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"tenant_id":1,"operator_id":"901","name":"API Employee","iban":"DE89370400440532013000","account_holder":"API Employee"})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"tenant_id":1,"operator_id":"901","name":"API Employee","iban":"DE89370400440532013000","account_holder":"API Employee"}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/employees")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"tenant_id\":1,\"operator_id\":\"901\",\"name\":\"API Employee\",\"iban\":\"DE89370400440532013000\",\"account_holder\":\"API Employee\"}")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/superadmin/employees", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/superadmin/employees")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"tenant_id\":1,\"operator_id\":\"901\",\"name\":\"API Employee\",\"iban\":\"DE89370400440532013000\",\"account_holder\":\"API Employee\"}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Aktualisiert Mitarbeiterstamm, Handy und Kontodaten.

curl -X PATCH 'https://trinkgeldmeister.com/api/v1/superadmin/employees/1' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"location":"API Bar","phone":"0170 7654321"}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("PATCH", "https://trinkgeldmeister.com/api/v1/superadmin/employees/1", headers=headers, data="{\"location\":\"API Bar\",\"phone\":\"0170 7654321\"}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/employees/1", {
  method: "PATCH",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"location":"API Bar","phone":"0170 7654321"})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"location":"API Bar","phone":"0170 7654321"}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/employees/1")!)
request.httpMethod = "PATCH"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"location\":\"API Bar\",\"phone\":\"0170 7654321\"}")
  req, _ := http.NewRequest("PATCH", "https://trinkgeldmeister.com/api/v1/superadmin/employees/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::PATCH, "https://trinkgeldmeister.com/api/v1/superadmin/employees/1")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"location\":\"API Bar\",\"phone\":\"0170 7654321\"}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Setzt einen Mitarbeiter auf deleted.

curl -X DELETE 'https://trinkgeldmeister.com/api/v1/superadmin/employees/1' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("DELETE", "https://trinkgeldmeister.com/api/v1/superadmin/employees/1", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/employees/1", {
  method: "DELETE",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/employees/1")!)
request.httpMethod = "DELETE"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("DELETE", "https://trinkgeldmeister.com/api/v1/superadmin/employees/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::DELETE, "https://trinkgeldmeister.com/api/v1/superadmin/employees/1")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Listet Provider-Verbindungen für `tenant_id` oder den ersten Mandanten.

curl -X GET 'https://trinkgeldmeister.com/api/v1/superadmin/providers' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/superadmin/providers", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/providers", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/providers")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/superadmin/providers", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/superadmin/providers")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Legt eine Provider-Verbindung mit Secret-Referenzen an und kann die Konfiguration testen.

curl -X POST 'https://trinkgeldmeister.com/api/v1/superadmin/providers' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"tenant_id":1,"provider":"stripe_global_payouts","display_name":"API Stripe","mode":"sandbox","credential_ref":"env:STRIPE_SECRET_KEY","webhook_secret_ref":"env:STRIPE_GLOBAL_PAYOUTS_WEBHOOK_SECRET","financial_account_ref":"fa_test","active":true,"test":true}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/superadmin/providers", headers=headers, data="{\"tenant_id\":1,\"provider\":\"stripe_global_payouts\",\"display_name\":\"API Stripe\",\"mode\":\"sandbox\",\"credential_ref\":\"env:STRIPE_SECRET_KEY\",\"webhook_secret_ref\":\"env:STRIPE_GLOBAL_PAYOUTS_WEBHOOK_SECRET\",\"financial_account_ref\":\"fa_test\",\"active\":true,\"test\":true}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/providers", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"tenant_id":1,"provider":"stripe_global_payouts","display_name":"API Stripe","mode":"sandbox","credential_ref":"env:STRIPE_SECRET_KEY","webhook_secret_ref":"env:STRIPE_GLOBAL_PAYOUTS_WEBHOOK_SECRET","financial_account_ref":"fa_test","active":true,"test":true})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"tenant_id":1,"provider":"stripe_global_payouts","display_name":"API Stripe","mode":"sandbox","credential_ref":"env:STRIPE_SECRET_KEY","webhook_secret_ref":"env:STRIPE_GLOBAL_PAYOUTS_WEBHOOK_SECRET","financial_account_ref":"fa_test","active":true,"test":true}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/providers")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"tenant_id\":1,\"provider\":\"stripe_global_payouts\",\"display_name\":\"API Stripe\",\"mode\":\"sandbox\",\"credential_ref\":\"env:STRIPE_SECRET_KEY\",\"webhook_secret_ref\":\"env:STRIPE_GLOBAL_PAYOUTS_WEBHOOK_SECRET\",\"financial_account_ref\":\"fa_test\",\"active\":true,\"test\":true}")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/superadmin/providers", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/superadmin/providers")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"tenant_id\":1,\"provider\":\"stripe_global_payouts\",\"display_name\":\"API Stripe\",\"mode\":\"sandbox\",\"credential_ref\":\"env:STRIPE_SECRET_KEY\",\"webhook_secret_ref\":\"env:STRIPE_GLOBAL_PAYOUTS_WEBHOOK_SECRET\",\"financial_account_ref\":\"fa_test\",\"active\":true,\"test\":true}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Aktualisiert Provider-Status, Modus oder Secret-Referenzen.

curl -X PATCH 'https://trinkgeldmeister.com/api/v1/superadmin/providers/1' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"display_name":"Stripe Sandbox Updated","status":"active"}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("PATCH", "https://trinkgeldmeister.com/api/v1/superadmin/providers/1", headers=headers, data="{\"display_name\":\"Stripe Sandbox Updated\",\"status\":\"active\"}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/providers/1", {
  method: "PATCH",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"display_name":"Stripe Sandbox Updated","status":"active"})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"display_name":"Stripe Sandbox Updated","status":"active"}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/providers/1")!)
request.httpMethod = "PATCH"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"display_name\":\"Stripe Sandbox Updated\",\"status\":\"active\"}")
  req, _ := http.NewRequest("PATCH", "https://trinkgeldmeister.com/api/v1/superadmin/providers/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::PATCH, "https://trinkgeldmeister.com/api/v1/superadmin/providers/1")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"display_name\":\"Stripe Sandbox Updated\",\"status\":\"active\"}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Deaktiviert eine Provider-Verbindung.

curl -X DELETE 'https://trinkgeldmeister.com/api/v1/superadmin/providers/1' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("DELETE", "https://trinkgeldmeister.com/api/v1/superadmin/providers/1", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/providers/1", {
  method: "DELETE",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/providers/1")!)
request.httpMethod = "DELETE"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("DELETE", "https://trinkgeldmeister.com/api/v1/superadmin/providers/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::DELETE, "https://trinkgeldmeister.com/api/v1/superadmin/providers/1")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Listet Auszahlungsläufe für `tenant_id` oder den ersten Mandanten.

curl -X GET 'https://trinkgeldmeister.com/api/v1/superadmin/payout-runs' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/superadmin/payout-runs", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/payout-runs", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/payout-runs")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/superadmin/payout-runs", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/superadmin/payout-runs")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Erzeugt einen Auszahlungslauf für einen Mandanten aus JSON-Positionen.

curl -X POST 'https://trinkgeldmeister.com/api/v1/superadmin/payout-runs' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"tenant_id":1,"name":"SuperAdmin Run","items":[{"operator_id":"17","amount":5125,"currency":"EUR"}]}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/superadmin/payout-runs", headers=headers, data="{\"tenant_id\":1,\"name\":\"SuperAdmin Run\",\"items\":[{\"operator_id\":\"17\",\"amount\":5125,\"currency\":\"EUR\"}]}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/payout-runs", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"tenant_id":1,"name":"SuperAdmin Run","items":[{"operator_id":"17","amount":5125,"currency":"EUR"}]})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"tenant_id":1,"name":"SuperAdmin Run","items":[{"operator_id":"17","amount":5125,"currency":"EUR"}]}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/payout-runs")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"tenant_id\":1,\"name\":\"SuperAdmin Run\",\"items\":[{\"operator_id\":\"17\",\"amount\":5125,\"currency\":\"EUR\"}]}")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/superadmin/payout-runs", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/superadmin/payout-runs")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"tenant_id\":1,\"name\":\"SuperAdmin Run\",\"items\":[{\"operator_id\":\"17\",\"amount\":5125,\"currency\":\"EUR\"}]}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Liest einen Auszahlungslauf inklusive Positionen.

curl -X GET 'https://trinkgeldmeister.com/api/v1/superadmin/payout-runs/1' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/superadmin/payout-runs/1", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/payout-runs/1", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/payout-runs/1")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/superadmin/payout-runs/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/superadmin/payout-runs/1")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Ändert den Status eines Auszahlungslaufs.

curl -X PATCH 'https://trinkgeldmeister.com/api/v1/superadmin/payout-runs/1' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"status":"approved"}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("PATCH", "https://trinkgeldmeister.com/api/v1/superadmin/payout-runs/1", headers=headers, data="{\"status\":\"approved\"}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/payout-runs/1", {
  method: "PATCH",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"status":"approved"})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"status":"approved"}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/payout-runs/1")!)
request.httpMethod = "PATCH"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"status\":\"approved\"}")
  req, _ := http.NewRequest("PATCH", "https://trinkgeldmeister.com/api/v1/superadmin/payout-runs/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::PATCH, "https://trinkgeldmeister.com/api/v1/superadmin/payout-runs/1")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"status\":\"approved\"}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Setzt einen Auszahlungslauf auf canceled.

curl -X DELETE 'https://trinkgeldmeister.com/api/v1/superadmin/payout-runs/1' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("DELETE", "https://trinkgeldmeister.com/api/v1/superadmin/payout-runs/1", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/payout-runs/1", {
  method: "DELETE",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/payout-runs/1")!)
request.httpMethod = "DELETE"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("DELETE", "https://trinkgeldmeister.com/api/v1/superadmin/payout-runs/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::DELETE, "https://trinkgeldmeister.com/api/v1/superadmin/payout-runs/1")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Liest Landing- und SMS-Gateway-Konfiguration ohne Klartext-Secrets.

curl -X GET 'https://trinkgeldmeister.com/api/v1/superadmin/settings' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/superadmin/settings", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/settings", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/settings")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/superadmin/settings", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/superadmin/settings")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Aktualisiert Landing-Texte oder SMS-Gateway-Secret-Referenzen.

curl -X PATCH 'https://trinkgeldmeister.com/api/v1/superadmin/settings' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"landing":{"hero_title":"API Landing"},"sms_gateway":{"sender":"TGM","dry_run":true}}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("PATCH", "https://trinkgeldmeister.com/api/v1/superadmin/settings", headers=headers, data="{\"landing\":{\"hero_title\":\"API Landing\"},\"sms_gateway\":{\"sender\":\"TGM\",\"dry_run\":true}}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/settings", {
  method: "PATCH",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"landing":{"hero_title":"API Landing"},"sms_gateway":{"sender":"TGM","dry_run":true}})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"landing":{"hero_title":"API Landing"},"sms_gateway":{"sender":"TGM","dry_run":true}}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/settings")!)
request.httpMethod = "PATCH"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"landing\":{\"hero_title\":\"API Landing\"},\"sms_gateway\":{\"sender\":\"TGM\",\"dry_run\":true}}")
  req, _ := http.NewRequest("PATCH", "https://trinkgeldmeister.com/api/v1/superadmin/settings", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::PATCH, "https://trinkgeldmeister.com/api/v1/superadmin/settings")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"landing\":{\"hero_title\":\"API Landing\"},\"sms_gateway\":{\"sender\":\"TGM\",\"dry_run\":true}}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Listet Preisplaene.

curl -X GET 'https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Legt einen Preisplan an oder aktualisiert ihn per Key.

curl -X POST 'https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"key":"api-plan","name":"API Plan","monthly_price":4900,"employees_monthly":25,"payout_runs_monthly":6,"payout_amount_monthly":500000,"status":"active"}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans", headers=headers, data="{\"key\":\"api-plan\",\"name\":\"API Plan\",\"monthly_price\":4900,\"employees_monthly\":25,\"payout_runs_monthly\":6,\"payout_amount_monthly\":500000,\"status\":\"active\"}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"key":"api-plan","name":"API Plan","monthly_price":4900,"employees_monthly":25,"payout_runs_monthly":6,"payout_amount_monthly":500000,"status":"active"})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"key":"api-plan","name":"API Plan","monthly_price":4900,"employees_monthly":25,"payout_runs_monthly":6,"payout_amount_monthly":500000,"status":"active"}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"key\":\"api-plan\",\"name\":\"API Plan\",\"monthly_price\":4900,\"employees_monthly\":25,\"payout_runs_monthly\":6,\"payout_amount_monthly\":500000,\"status\":\"active\"}")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"key\":\"api-plan\",\"name\":\"API Plan\",\"monthly_price\":4900,\"employees_monthly\":25,\"payout_runs_monthly\":6,\"payout_amount_monthly\":500000,\"status\":\"active\"}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Liest einen Preisplan.

curl -X GET 'https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans/1' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans/1", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans/1", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans/1")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans/1")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Aktualisiert einen Preisplan inklusive Null-Werten für Preis oder Limits.

curl -X PATCH 'https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans/1' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"name":"Starter Updated","monthly_price":0}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("PATCH", "https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans/1", headers=headers, data="{\"name\":\"Starter Updated\",\"monthly_price\":0}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans/1", {
  method: "PATCH",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"name":"Starter Updated","monthly_price":0})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"name":"Starter Updated","monthly_price":0}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans/1")!)
request.httpMethod = "PATCH"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"name\":\"Starter Updated\",\"monthly_price\":0}")
  req, _ := http.NewRequest("PATCH", "https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::PATCH, "https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans/1")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"name\":\"Starter Updated\",\"monthly_price\":0}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Setzt einen Preisplan auf inactive.

curl -X DELETE 'https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans/1' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("DELETE", "https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans/1", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans/1", {
  method: "DELETE",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans/1")!)
request.httpMethod = "DELETE"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("DELETE", "https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::DELETE, "https://trinkgeldmeister.com/api/v1/superadmin/pricing-plans/1")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Listet Webhook-Endpunkte je Mandant.

curl -X GET 'https://trinkgeldmeister.com/api/v1/superadmin/webhooks' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/superadmin/webhooks", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/webhooks", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/webhooks")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/superadmin/webhooks", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/superadmin/webhooks")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Listet API Keys ohne Hash oder Klartext-Key für `tenant_id`.

curl -X GET 'https://trinkgeldmeister.com/api/v1/superadmin/api-keys' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("GET", "https://trinkgeldmeister.com/api/v1/superadmin/api-keys", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/api-keys", {
  method: "GET",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/api-keys")!)
request.httpMethod = "GET"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("GET", "https://trinkgeldmeister.com/api/v1/superadmin/api-keys", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::GET, "https://trinkgeldmeister.com/api/v1/superadmin/api-keys")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Legt einen API Key an und gibt nur Metadaten zurück, nicht den Klartext-Key.

curl -X POST 'https://trinkgeldmeister.com/api/v1/superadmin/api-keys' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"tenant_id":1,"name":"API Managed Key","scopes":"tenant.read employee.read"}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/superadmin/api-keys", headers=headers, data="{\"tenant_id\":1,\"name\":\"API Managed Key\",\"scopes\":\"tenant.read employee.read\"}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/api-keys", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"tenant_id":1,"name":"API Managed Key","scopes":"tenant.read employee.read"})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"tenant_id":1,"name":"API Managed Key","scopes":"tenant.read employee.read"}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/api-keys")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"tenant_id\":1,\"name\":\"API Managed Key\",\"scopes\":\"tenant.read employee.read\"}")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/superadmin/api-keys", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/superadmin/api-keys")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"tenant_id\":1,\"name\":\"API Managed Key\",\"scopes\":\"tenant.read employee.read\"}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Aktualisiert Name, Scopes oder Status eines API Keys ohne Hash oder Klartext-Key offenzulegen.

curl -X PATCH 'https://trinkgeldmeister.com/api/v1/superadmin/api-keys/1' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"name":"API Managed Key Updated","scopes":"tenant.read employee.read payout.read","status":"active"}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("PATCH", "https://trinkgeldmeister.com/api/v1/superadmin/api-keys/1", headers=headers, data="{\"name\":\"API Managed Key Updated\",\"scopes\":\"tenant.read employee.read payout.read\",\"status\":\"active\"}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/api-keys/1", {
  method: "PATCH",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"name":"API Managed Key Updated","scopes":"tenant.read employee.read payout.read","status":"active"})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"name":"API Managed Key Updated","scopes":"tenant.read employee.read payout.read","status":"active"}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/api-keys/1")!)
request.httpMethod = "PATCH"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"name\":\"API Managed Key Updated\",\"scopes\":\"tenant.read employee.read payout.read\",\"status\":\"active\"}")
  req, _ := http.NewRequest("PATCH", "https://trinkgeldmeister.com/api/v1/superadmin/api-keys/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::PATCH, "https://trinkgeldmeister.com/api/v1/superadmin/api-keys/1")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"name\":\"API Managed Key Updated\",\"scopes\":\"tenant.read employee.read payout.read\",\"status\":\"active\"}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Sperrt einen API Key.

curl -X DELETE 'https://trinkgeldmeister.com/api/v1/superadmin/api-keys/1' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("DELETE", "https://trinkgeldmeister.com/api/v1/superadmin/api-keys/1", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/api-keys/1", {
  method: "DELETE",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/api-keys/1")!)
request.httpMethod = "DELETE"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("DELETE", "https://trinkgeldmeister.com/api/v1/superadmin/api-keys/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::DELETE, "https://trinkgeldmeister.com/api/v1/superadmin/api-keys/1")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Legt einen Kunden-Webhook für einen Mandanten an.

curl -X POST 'https://trinkgeldmeister.com/api/v1/superadmin/webhooks' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"tenant_id":1,"name":"API Webhook","url":"https://example.test/tgm","events":"payout.*"}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("POST", "https://trinkgeldmeister.com/api/v1/superadmin/webhooks", headers=headers, data="{\"tenant_id\":1,\"name\":\"API Webhook\",\"url\":\"https://example.test/tgm\",\"events\":\"payout.*\"}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/webhooks", {
  method: "POST",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"tenant_id":1,"name":"API Webhook","url":"https://example.test/tgm","events":"payout.*"})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"tenant_id":1,"name":"API Webhook","url":"https://example.test/tgm","events":"payout.*"}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/webhooks")!)
request.httpMethod = "POST"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"tenant_id\":1,\"name\":\"API Webhook\",\"url\":\"https://example.test/tgm\",\"events\":\"payout.*\"}")
  req, _ := http.NewRequest("POST", "https://trinkgeldmeister.com/api/v1/superadmin/webhooks", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::POST, "https://trinkgeldmeister.com/api/v1/superadmin/webhooks")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"tenant_id\":1,\"name\":\"API Webhook\",\"url\":\"https://example.test/tgm\",\"events\":\"payout.*\"}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Aktualisiert Name, URL, Events, Secret-Referenz oder Status eines Kunden-Webhooks.

curl -X PATCH 'https://trinkgeldmeister.com/api/v1/superadmin/webhooks/1' \
  -H 'Authorization: Bearer tgm_test_...' \
  -H 'Content-Type: application/json' \
  -d '{"name":"API Webhook Updated","url":"https://example.test/tgm-updated","events":"payout.*,billing.*","secret_ref":"env:TGM_WEBHOOK_SECRET","status":"active"}'

import requests
headers = {"Authorization":"Bearer tgm_test_...","Content-Type":"application/json"}
response = requests.request("PATCH", "https://trinkgeldmeister.com/api/v1/superadmin/webhooks/1", headers=headers, data="{\"name\":\"API Webhook Updated\",\"url\":\"https://example.test/tgm-updated\",\"events\":\"payout.*,billing.*\",\"secret_ref\":\"env:TGM_WEBHOOK_SECRET\",\"status\":\"active\"}")
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/webhooks/1", {
  method: "PATCH",
  headers: { Authorization: "Bearer tgm_test_...", "Content-Type": "application/json" },
  body: JSON.stringify({"name":"API Webhook Updated","url":"https://example.test/tgm-updated","events":"payout.*,billing.*","secret_ref":"env:TGM_WEBHOOK_SECRET","status":"active"})
});
console.log(response.status, await response.text());

import Foundation
let json = #"{"name":"API Webhook Updated","url":"https://example.test/tgm-updated","events":"payout.*,billing.*","secret_ref":"env:TGM_WEBHOOK_SECRET","status":"active"}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/webhooks/1")!)
request.httpMethod = "PATCH"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(json.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("{\"name\":\"API Webhook Updated\",\"url\":\"https://example.test/tgm-updated\",\"events\":\"payout.*,billing.*\",\"secret_ref\":\"env:TGM_WEBHOOK_SECRET\",\"status\":\"active\"}")
  req, _ := http.NewRequest("PATCH", "https://trinkgeldmeister.com/api/v1/superadmin/webhooks/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::PATCH, "https://trinkgeldmeister.com/api/v1/superadmin/webhooks/1")
    .bearer_auth("tgm_test_...")
    .header("Content-Type", "application/json")
    .body("{\"name\":\"API Webhook Updated\",\"url\":\"https://example.test/tgm-updated\",\"events\":\"payout.*,billing.*\",\"secret_ref\":\"env:TGM_WEBHOOK_SECRET\",\"status\":\"active\"}")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}

Deaktiviert einen Kunden-Webhook.

curl -X DELETE 'https://trinkgeldmeister.com/api/v1/superadmin/webhooks/1' \
  -H 'Authorization: Bearer tgm_test_...'

import requests
headers = {"Authorization":"Bearer tgm_test_..."}
response = requests.request("DELETE", "https://trinkgeldmeister.com/api/v1/superadmin/webhooks/1", headers=headers)
print(response.status_code, response.text)

const response = await fetch("https://trinkgeldmeister.com/api/v1/superadmin/webhooks/1", {
  method: "DELETE",
  headers: { Authorization: "Bearer tgm_test_..." }
});
console.log(response.status, await response.text());

import Foundation
let json = #"{}"#
var request = URLRequest(url: URL(string: "https://trinkgeldmeister.com/api/v1/superadmin/webhooks/1")!)
request.httpMethod = "DELETE"
request.setValue("Bearer tgm_test_...", forHTTPHeaderField: "Authorization")

let (data, response) = try await URLSession.shared.data(for: request)
print((response as! HTTPURLResponse).statusCode, String(data: data, encoding: .utf8)!)

package main
import ("bytes"; "fmt"; "io"; "log"; "net/http")
func main() {
  body := []byte("")
  req, _ := http.NewRequest("DELETE", "https://trinkgeldmeister.com/api/v1/superadmin/webhooks/1", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer tgm_test_...")
  req.Body = nil
  res, err := http.DefaultClient.Do(req); if err != nil { log.Fatal(err) }
  defer res.Body.Close()
  raw, _ := io.ReadAll(res.Body)
  fmt.Println(res.StatusCode, string(raw))
}

use reqwest::{Client, Method};
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let response = Client::new()
    .request(Method::DELETE, "https://trinkgeldmeister.com/api/v1/superadmin/webhooks/1")
    .bearer_auth("tgm_test_...")
    .send().await?;
  println!("{} {}", response.status(), response.text().await?);
  Ok(())
}