Connect meiti to your system — in one afternoon.

curl https://api.meiti.ai/v1/messages \
  -H "X-Api-Key: $MEITI_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: invoice-2024-117-ready" \
  -d '{
    "phone": "+491701234567",
    "text": "Hallo Frau Weber, Ihre Rechnung 2024-117 ist fertig. Fragen? Antworten Sie einfach hier.",
    "purpose": "service"
  }'

const res = await fetch("https://api.meiti.ai/v1/messages", {
  method: "POST",
  headers: {
    "X-Api-Key": process.env.MEITI_API_KEY,
    "Content-Type": "application/json",
    // Same key on a retry = the message is sent only once.
    "Idempotency-Key": `invoice-${invoice.number}-ready`,
  },
  body: JSON.stringify({
    phone: customer.phone,
    text: `Hallo ${customer.name}, Ihre Rechnung ${invoice.number} ist fertig. Fragen? Antworten Sie einfach hier.`,
    purpose: "service",
  }),
});
const sent = await res.json(); // 202: { projectId, contactId, messageId, status, channel }

import os, requests

res = requests.post(
    "https://api.meiti.ai/v1/messages",
    headers={
        "X-Api-Key": os.environ["MEITI_API_KEY"],
        # Same key on a retry = the message is sent only once.
        "Idempotency-Key": f"invoice-{invoice.number}-ready",
    },
    json={
        "phone": customer.phone,
        "text": f"Hallo {customer.name}, Ihre Rechnung {invoice.number} ist fertig. Fragen? Antworten Sie einfach hier.",
        "purpose": "service",
    },
)
sent = res.json()  # 202: projectId, contactId, messageId, status, channel

// call() from the quickstart; the last two args set the Idempotency-Key header.
sent, status, err := call("POST", "/v1/messages", map[string]any{
	"phone":   customer.Phone,
	"text":    fmt.Sprintf("Hallo %s, Ihre Rechnung %s ist fertig. Fragen? Antworten Sie einfach hier.", customer.Name, invoice.Number),
	"purpose": "service",
}, "Idempotency-Key", "invoice-"+invoice.Number+"-ready") // same key on a retry = sent only once
if err != nil {
	log.Fatal(err)
}
fmt.Println(status, sent["status"], sent["channel"]) // 202 queued whatsapp

using var request = new HttpRequestMessage(HttpMethod.Post, "v1/messages")
{
    Content = JsonContent.Create(new
    {
        phone = customer.Phone,
        text = $"Hallo {customer.Name}, Ihre Rechnung {invoice.Number} ist fertig. Fragen? Antworten Sie einfach hier.",
        purpose = "service",
    }),
};
// Same key on a retry = the message is sent only once.
request.Headers.Add("Idempotency-Key", $"invoice-{invoice.Number}-ready");

var res = await http.SendAsync(request); // http from the quickstart (BaseAddress + X-Api-Key)
var sent = await res.Content.ReadFromJsonAsync<JsonElement>(); // 202: projectId, contactId, messageId, status, channel

<?php
$ch = curl_init("https://api.meiti.ai/v1/messages");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "X-Api-Key: " . getenv("MEITI_API_KEY"),
        "Content-Type: application/json",
        // Same key on a retry = the message is sent only once.
        "Idempotency-Key: invoice-{$invoice['number']}-ready",
    ],
    CURLOPT_POSTFIELDS => json_encode([
        "phone" => $customer["phone"],
        "text" => "Hallo {$customer['name']}, Ihre Rechnung {$invoice['number']} ist fertig. Fragen? Antworten Sie einfach hier.",
        "purpose" => "service",
    ]),
]);
$sent = json_decode(curl_exec($ch), true); // 202: projectId, contactId, messageId, status, channel

curl https://api.meiti.ai/v1/contacts \
  -H "X-Api-Key: $MEITI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "phone": "+491701234567",
    "firstName": "Ingrid",
    "lastName": "Weber",
    "email": "ingrid.weber@example.com",
    "serviceConsent": true
  }'
# 201 = created, 200 = updated. Keep the returned "id" next to your own customer id.

