Zimun Zimun: Appointment Scheduling & Booking Service

Zimun: Appointment Scheduling & Booking Service: Booking-API-Beispiele

API

Diese Beispiele zeigen vollständige Abläufe in Python, Node.js, Go und Rust. Kopiere sie, ersetze deine IDs, und du hast eine funktionierende Integration.

1) Zugriffstoken anfordern

Nutze OAuth2 Client Credentials, um vor jedem API‑Aufruf ein kurzlebiges Token anzufordern.

Python 
import os
import requests

token_resp = requests.post(
    "https://api.zimun.online/oauth/token",
    auth=(os.getenv("ZIMUN_CLIENT_ID"), os.getenv("ZIMUN_CLIENT_SECRET")),
    data={"grant_type": "client_credentials"},
)
token = token_resp.json()["access_token"]
headers = {"Authorization": f"Bearer {token}"}
Node.js 
import axios from "axios";

const tokenResp = await axios.post(
  "https://api.zimun.online/oauth/token",
  new URLSearchParams({ grant_type: "client_credentials" }),
  {
    auth: {
      username: process.env.ZIMUN_CLIENT_ID,
      password: process.env.ZIMUN_CLIENT_SECRET,
    },
  }
);
const token = tokenResp.data.access_token;
const headers = { Authorization: `Bearer ${token}` };
Go 
client := &http.Client{}
req, _ := http.NewRequest("POST", "https://api.zimun.online/oauth/token", strings.NewReader("grant_type=client_credentials"))
req.SetBasicAuth(os.Getenv("ZIMUN_CLIENT_ID"), os.Getenv("ZIMUN_CLIENT_SECRET"))
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
resp, _ := client.Do(req)
defer resp.Body.Close()
Rust 
let client = reqwest::Client::new();
let resp = client
  .post("https://api.zimun.online/oauth/token")
  .basic_auth(std::env::var("ZIMUN_CLIENT_ID")?, Some(std::env::var("ZIMUN_CLIENT_SECRET")?))
  .form(&[("grant_type", "client_credentials")])
  .send()
  .await?;
let json: serde_json::Value = resp.json().await?;
let token = json["access_token"].as_str().unwrap();

2) Services auflisten

Rufen Sie zuerst die Services der Organisation ab und verwenden Sie dann eine ausgewählte service_id in Verfügbarkeits- und Buchungsaufrufen.

Python 
services = requests.get(
    "https://api.zimun.online/api/v1/services?page_size=50",
    headers=headers,
).json()

first_service_id = services["items"][0]["id"] if services.get("items") else None
Node.js 
const services = await axios.get(
  "https://api.zimun.online/api/v1/services?page_size=50",
  { headers }
);

const firstServiceId = services.data.items?.[0]?.id || null;
Go 
servicesReq, _ := http.NewRequest("GET", "https://api.zimun.online/api/v1/services?page_size=50", nil)
servicesReq.Header.Set("Authorization", "Bearer "+token)
servicesResp, _ := client.Do(servicesReq)
defer servicesResp.Body.Close()
Rust 
let services = client
  .get("https://api.zimun.online/api/v1/services?page_size=50")
  .bearer_auth(token)
  .send()
  .await?;

let body: serde_json::Value = services.json().await?;

3) Verfügbarkeit abrufen

Lesen Sie offene Slots für einen ausgewählten Dienst an einem bestimmten Datum.

Python 
single_day = requests.get(
    "https://api.zimun.online/api/v1/availability?service_id=s_123&date=2026-02-20",
    headers=headers,
).json()
Node.js 
const singleDay = await axios.get(
  "https://api.zimun.online/api/v1/availability?service_id=s_123&date=2026-02-20",
  { headers }
);
Go 
availReq, _ := http.NewRequest("GET", "https://api.zimun.online/api/v1/availability?service_id=s_123&date=2026-02-20", nil)
availReq.Header.Set("Authorization", "Bearer "+token)
availResp, _ := client.Do(availReq)
defer availResp.Body.Close()
Rust 
let availability = client
  .get("https://api.zimun.online/api/v1/availability?service_id=s_123&date=2026-02-20")
  .bearer_auth(token)
  .send()
  .await?;

4) Hold → Bestätigen

Dies ist der Buchungsabschluss-Flow, nachdem Sie bereits einen gültigen Service und eine gültige Zeit ausgewählt haben.

