TikTok-API in Python und Node.js: Praxisbeispiele
Die TikTok API for Business lässt sich mit Python oder Node.js über einfache HTTPS-Anfragen nutzen: Jeder Aufruf geht an https://business-api.tiktok.com/open_api/v1.3 mit dem Token des Kontos im Header Access-Token und seiner open_id als business_id. TikTok antwortet auf die meisten Aufrufe mit HTTP 200 und einem Feld code, bei Erfolg 0. Prüfen Sie deshalb dieses Feld und warten Sie bei 40100 fünf Minuten.
easyCoexistence gibt Claude, ChatGPT oder Ihrem eigenen Code dieselben TikTok-Aufgaben als Tools, von publish_tiktok_post und reply_to_comment bis get_social_insights, und übergibt Ihren Skripten über get_social_credentials oder die Partner API ein aktuelles Token.
HTTP-Status der meisten TikTok-Antworten, auch bei Fehlern; nur ein code von 0 im Body bedeutet, dass der Aufruf erfolgreich war.
Code für gedrosselte Aufrufe: TikTok verlangt nach einem Minutenlimit eine Pause von 5 Minuten und nach einem Tageslimit eine Pause bis 00:00 UTC.
Serverfehler, nach denen TikTok empfiehlt, etwa 5 Minuten zu warten, bevor erneut aufgerufen wird.
Pfade enden mit einem Schrägstrich. Ohne ihn nennt TikTok /tt_user/oauth2/refresh_token als Ursache für 404 page not found.
Python, JavaScript und Java im SDK der TikTok API for Business; dessen Endpoint-Liste enthält keinen /business/-Endpoint.
Signatur im Header Tiktok-Signature jedes Webhooks, berechnet über den Zeitstempel, einen Punkt und den Body, mit dem App-Secret als Schlüssel.
Was braucht jeder TikTok-API-Aufruf?
Dieselben fünf Dinge, unabhängig von der Aufgabe:
- Die Basis-URL https://business-api.tiktok.com/
open_api/v1.3, mit einem Pfad, der mit einem Schrägstrich endet, etwa /business/video/list/. - Das Access-Token des Kontos im Header Access-Token, das vor Ablauf seiner 24 Stunden erneuert wird.
business_id, dieopen_iddes Kontos: bei GET im Query-String, bei POST im JSON-Body.- Listen- und Objektparameter bei GET, etwa fields und filters, als JSON-Text gesendet: fields=["
item_id","caption"]. - Eine Prüfung von code in der Antwort, denn TikTok sendet Fehler wie 40002 oder 40100 mit HTTP 200, und data nur, wenn code 0 ist.
Wie behandeln Sie das Antwortformat von TikTok bei Fehlern in Python?
Mit einem kleinen Client, der business_id dorthin setzt, wo jede Methode sie erwartet, bei code 0 die data zurückgibt und sonst eine TikTokError auslöst. Ein gedrosselter Aufruf wird nach der 5-minütigen Pause von TikTok wiederholt, denn 40100 bedeutet, dass TikTok den Aufruf abgelehnt hat. Ein 5xx wiederholt er nur bei GET, weil eine Veröffentlichung, die mit einem Serverfehler endete, TikTok trotzdem erreicht haben kann. Er braucht requests, und die späteren Python-Beispiele verwenden ihn wieder:
import json
import os
import time
import requests
API = "https://business-api.tiktok.com/open_api/v1.3"
class TikTokError(Exception):
def __init__(self, code, message, request_id):
super().__init__(f"TikTok {code}: {message} (request_id {request_id})")
self.code = code
class TikTok:
"""One TikTok account: its access token and its business_id, the open_id."""
def __init__(self, access_token, business_id, pause=300):
self.http = requests.Session()
self.http.headers["Access-Token"] = access_token
self.business_id = business_id
self.pause = pause # TikTok's advice after a 40100 or a 5xx: about 5 minutes
def call(self, method, path, params=None, body=None, tries=3):
for attempt in range(1, tries + 1):
if method == "GET":
query = {"business_id": self.business_id}
for key, value in (params or {}).items():
is_json = isinstance(value, (list, dict))
query[key] = json.dumps(value, separators=(",", ":")) if is_json else value
res = self.http.get(f"{API}/{path}", params=query, timeout=30)
else:
payload = {"business_id": self.business_id, **(body or {})}
res = self.http.post(f"{API}/{path}", json=payload, timeout=30)
if res.status_code >= 500 and method == "GET" and attempt < tries:
time.sleep(self.pause) # a POST is not repeated: it may have reached TikTok
continue
res.raise_for_status() # a 4xx: a wrong path or method, such as a missing final slash
answer = res.json()
if answer.get("code") == 0:
return answer.get("data") or {}
if answer.get("code") == 40100 and attempt < tries:
time.sleep(self.pause) # throttled: TikTok refused the call, so repeating it is safe
continue
raise TikTokError(answer.get("code"), answer.get("message"), answer.get("request_id"))
tt = TikTok(os.environ["TIKTOK_ACCESS_TOKEN"], os.environ["TIKTOK_BUSINESS_ID"])Wie gehen Sie damit in Node.js um?
Derselbe Client auf dem fetch, der in Node.js 18 und neueren Versionen integriert ist, ohne etwas zu installieren. Er kodiert Listenparameter bei GET als JSON, setzt business_id bei POST in den Body und behält den code von TikTok im Fehler, damit Aufrufer 40102 oder 40105, ein Token-Problem, von 40001, einer fehlenden Berechtigung, unterscheiden können:
const API = "https://business-api.tiktok.com/open_api/v1.3";
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
class TikTokError extends Error {
constructor(code, message, requestId) {
super("TikTok " + code + ": " + message + " (request_id " + requestId + ")");
this.code = code;
}
}
// One TikTok account: its access token and its business_id, the open_id.
class TikTok {
constructor(accessToken, businessId, pauseMs = 300000) {
this.accessToken = accessToken;
this.businessId = businessId;
this.pauseMs = pauseMs; // TikTok's advice after a 40100 or a 5xx: about 5 minutes
}
async call(method, path, { params = {}, body = {} } = {}, tries = 3) {
for (let attempt = 1; ; attempt++) {
const url = new URL(API + "/" + path);
const init = { method, headers: { "Access-Token": this.accessToken } };
if (method === "GET") {
url.searchParams.set("business_id", this.businessId);
for (const [key, value] of Object.entries(params)) {
url.searchParams.set(key, typeof value === "object" ? JSON.stringify(value) : String(value));
}
} else {
init.headers["Content-Type"] = "application/json";
init.body = JSON.stringify({ business_id: this.businessId, ...body });
}
const res = await fetch(url, init);
if (res.status >= 500 && method === "GET" && attempt < tries) {
await sleep(this.pauseMs); // a POST is not repeated: it may have reached TikTok
continue;
}
if (!res.ok) throw new Error("HTTP " + res.status + " on " + path + ": check the path, its final slash and the method");
const answer = await res.json();
if (answer.code === 0) return answer.data ?? {};
if (answer.code === 40100 && attempt < tries) {
await sleep(this.pauseMs); // throttled: TikTok refused the call, so repeating it is safe
continue;
}
throw new TikTokError(answer.code, answer.message, answer.request_id);
}
}
}
const tt = new TikTok(process.env.TIKTOK_ACCESS_TOKEN, process.env.TIKTOK_BUSINESS_ID);Wie veröffentlichen Sie ein Video per URL und prüfen den Status?
POST /business/video/publish/ mit video_url und post_info, dann Abfrage von /business/publish/status/ mit der share_id als publish_id. Die Abfrageschleife endet bei FAILED mit dem Grund von TikTok; bei PUBLISH_COMPLETE wartet sie weiter, bis post_ids erscheint, was laut TikTok bis zu drei weitere Minuten dauern kann. Die video_url muss auf einer für Ihre App verifizierten Domain oder einem URL-Präfix liegen:
# Python
def wait_until_live(tt, share_id, interval=30, give_up_after=7200):
deadline = time.time() + give_up_after
while time.time() < deadline:
status = tt.call("GET", "business/publish/status/", params={"publish_id": share_id})
if status["status"] == "FAILED":
raise RuntimeError(f"TikTok did not publish {share_id}: {status.get('reason')}")
if status["status"] == "PUBLISH_COMPLETE" and status.get("post_ids"):
return status["post_ids"]
time.sleep(interval) # post_ids can follow PUBLISH_COMPLETE by up to three minutes
raise TimeoutError(f"{share_id} was not public after {give_up_after} s")
video = tt.call("POST", "business/video/publish/", body={
"video_url": "https://media.example.com/tiktok/launch.mp4", # on a verified domain or URL prefix
"post_info": {
"caption": "Our spring menu is live #food",
"is_brand_organic": True, # the Promotional content label, for the account's own business
"is_branded_content": False,
},
})
print("Live:", wait_until_live(tt, video["share_id"]))
// Node.js
async function waitUntilLive(tt, shareId, everyMs = 30000, giveUpAfterMs = 7200000) {
const deadline = Date.now() + giveUpAfterMs;
while (Date.now() < deadline) {
const s = await tt.call("GET", "business/publish/status/", { params: { publish_id: shareId } });
if (s.status === "FAILED") throw new Error("TikTok did not publish " + shareId + ": " + s.reason);
if (s.status === "PUBLISH_COMPLETE" && s.post_ids && s.post_ids.length) return s.post_ids;
await sleep(everyMs); // post_ids can follow PUBLISH_COMPLETE by up to three minutes
}
throw new Error(shareId + " was not public after " + giveUpAfterMs / 1000 + " s");
}
async function publishVideo(tt) {
const video = await tt.call("POST", "business/video/publish/", {
body: {
video_url: "https://media.example.com/tiktok/launch.mp4", // on a verified domain or URL prefix
post_info: { caption: "Our spring menu is live #food", is_brand_organic: true, is_branded_content: false },
},
});
return waitUntilLive(tt, video.share_id);
}
publishVideo(tt).then((postIds) => console.log("Live:", postIds), console.error);Wie veröffentlichen Sie Fotos?
Lesen Sie zuerst die erlaubten Einstellungen des Kontos aus und senden Sie dann POST /business/photo/publish/. Ein Fotobeitrag braucht privacy_level, das eine der privacy_level_options aus /business/video/settings/ sein muss; ist dort comment_disabled auf true gesetzt, muss auch disable_comment auf true stehen. Die zurückgegebene share_id wird mit derselben Wartefunktion wie bei einem Video verfolgt:
# Python
def publish_photos(tt, image_urls, title, caption):
settings = tt.call("GET", "business/video/settings/")
if "PUBLIC_TO_EVERYONE" not in settings["privacy_level_options"]:
raise RuntimeError(f"Private account, choose from {settings['privacy_level_options']}")
photo = tt.call("POST", "business/photo/publish/", body={
"photo_images": image_urls, # 1 to 35 JPG, JPEG or WebP links on a verified domain or prefix
"photo_cover_index": 0,
"post_info": {
"title": title, # up to 90 UTF-16 code units
"caption": caption, # up to 4,000
"privacy_level": "PUBLIC_TO_EVERYONE",
"disable_comment": settings["comment_disabled"], # True when the account takes no comments
"is_brand_organic": True,
"is_branded_content": False,
},
})
return wait_until_live(tt, photo["share_id"])
print(publish_photos(tt, ["https://media.example.com/menu/1.jpg", "https://media.example.com/menu/2.jpg"],
"Spring menu", "Four new dishes, from Friday #food"))
// Node.js
async function publishPhotos(tt, imageUrls, title, caption) {
const settings = await tt.call("GET", "business/video/settings/");
if (!settings.privacy_level_options.includes("PUBLIC_TO_EVERYONE")) {
throw new Error("Private account, choose from " + settings.privacy_level_options.join(", "));
}
const photo = await tt.call("POST", "business/photo/publish/", {
body: {
photo_images: imageUrls, // 1 to 35 JPG, JPEG or WebP links on a verified domain or prefix
photo_cover_index: 0,
post_info: {
title, // up to 90 UTF-16 code units
caption, // up to 4,000
privacy_level: "PUBLIC_TO_EVERYONE",
disable_comment: settings.comment_disabled, // true when the account takes no comments
is_brand_organic: true,
is_branded_content: false,
},
},
});
return waitUntilLive(tt, photo.share_id);
}
publishPhotos(tt, ["https://media.example.com/menu/1.jpg", "https://media.example.com/menu/2.jpg"],
"Spring menu", "Four new dishes, from Friday #food").then(console.log, console.error);Wie listen Sie die Videos eines Kontos auf?
GET /business/video/list/ mit den gewünschten Feldern, darunter item_id, bis zu 20 Beiträge pro Seite, die neuesten zuerst. Übergeben Sie den zurückgegebenen cursor, einen UTC-Zeitstempel in Millisekunden, solange has_more auf true steht, und rechnen Sie mit kurzen Seiten: Die Regeln für Vertrauen und Sicherheit von TikTok können weniger als max_count liefern, bevor die Liste endet.
# Python
def recent_videos(tt, how_many=60):
params = {"fields": ["item_id", "create_time", "caption", "share_url", "video_views", "likes", "comments"],
"max_count": 20}
videos = []
while len(videos) < how_many:
page = tt.call("GET", "business/video/list/", params=params)
videos += page.get("videos", [])
if not page.get("has_more"):
break
params["cursor"] = page["cursor"] # posts published before this UTC time, in milliseconds
return videos[:how_many]
for v in recent_videos(tt):
print(v["item_id"], v.get("video_views"), (v.get("caption") or "")[:60])
// Node.js
async function recentVideos(tt, howMany = 60) {
const params = {
fields: ["item_id", "create_time", "caption", "share_url", "video_views", "likes", "comments"],
max_count: 20,
};
const videos = [];
while (videos.length < howMany) {
const page = await tt.call("GET", "business/video/list/", { params });
videos.push(...(page.videos ?? []));
if (!page.has_more) break;
params.cursor = page.cursor; // posts published before this UTC time, in milliseconds
}
return videos.slice(0, howMany);
}
recentVideos(tt).then((videos) => {
for (const v of videos) console.log(v.item_id, v.video_views, (v.caption || "").slice(0, 60));
}, console.error);Wie lesen Sie Kommentare und antworten darauf?
GET /business/comment/list/ mit der item_id des Beitrags als video_id liefert bis zu 30 Kommentare pro Seite, und POST /business/comment/reply/create/ antwortet einem Kommentar öffentlich mit bis zu 1,200 Zeichen Text. Das Beispiel antwortet auf öffentliche Kommentare der obersten Ebene, die noch keine Antworten haben, überspringt die eigenen des Kontos und überlässt den Wortlaut einer Funktion, die Sie schreiben; denn TikTok kann ähnlich lautende Kommentare, die kurz hintereinander gepostet werden, als Spam ausblenden:
# Python
def reply_to_new_comments(tt, video_id, write_reply):
page = tt.call("GET", "business/comment/list/", params={
"video_id": video_id, # the post's item_id
"status": "PUBLIC",
"sort_field": "create_time",
"sort_order": "desc",
"max_count": 30,
})
for comment in page.get("comments", []):
if comment.get("owner") or comment.get("replies") or comment.get("parent_comment_id"):
continue # the account's own comments, threads with replies, and replies
text = write_reply(comment)
if text:
tt.call("POST", "business/comment/reply/create/", body={
"video_id": video_id, "comment_id": comment["comment_id"], "text": text, # up to 1,200 characters
})
def reply_for(comment):
if "price" in (comment.get("text") or "").lower():
return f"Hi {comment.get('display_name') or 'there'}, the price list is pinned on our profile."
return None # leave the rest to a person
reply_to_new_comments(tt, "<ITEM_ID>", reply_for)
// Node.js
async function replyToNewComments(tt, videoId, writeReply) {
const page = await tt.call("GET", "business/comment/list/", {
params: { video_id: videoId, status: "PUBLIC", sort_field: "create_time", sort_order: "desc", max_count: 30 },
});
for (const comment of page.comments ?? []) {
if (comment.owner || comment.replies || comment.parent_comment_id) continue; // own, already replied to, or a reply
const text = writeReply(comment);
if (text) {
await tt.call("POST", "business/comment/reply/create/", {
body: { video_id: videoId, comment_id: comment.comment_id, text }, // up to 1,200 characters
});
}
}
}
function replyFor(comment) {
if ((comment.text || "").toLowerCase().includes("price")) {
return "Hi " + (comment.display_name || "there") + ", the price list is pinned on our profile.";
}
return null; // leave the rest to a person
}
replyToNewComments(tt, "<ITEM_ID>", replyFor).catch(console.error);Wie lesen Sie die Insights eines Kontos?
GET /business/get/ mit den Feldnamen in fields und einem UTC-Datumsbereich von bis zu 60 Tagen. followers_count erscheint zweimal: als aktueller Gesamtwert oben in data und als Gesamtwert jedes Tages innerhalb von metrics, neben video_views, profile_views, likes, comments und shares des jeweiligen Tages. Das Beispiel endet gestern, weil die Tageswerte 24 bis 48 Stunden verzögert eintreffen:
# Python
from datetime import datetime, timedelta, timezone
def daily_insights(tt, days=7):
yesterday = datetime.now(timezone.utc).date() - timedelta(days=1) # counts arrive 24 to 48 h late
data = tt.call("GET", "business/get/", params={
"fields": ["followers_count", "video_views", "profile_views", "likes", "comments", "shares"],
"start_date": (yesterday - timedelta(days=days - 1)).isoformat(), # UTC, up to 60 days back
"end_date": yesterday.isoformat(),
})
print("Followers now:", data.get("followers_count"))
for day in data.get("metrics", []):
print(day["date"], day.get("followers_count"), day.get("video_views"), day.get("likes"))
daily_insights(tt)
// Node.js
async function dailyInsights(tt, days = 7) {
const utcDay = (daysAgo) => new Date(Date.now() - daysAgo * 86400000).toISOString().slice(0, 10);
const data = await tt.call("GET", "business/get/", {
params: {
fields: ["followers_count", "video_views", "profile_views", "likes", "comments", "shares"],
start_date: utcDay(days), // UTC, up to 60 days back
end_date: utcDay(1), // counts arrive 24 to 48 h late
},
});
console.log("Followers now:", data.followers_count);
for (const day of data.metrics ?? []) console.log(day.date, day.followers_count, day.video_views, day.likes);
}
dailyInsights(tt).catch(console.error);Wie prüfen Sie eine Webhook-Signatur?
Berechnen Sie einen HMAC-SHA256 aus dem Wert t, einem Punkt und dem rohen Body, mit dem App-Secret als Schlüssel; vergleichen Sie ihn zeitkonstant mit s und prüfen Sie, dass t aktuell ist. Lesen Sie den Body als Bytes, bevor ihn etwas parst, antworten Sie sofort mit 200 und protokollieren Sie x-tt-logid, wenn eine Prüfung fehlschlägt. Flask für Python und das eingebaute Modul http für Node.js:
# Python
import hashlib
import hmac
import json
import os
import time
from queue import Queue
from flask import Flask, request
app = Flask(__name__)
events = Queue()
def signature_ok(raw, header, secret, max_age=300):
fields = {}
for part in (header or "").split(","):
key, sep, value = part.strip().partition("=")
if sep:
fields[key] = value
t, s = fields.get("t", ""), fields.get("s", "").lower()
if not t.isdigit() or len(s) != 64:
return False
expected = hmac.new(secret.encode(), t.encode() + b"." + raw, hashlib.sha256).hexdigest()
return hmac.compare_digest(expected, s) and abs(time.time() - int(t)) <= max_age
@app.post("/tiktok/webhook")
def tiktok_webhook():
raw = request.get_data() # the bytes TikTok signed, before any JSON parsing
if not signature_ok(raw, request.headers.get("Tiktok-Signature"), os.environ["TIKTOK_APP_SECRET"]):
app.logger.warning("Bad signature, x-tt-logid %s", request.headers.get("X-Tt-Logid"))
return "", 401
events.put(json.loads(raw)) # its content field is itself a JSON string: work on it elsewhere
return "", 200
// Node.js
const { createServer } = require("node:http");
const { createHmac, timingSafeEqual } = require("node:crypto");
function signatureOk(raw, header, secret, maxAgeSec = 300) {
const fields = {};
for (const part of String(header ?? "").split(",")) {
const i = part.indexOf("=");
if (i > 0) fields[part.slice(0, i).trim()] = part.slice(i + 1).trim();
}
if (!/^\d+$/.test(fields.t ?? "") || !/^[0-9a-f]{64}$/i.test(fields.s ?? "")) return false;
const expected = createHmac("sha256", secret).update(fields.t + ".").update(raw).digest();
const fresh = Math.abs(Date.now() / 1000 - Number(fields.t)) <= maxAgeSec;
return timingSafeEqual(expected, Buffer.from(fields.s, "hex")) && fresh;
}
const inbox = [];
createServer((req, res) => {
if (req.method !== "POST" || req.url !== "/tiktok/webhook") return res.writeHead(404).end();
const chunks = [];
req.on("data", (chunk) => chunks.push(chunk));
req.on("end", () => {
const raw = Buffer.concat(chunks); // the bytes TikTok signed
if (!signatureOk(raw, req.headers["tiktok-signature"], process.env.TIKTOK_APP_SECRET)) {
console.warn("Bad signature, x-tt-logid", req.headers["x-tt-logid"]);
return res.writeHead(401).end();
}
res.writeHead(200).end(); // answer first: TikTok retries anything but a 200 for up to 72 hours
inbox.push(JSON.parse(raw.toString("utf8")));
});
}).listen(3000);Wie führen Sie dieselben Aufgaben über easyCoexistence aus?
Als Tool-Aufrufe von Claude, ChatGPT oder einem anderen MCP-Client, der mit https://easycoexistence.com/api/mcp verbunden ist; jeder nimmt die account_id aus list_social_accounts. easyCoexistence sendet Ihre Medienlinks über das eigene verifizierte URL-Präfix an TikTok, verfolgt jeden Beitrag, bis TikTok ihn abschließt oder ablehnt, und erneuert das Token. Ein abgelehnter Aufruf kommt mit dem Fehlercode und der Meldung von TikTok zurück:
// Publish a video by URL, then see where it stands
publish_tiktok_post { "account_id": "<ACCOUNT_ID>", "video_url": "https://media.example.com/tiktok/launch.mp4", "caption": "Our spring menu is live #food" }
get_tiktok_publish_status { "account_id": "<ACCOUNT_ID>", "share_id": "<SHARE_ID>" }
// Post photos
publish_tiktok_post { "account_id": "<ACCOUNT_ID>", "image_urls": ["https://media.example.com/menu/1.jpg", "https://media.example.com/menu/2.jpg"], "title": "Spring menu", "caption": "Four new dishes, from Friday #food" }
// List videos
list_social_posts { "account_id": "<ACCOUNT_ID>", "limit": 20 }
// Read comments and reply in public
list_social_comments { "account_id": "<ACCOUNT_ID>", "post_id": "<ITEM_ID>" }
reply_to_comment { "account_id": "<ACCOUNT_ID>", "post_id": "<ITEM_ID>", "comment_id": "<COMMENT_ID>", "text": "The price list is pinned on our profile." }
// Account insights
get_social_insights { "account_id": "<ACCOUNT_ID>", "metrics": ["followers_count", "video_views", "likes"], "params": { "start_date": "2026-10-26", "end_date": "2026-11-01" } }
// Comment events, signed by easyCoexistence, at your endpoint
set_social_webhook_destination { "account_id": "<ACCOUNT_ID>", "url": "https://hooks.example.com/tiktok/" }Wie nutzt Ihr eigener Code ein mit easyCoexistence verbundenes Konto?
Holen Sie die Zugangsdaten des Kontos für jede Aufgabe über die Partner API und übergeben Sie sie an denselben Client. GET /channels/{id}?credentials=1 mit Ihrem ec_live_-Schlüssel liefert api_base, business_id und ein aktuelles access_token mit token_expires_at, oder ein null-Token mit einem Hinweis, wenn der Kanal neu verbunden werden muss. Abrufe, Antworten und Insights laufen dann aus Ihrem eigenen Code, während Beiträge über POST /channels/{id}/posts oder publish_tiktok_post laufen, die Medien über das verifizierte Präfix leiten:
# Python
def tiktok_for(channel_id):
res = requests.get(f"https://easycoexistence.com/api/v1/channels/{channel_id}", params={"credentials": "1"},
headers={"Authorization": f"Bearer {os.environ['EC_API_KEY']}"}, timeout=30)
res.raise_for_status()
creds = res.json()["credentials"]
if not creds.get("access_token"):
raise RuntimeError(creds.get("note")) # the channel needs reconnecting
return TikTok(creds["access_token"], creds["business_id"])
print(recent_videos(tiktok_for("<CHANNEL_ID>"), 20))
// Node.js
async function tiktokFor(channelId) {
const res = await fetch("https://easycoexistence.com/api/v1/channels/" + channelId + "?credentials=1", {
headers: { Authorization: "Bearer " + process.env.EC_API_KEY },
});
if (!res.ok) throw new Error("HTTP " + res.status + " from easyCoexistence");
const { credentials } = await res.json();
if (!credentials.access_token) throw new Error(credentials.note); // the channel needs reconnecting
return new TikTok(credentials.access_token, credentials.business_id);
}
tiktokFor("<CHANNEL_ID>").then((account) => recentVideos(account, 20)).then(console.log, console.error);Häufige Fehler
- Daten lesen, ohne code zu prüfen. Eine Antwort kann HTTP 200, den code 40002 und überhaupt keine data tragen, sodass ein fehlendes Feld oft ein Fehler ist, den der Code übergangen hat.
- Den abschließenden Schrägstrich weglassen. Die Pfade von TikTok enden auf /, und der Anhang zu den Rückgabecodes nennt /tt_user/oauth2/refresh_token ohne Schrägstrich als Aufruf, der mit HTTP 404 page not found endet.
- Antwort-IDs aus reply_list in Node.js übernehmen. TikTok typisiert comment_id und video_id in reply_list als Zahlen, die JSON.parse runden kann; /business/comment/reply/list/ liefert sie als Strings zurück.
- Fields als kommagetrennte Liste senden. Die API for Business erwartet JSON-Text, fields=["item_id","caption"], anders als die Display API auf developers.tiktok.com, die fields=open_id,union_id akzeptiert.
US$ 9 bis US$ 0.75 pro Verbindung und Monat, sinkend mit jeder weiteren Verbindung, mit einer kostenlosen Testphase von 3 Tagen.
Häufig gestellte Fragen
Gibt es ein offizielles Python- oder Node.js-SDK für die Accounts API von TikTok?
Das SDK der TikTok API for Business gibt es in Python, JavaScript und Java, doch dessen Endpoint-Liste umfasst Werbung, Reporting und das Business Center, ohne Endpoint unter /business/ oder /tt_user/.
Warum liefert ein TikTok-Aufruf HTTP 200 ohne Daten zurück?
TikTok meldet Fehler im Feld code einer HTTP-200-Antwort. Lesen Sie code und die Meldung: 40002 ist ein Parameterfehler, 40001 eine fehlende Berechtigung und 40100 ein gedrosselter Aufruf.
Welche Python- und Node.js-Versionen brauchen diese Beispiele?
Python 3.9 oder neuer mit requests sowie Flask für den Webhook und Node.js 18 oder neuer, dessen eingebautes fetch und node:crypto den Rest abdecken.
Kann ich die TikTok API aus dem Browser aufrufen?
Halten Sie die Aufrufe auf Ihrem Server. Der Token-Typ von TikTok ist Bearer, also nutzbar für jeden, der ihn besitzt, und die Token-Endpoints brauchen das client_secret Ihrer App.
Weiterlesen
Verbinden Sie Ihren ersten Kanal in zwei Minuten.
Keine Plattform-Prüfungen, auf die Sie warten müssen. Verbinden Sie WhatsApp, Instagram, TikTok oder einen anderen Kanal, bitten Sie dann Ihre KI, zu posten, zu antworten oder Berichte zu erstellen, und sehen Sie ihr bei der Arbeit zu.
- 3 Tage kostenlos
- Jederzeit kündbar
- Nur offizielle APIs
- Überwacht rund um die Uhr (24/7)
Verifiziert am