const res = await fetch("https://api.meiti.ai/v1/contacts", {
  method: "POST",
  headers: { "X-Api-Key": process.env.MEITI_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({
    phone: "+491701234567",
    firstName: "Ingrid",
    lastName: "Weber",
    email: "ingrid.weber@example.com",
    serviceConsent: true,
  }),
});
const contact = await res.json(); // 201 created / 200 updated
await crm.customers.update(customerId, { meitiContactId: contact.id });

res = requests.post(
    "https://api.meiti.ai/v1/contacts",
    headers={"X-Api-Key": os.environ["MEITI_API_KEY"]},
    json={
        "phone": "+491701234567",
        "firstName": "Ingrid",
        "lastName": "Weber",
        "email": "ingrid.weber@example.com",
        "serviceConsent": True,
    },
)
contact = res.json()  # 201 created / 200 updated
crm.customers.update(customer_id, meiti_contact_id=contact["id"])

contact, status, err := call("POST", "/v1/contacts", map[string]any{
	"phone":          "+491701234567",
	"firstName":      "Ingrid",
	"lastName":       "Weber",
	"email":          "ingrid.weber@example.com",
	"serviceConsent": true,
})
if err != nil || status >= 300 {
	log.Fatal(status, err, contact)
}
// 201 created / 200 updated — keep the id next to your own customer id
crm.SaveMeitiContactID(customerID, int(contact["id"].(float64)))

var res = await http.PostAsJsonAsync("v1/contacts", new
{
    phone = "+491701234567",
    firstName = "Ingrid",
    lastName = "Weber",
    email = "ingrid.weber@example.com",
    serviceConsent = true,
});
var contact = await res.Content.ReadFromJsonAsync<JsonElement>(); // 201 created / 200 updated
customer.MeitiContactId = contact.GetProperty("id").GetInt32();

<?php
$ch = curl_init("https://api.meiti.ai/v1/contacts");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["X-Api-Key: " . getenv("MEITI_API_KEY"), "Content-Type: application/json"],
    CURLOPT_POSTFIELDS => json_encode([
        "phone" => "+491701234567",
        "firstName" => "Ingrid",
        "lastName" => "Weber",
        "email" => "ingrid.weber@example.com",
        "serviceConsent" => true,
    ]),
]);
$contact = json_decode(curl_exec($ch), true); // 201 created / 200 updated
$crm->updateCustomer($customerId, ["meiti_contact_id" => $contact["id"]]);

curl https://api.meiti.ai/v1/messages/log \
  -H "X-Api-Key: $MEITI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "erika.weber@example.com",
    "direction": "in",
    "channel": "email",
    "subject": "Angebot Badsanierung",
    "text": "Hallo, wann können Sie diese Woche vorbeikommen?",
    "occurredAt": "2026-10-09T08:12:00Z",
    "externalId": "<CAF7x9Q@mail.gmail.com>"
  }'

// e.g. from an n8n Gmail trigger: one call per new mail in your own mailbox.
const res = await fetch("https://api.meiti.ai/v1/messages/log", {
  method: "POST",
  headers: { "X-Api-Key": process.env.MEITI_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({
    email: mail.from,
    direction: "in",                // "out" for mails your team sent
    channel: "email",
    subject: mail.subject,
    text: mail.text,
    occurredAt: mail.date,
    externalId: mail.messageId,     // same id again = filed only once
  }),
});
const logged = await res.json(); // 201: { projectId, contactId, messageId, created: true, truncated }

import os, requests

res = requests.post(
    "https://api.meiti.ai/v1/messages/log",
    headers={"X-Api-Key": os.environ["MEITI_API_KEY"]},
    json={
        "email": mail.sender,
        "direction": "in",             # "out" for mails your team sent
        "channel": "email",
        "subject": mail.subject,
        "text": mail.text,
        "occurredAt": mail.date.isoformat(),
        "externalId": mail.message_id,  # same id again = filed only once
    },
)
logged = res.json()  # 201 (200 if logged before): projectId, contactId, messageId, created, truncated

// call() from the quickstart.
logged, status, err := call("POST", "/v1/messages/log", map[string]any{
	"email":      mail.From,
	"direction":  "in", // "out" for mails your team sent
	"channel":    "email",
	"subject":    mail.Subject,
	"text":       mail.Text,
	"occurredAt": mail.Date.Format(time.RFC3339),
	"externalId": mail.MessageID, // same id again = filed only once
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(status, logged["projectId"], logged["created"]) // 201 67890 true

var res = await http.PostAsJsonAsync("v1/messages/log", new // http from the quickstart
{
    email = mail.From,
    direction = "in",            // "out" for mails your team sent
    channel = "email",
    subject = mail.Subject,
    text = mail.TextBody,
    occurredAt = mail.Date,
    externalId = mail.MessageId, // same id again = filed only once
});
var logged = await res.Content.ReadFromJsonAsync<JsonElement>(); // 201: projectId, contactId, messageId, created, truncated

<?php
$ch = curl_init("https://api.meiti.ai/v1/messages/log");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["X-Api-Key: " . getenv("MEITI_API_KEY"), "Content-Type: application/json"],
    CURLOPT_POSTFIELDS => json_encode([
        "email" => $mail["from"],
        "direction" => "in",              // "out" for mails your team sent
        "channel" => "email",
        "subject" => $mail["subject"],
        "text" => $mail["text"],
        "occurredAt" => $mail["date"],
        "externalId" => $mail["messageId"], // same id again = filed only once
    ]),
]);
$logged = json_decode(curl_exec($ch), true); // 201: projectId, contactId, messageId, created, truncated

curl https://api.meiti.ai/v1/notes \
  -H "X-Api-Key: $MEITI_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: crm-note-4711" \
  -d '{
    "phone": "+491701234567",
    "title": "Aus dem CRM",
    "text": "Kundin möchte nur vormittags angerufen werden. Offene Rechnung 2024-117."
  }'