Python 
# create hold
hold = requests.post(
    "https://api.zimun.online/api/v1/appointments/hold",
    headers=headers,
    json={
        "service_id": "s_123",
        "appointment_time": "2025-12-01T10:00:00Z",
    },
).json()

# 3) confirm
confirm = requests.post(
    "https://api.zimun.online/api/v1/appointments/confirm",
    headers=headers,
    json={
        "hold_id": hold["hold_id"],
        "contact_name": "Dana Lee",
        "contact_email": "dana@example.com",
    },
).json()
Node.js 
const hold = await axios.post(
  "https://api.zimun.online/api/v1/appointments/hold",
  {
    service_id: "s_123",
    appointment_time: "2025-12-01T10:00:00Z",
  },
  { headers }
);

const confirm = await axios.post(
  "https://api.zimun.online/api/v1/appointments/confirm",
  {
    hold_id: hold.data.hold_id,
    contact_name: "Dana Lee",
    contact_email: "dana@example.com",
  },
  { headers }
);
Go 
// hold
holdBody := `{"service_id":"s_123","appointment_time":"2025-12-01T10:00:00Z"}`
holdReq, _ := http.NewRequest("POST", "https://api.zimun.online/api/v1/appointments/hold", strings.NewReader(holdBody))
holdReq.Header.Set("Authorization", "Bearer "+token)
holdReq.Header.Set("Content-Type", "application/json")
holdResp, _ := client.Do(holdReq)
Rust 
let hold = client
  .post("https://api.zimun.online/api/v1/appointments/hold")
  .bearer_auth(token)
  .json(&serde_json::json!({
      "service_id": "s_123",
      "appointment_time": "2025-12-01T10:00:00Z"
  }))
  .send()
  .await?;

5) Einen Termin verschieben oder absagen

Verwenden Sie /api/v1-Endpunkte mit Ihrem Bearer-Token, um einen vorhandenen Termin anhand der Termin-ID zu aktualisieren.

Python 
rescheduled = requests.post(
    "https://api.zimun.online/api/v1/appointments/reschedule",
    headers=headers,
    json={
        "appointment_id": "a_123",
        "start_time": "2026-02-20T13:00:00Z",
    },
).json()

cancelled = requests.post(
    "https://api.zimun.online/api/v1/appointments/cancel",
    headers=headers,
    json={"appointment_id": "a_123"},
).json()
Node.js 
const rescheduled = await axios.post(
  "https://api.zimun.online/api/v1/appointments/reschedule",
  { appointment_id: "a_123", start_time: "2026-02-20T13:00:00Z" },
  { headers }
);

const cancelled = await axios.post(
  "https://api.zimun.online/api/v1/appointments/cancel",
  { appointment_id: "a_123" },
  { headers }
);
Go 
rescheduleBody := `{"appointment_id":"a_123","start_time":"2026-02-20T13:00:00Z"}`
rescheduleReq, _ := http.NewRequest("POST", "https://api.zimun.online/api/v1/appointments/reschedule", strings.NewReader(rescheduleBody))
rescheduleReq.Header.Set("Authorization", "Bearer "+token)
rescheduleReq.Header.Set("Content-Type", "application/json")
rescheduleResp, _ := client.Do(rescheduleReq)
defer rescheduleResp.Body.Close()

cancelBody := `{"appointment_id":"a_123"}`
cancelReq, _ := http.NewRequest("POST", "https://api.zimun.online/api/v1/appointments/cancel", strings.NewReader(cancelBody))
cancelReq.Header.Set("Authorization", "Bearer "+token)
cancelReq.Header.Set("Content-Type", "application/json")
cancelResp, _ := client.Do(cancelReq)
defer cancelResp.Body.Close()
Rust 
let rescheduled = client
  .post("https://api.zimun.online/api/v1/appointments/reschedule")
  .bearer_auth(token)
  .json(&serde_json::json!({
    "appointment_id": "a_123",
    "start_time": "2026-02-20T13:00:00Z"
  }))
  .send()
  .await?;

let cancelled = client
  .post("https://api.zimun.online/api/v1/appointments/cancel")
  .bearer_auth(token)
  .json(&serde_json::json!({ "appointment_id": "a_123" }))
  .send()
  .await?;