const res = await fetch("https://api.meiti.ai/v1/notes", {
  method: "POST",
  headers: {
    "X-Api-Key": process.env.MEITI_API_KEY,
    "Content-Type": "application/json",
    "Idempotency-Key": `crm-note-${note.id}`, // same key on a retry = one note
  },
  body: JSON.stringify({ phone: customer.phone, title: "Aus dem CRM", text: note.text }),
});
const created = await res.json(); // 201: { projectId, contactId, noteId }

import os, requests

res = requests.post(
    "https://api.meiti.ai/v1/notes",
    headers={
        "X-Api-Key": os.environ["MEITI_API_KEY"],
        "Idempotency-Key": f"crm-note-{note.id}",  # same key on a retry = one note
    },
    json={"phone": customer.phone, "title": "Aus dem CRM", "text": note.text},
)
created = res.json()  # 201: projectId, contactId, noteId

// call() from the quickstart; the last two args set the Idempotency-Key header.
created, status, err := call("POST", "/v1/notes", map[string]any{
	"phone": customer.Phone,
	"title": "Aus dem CRM",
	"text":  note.Text,
}, "Idempotency-Key", "crm-note-"+note.ID) // same key on a retry = one note
if err != nil {
	log.Fatal(err)
}
fmt.Println(status, created["noteId"]) // 201 5531

using var request = new HttpRequestMessage(HttpMethod.Post, "v1/notes")
{
    Content = JsonContent.Create(new { phone = customer.Phone, title = "Aus dem CRM", text = note.Text }),
};
request.Headers.Add("Idempotency-Key", $"crm-note-{note.Id}"); // same key on a retry = one note

var res = await http.SendAsync(request); // http from the quickstart
var created = await res.Content.ReadFromJsonAsync<JsonElement>(); // 201: projectId, contactId, noteId

<?php
$ch = curl_init("https://api.meiti.ai/v1/notes");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "X-Api-Key: " . getenv("MEITI_API_KEY"),
        "Content-Type: application/json",
        "Idempotency-Key: crm-note-{$note['id']}", // same key on a retry = one note
    ],
    CURLOPT_POSTFIELDS => json_encode(["phone" => $customer["phone"], "title" => "Aus dem CRM", "text" => $note["text"]]),
]);
$created = json_decode(curl_exec($ch), true); // 201: projectId, contactId, noteId

curl https://api.meiti.ai/v1/appointments \
  -H "X-Api-Key: $MEITI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "phone": "+491701234567",
    "start": "2026-10-20T08:00:00Z",
    "durationMinutes": 60,
    "title": "Heizungswartung",
    "kind": "in_person",
    "confirmed": false,
    "externalId": "CAL-8812",
    "metadata": { "technician": "Jonas" }
  }'

const res = await fetch("https://api.meiti.ai/v1/appointments", {
  method: "POST",
  headers: { "X-Api-Key": process.env.MEITI_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({
    phone: "+491701234567",
    start: "2026-10-20T08:00:00Z",
    durationMinutes: 60,
    title: "Heizungswartung",
    confirmed: false,          // meiti asks the customer to confirm
    externalId: calendarEvent.id, // comes back on every read and webhook
    metadata: { technician: "Jonas" },
  }),
});
const appointment = await res.json(); // 201: { id, status: "proposed", startLocal, … }

res = requests.post(
    "https://api.meiti.ai/v1/appointments",
    headers={"X-Api-Key": os.environ["MEITI_API_KEY"]},
    json={
        "phone": "+491701234567",
        "start": "2026-10-20T08:00:00Z",
        "durationMinutes": 60,
        "title": "Heizungswartung",
        "confirmed": False,            # meiti asks the customer to confirm
        "externalId": calendar_event.id,  # comes back on every read and webhook
        "metadata": {"technician": "Jonas"},
    },
)
appointment = res.json()  # 201: id, status "proposed", startLocal, ...

appointment, status, err := call("POST", "/v1/appointments", map[string]any{
	"phone":           "+491701234567",
	"start":           "2026-10-20T08:00:00Z",
	"durationMinutes": 60,
	"title":           "Heizungswartung",
	"kind":            "in_person",
	"confirmed":       false,                      // meiti asks the customer to confirm
	"externalId":      calendarEvent.ID,           // comes back on every read and webhook
	"metadata":        map[string]string{"technician": "Jonas"},
})
if err != nil || status != 201 {
	log.Fatal(status, err, appointment)
}
fmt.Println(appointment["id"], appointment["status"]) // … proposed

var res = await http.PostAsJsonAsync("v1/appointments", new
{
    phone = "+491701234567",
    start = new DateTime(2026, 10, 20, 8, 0, 0, DateTimeKind.Utc),
    durationMinutes = 60,
    title = "Heizungswartung",
    confirmed = false,              // meiti asks the customer to confirm
    externalId = calendarEvent.Id,  // comes back on every read and webhook
    metadata = new Dictionary<string, string> { ["technician"] = "Jonas" },
});
var appointment = await res.Content.ReadFromJsonAsync<JsonElement>(); // 201: id, status "proposed", …

<?php
$ch = curl_init("https://api.meiti.ai/v1/appointments");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["X-Api-Key: " . getenv("MEITI_API_KEY"), "Content-Type: application/json"],
    CURLOPT_POSTFIELDS => json_encode([
        "phone" => "+491701234567",
        "start" => "2026-10-20T08:00:00Z",
        "durationMinutes" => 60,
        "title" => "Heizungswartung",
        "confirmed" => false,            // meiti asks the customer to confirm
        "externalId" => $calendarEvent["id"],
        "metadata" => ["technician" => "Jonas"],
    ]),
]);
$appointment = json_decode(curl_exec($ch), true); // 201: id, status "proposed", …

curl https://api.meiti.ai/v1/webhooks \
  -H "X-Api-Key: $MEITI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://crm.example.com/meiti/events",
    "events": ["appointment.confirmed", "appointment.cancelled", "appointment.rescheduled"],
    "description": "Kalender-Sync"
  }'
# The response contains "secret" exactly once — store it, it signs every delivery.

const res = await fetch("https://api.meiti.ai/v1/webhooks", {
  method: "POST",
  headers: { "X-Api-Key": process.env.MEITI_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({
    url: "https://crm.example.com/meiti/events",
    events: ["appointment.confirmed", "appointment.cancelled", "appointment.rescheduled"],
    description: "Kalender-Sync",
  }),
});
const { subscription, secret } = await res.json(); // secret is shown exactly once

res = requests.post(
    "https://api.meiti.ai/v1/webhooks",
    headers={"X-Api-Key": os.environ["MEITI_API_KEY"]},
    json={
        "url": "https://crm.example.com/meiti/events",
        "events": ["appointment.confirmed", "appointment.cancelled", "appointment.rescheduled"],
        "description": "Kalender-Sync",
    },
)
secret = res.json()["secret"]  # shown exactly once

created, status, err := call("POST", "/v1/webhooks", map[string]any{
	"url":         "https://crm.example.com/meiti/events",
	"events":      []string{"appointment.confirmed", "appointment.cancelled", "appointment.rescheduled"},
	"description": "Kalender-Sync",
})
if err != nil || status != 201 {
	log.Fatal(status, err, created)
}
secret := created["secret"].(string) // shown exactly once — store it
saveSecret(secret)

var res = await http.PostAsJsonAsync("v1/webhooks", new
{
    url = "https://crm.example.com/meiti/events",
    events = new[] { "appointment.confirmed", "appointment.cancelled", "appointment.rescheduled" },
    description = "Kalender-Sync",
});
var secret = (await res.Content.ReadFromJsonAsync<JsonElement>()).GetProperty("secret").GetString(); // shown exactly once

<?php
$ch = curl_init("https://api.meiti.ai/v1/webhooks");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["X-Api-Key: " . getenv("MEITI_API_KEY"), "Content-Type: application/json"],
    CURLOPT_POSTFIELDS => json_encode([
        "url" => "https://crm.example.com/meiti/events",
        "events" => ["appointment.confirmed", "appointment.cancelled", "appointment.rescheduled"],
        "description" => "Kalender-Sync",
    ]),
]);
$secret = json_decode(curl_exec($ch), true)["secret"]; // shown exactly once

// https works everywhere; "meiti://open" opens the installed app directly (e.g. from a desktop CRM).
const base = "https://m.meiti.ai/open";

const openCase     = `${base}/project?crmId=${encodeURIComponent(caseRecord.number)}`;
const openCustomer = `${base}/project?crmContactId=${encodeURIComponent(customer.number)}`;
const openById     = `${base}/project?id=${meitiProjectId}`; // projectData.meitiProjectId from the webhook
const call         = `${base}/dial?number=${encodeURIComponent(customer.phone)}`;

from urllib.parse import quote

# https works everywhere; "meiti://open" opens the installed app directly (e.g. from a desktop CRM).
BASE = "https://m.meiti.ai/open"

open_case = f"{BASE}/project?crmId={quote(case.number, safe='')}"
open_customer = f"{BASE}/project?crmContactId={quote(customer.number, safe='')}"
open_by_id = f"{BASE}/project?id={meiti_project_id}"  # projectData.meitiProjectId from the webhook
call = f"{BASE}/dial?number={quote(customer.phone, safe='')}"

// imports: fmt, net/url, strings
// https works everywhere; "meiti://open" opens the installed app directly (e.g. from a desktop CRM).
const base = "https://m.meiti.ai/open"

// QueryEscape encodes & = / +, but turns spaces into "+"; meiti expects %20.
func esc(v string) string { return strings.ReplaceAll(url.QueryEscape(v), "+", "%20") }

func meitiLinks(caseNumber, customerNumber, phone string, meitiProjectID int) []string {
	return []string{
		base + "/project?crmId=" + esc(caseNumber),
		base + "/project?crmContactId=" + esc(customerNumber),
		fmt.Sprintf("%s/project?id=%d", base, meitiProjectID), // projectData.meitiProjectId from the webhook
		base + "/dial?number=" + esc(phone),
	}
}

using System.Diagnostics;

// Web CRM: https works everywhere. Windows desktop app with meiti installed: use "meiti://open".
var scheme = "https://m.meiti.ai/open"; // or "meiti://open"

var openCase     = $"{scheme}/project?crmId={Uri.EscapeDataString(caseRecord.Number)}";
var openCustomer = $"{scheme}/project?crmContactId={Uri.EscapeDataString(customer.Number)}";
var openById     = $"{scheme}/project?id={meitiProjectId}"; // projectData.meitiProjectId from the webhook
var call         = $"{scheme}/dial?number={Uri.EscapeDataString(customer.Phone)}";

Process.Start(new ProcessStartInfo(openCase) { UseShellExecute = true }); // hands the link to the OS

<?php
// https works everywhere; "meiti://open" opens the installed app directly (e.g. from a desktop CRM).
$base = "https://m.meiti.ai/open";

$openCase     = "$base/project?crmId=" . rawurlencode($case["number"]);
$openCustomer = "$base/project?crmContactId=" . rawurlencode($customer["number"]);
$openById     = "$base/project?id=" . (int)$meitiProjectId; // projectData.meitiProjectId from the webhook
$call         = "$base/dial?number=" . rawurlencode($customer["phone"]);

<!-- In your CRM's case view -->
<a href="https://m.meiti.ai/open/project?crmId=AZ-2024%2F117">In meiti öffnen</a>

<!-- Next to a phone number -->
<a href="https://m.meiti.ai/open/dial?number=%2B491701234567">Mit meiti anrufen</a>