InloggenGratis proefperiode starten
easyCoexistence Officiële API's

TikTok API in Python en Node.js: werkende voorbeelden

De API for Business van TikTok werkt vanuit Python of Node.js met gewone HTTPS-verzoeken: stuur elke aanroep naar https://business-api.tiktok.com/open_api/v1.3 met het token van het account in de Access-Token-header en zijn open_id als business_id. TikTok antwoordt op de meeste aanroepen met HTTP 200 en een code-veld, 0 bij succes. Controleer dat veld en pauzeer 5 minuten bij 40100.

easyCoexistence geeft Claude, ChatGPT of je eigen code dezelfde TikTok-taken als tools, van publish_tiktok_post en reply_to_comment tot get_social_insights, en levert je scripts een actueel token via get_social_credentials of de Partner API.

HTTP 200

Status van de meeste TikTok-antwoorden, ook bij fouten; alleen een code van 0 in de body betekent dat de aanroep is gelukt.

40100

Foutcode voor een afgeremde aanroep: TikTok vraagt om een pauze van 5 minuten na een limiet per minuut, en tot 00:00 UTC na een dagelijkse limiet.

5xx

Serverfouten, waarna TikTok voorstelt ongeveer 5 minuten te wachten voordat je opnieuw aanroept.

Final /

Paden eindigen op een schuine streep; TikTok noemt /tt_user/oauth2/refresh_token zonder die streep als oorzaak van 404 page not found.

3 languages

Python, JavaScript en Java in de SDK van TikTok voor de API for Business, waarvan de lijst met endpoints geen /business/-endpoint bevat.

HMAC-SHA256

Handtekening in de Tiktok-Signature-header van elke webhook, over de tijdstempel, een punt en de body, met als sleutel het app-geheim.

Wat heeft elke TikTok API-aanroep nodig?

Dezelfde vijf dingen, wat de taak ook is:

  • De basis-URL https://business-api.tiktok.com/open_api/v1.3, met een pad dat eindigt op een schuine streep, zoals /business/video/list/.
  • Het toegangstoken van het account in een Access-Token-header, vernieuwd voordat de 24 uur verstreken zijn.
  • business_id, de open_id van het account: in de querystring bij GET, in de JSON-body bij POST.
  • Lijst- en objectparameters bij GET, zoals fields en filters, als JSON-tekst verstuurd: fields=["item_id","caption"].
  • Een controle van code in het antwoord, want TikTok stuurt fouten zoals 40002 of 40100 met HTTP 200 en data alleen bij code 0.

Hoe verwerk je de foutstructuur van TikTok in Python?

Met een kleine client die business_id plaatst waar elke methode die verwacht, data teruggeeft bij code 0 en anders een TikTokError gooit. Hij herhaalt een afgeremde aanroep na de pauze van 5 minuten van TikTok, omdat 40100 betekent dat TikTok de aanroep heeft geweigerd, en herhaalt een 5xx alleen bij GET, omdat een publicatie die op een serverfout eindigde toch bij TikTok kan zijn aangekomen. Hij heeft requests nodig, en de latere Python-voorbeelden gebruiken hem opnieuw:

Python: a TikTok client that reads the envelope
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"])

Hoe doe je dat in Node.js?

Dezelfde client op de fetch die ingebouwd is in Node.js 18 en nieuwer, zonder iets te installeren. Hij codeert lijstparameters als JSON bij GET, zet business_id in de body bij POST en bewaart de code van TikTok bij de fout, zodat aanroepers 40102 of 40105, een tokenprobleem, kunnen onderscheiden van 40001, een ontbrekende machtiging:

Node.js: the same client on the built-in fetch
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);

Hoe publiceer je een video via URL en controleer je de status?

POST /business/video/publish/ met video_url en post_info, daarna de status opvragen op /business/publish/status/ met de share_id als publish_id. De lus stopt bij FAILED met de reden van TikTok, en bij PUBLISH_COMPLETE blijft hij wachten tot post_ids verschijnt, wat volgens TikTok nog tot drie minuten kan duren. De video_url moet op een domein of URL-prefix staan dat voor jouw app is geverifieerd:

Publish a video and wait until it is public: Python, then Node.js
# 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);

Hoe plaats je foto's?

Lees eerst de toegestane instellingen van het account, daarna POST /business/photo/publish/. Een fotopost vereist privacy_level, dat een van de privacy_level_options uit /business/video/settings/ moet zijn, en als comment_disabled daar true is, moet disable_comment ook true zijn. De teruggegeven share_id wordt gevolgd met dezelfde wachtfunctie als bij een video:

Publish a photo post: Python, then Node.js
# 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);

Hoe lijst je de video's van een account?

GET /business/video/list/ met de velden die je wilt, waaronder item_id, tot 20 posts per pagina vanaf de nieuwste. Geef de teruggegeven cursor door, een UTC-tijdstempel in milliseconden, zolang has_more true is, en reken op korte pagina's: de regels van TikTok voor vertrouwen en veiligheid kunnen minder dan max_count teruggeven voordat de lijst eindigt.

List recent videos across pages: Python, then Node.js
# 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);

Hoe lees je reacties en beantwoord je ze?

GET /business/comment/list/ met het item_id van de post als video_id geeft tot 30 reacties per pagina, en POST /business/comment/reply/create/ beantwoordt er één openbaar met tot 1.200 tekens tekst. Het voorbeeld reageert op openbare reacties op het hoogste niveau die nog geen antwoorden hebben, slaat de reacties van het account zelf over, en laat de formulering over aan een functie die jij schrijft, want TikTok kan sterk op elkaar lijkende reacties die dicht na elkaar zijn geplaatst als spam verbergen:

Reply to new comments on a video: Python, then Node.js
# 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);

Hoe lees je de inzichten van een account?

GET /business/get/ met de veldnamen in fields en een UTC-datumbereik van maximaal 60 dagen. followers_count komt er twee keer in: het huidige totaal bovenaan data, en het totaal per dag binnen metrics, naast de video_views, profile_views, likes, comments en shares van die dag. Het voorbeeld eindigt op gisteren, omdat dagtellingen 24 tot 48 uur te laat binnenkomen:

Daily account metrics for the last 7 days: Python, then Node.js
# 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);

Hoe verifieer je een webhook-handtekening?

Bereken opnieuw een HMAC-SHA256 van de waarde t, een punt en de ruwe body, met als sleutel het app-geheim, vergelijk die in constante tijd met s en controleer of t recent is. Lees de body als bytes voordat iets hem parseert, antwoord direct met 200 en log x-tt-logid wanneer een controle mislukt. Flask voor Python, en de ingebouwde http-module voor Node.js:

Receive a signed TikTok webhook: Python with Flask, then 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);

Hoe draai je dezelfde taken via easyCoexistence?

Als toolaanroepen vanuit Claude, ChatGPT of een andere MCP-client die is verbonden met https://easycoexistence.com/api/mcp, waarbij elke aanroep het account_id uit list_social_accounts neemt. easyCoexistence stuurt je medialinks via de eigen geverifieerde URL-prefix naar TikTok, volgt elke post tot TikTok hem voltooit of laat mislukken, en vernieuwt het token, terwijl een geweigerde aanroep terugkomt met de code en het bericht van TikTok:

The six jobs as MCP tool calls
// 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/" }

Hoe gebruikt je eigen code een account dat met easyCoexistence is verbonden?

Haal per taak de inloggegevens van het account op via de Partner API en geef ze door aan dezelfde client. GET /channels/{id}?credentials=1 met je ec_live_-sleutel geeft api_base, business_id en een actueel access_token met token_expires_at terug, of een null-token met een opmerking wanneer het kanaal opnieuw verbonden moet worden. Lezen, antwoorden en inzichten draaien dan vanuit je eigen code, terwijl posts gaan via POST /channels/{id}/posts of publish_tiktok_post, die mediabestanden via de geverifieerde prefix routeren:

A current token from the Partner API, into the same client: Python, then Node.js
# 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);

Veelgemaakte fouten

  • Gegevens lezen zonder de code te controleren. Een antwoord kan HTTP 200, code 40002 en helemaal geen data bevatten, dus een ontbrekend veld is vaak een fout die de code oversloeg.
  • De slotschuine weglaten. De paden van TikTok eindigen op /, en de bijlage met retourcodes geeft /tt_user/oauth2/refresh_token, zonder de schuine streep, als aanroep die eindigt op HTTP 404 page not found.
  • Reactie-ID's halen uit reply_list in Node.js. De referentie van TikTok typeert comment_id en video_id in reply_list als getallen, die JSON.parse kan afronden; /business/comment/reply/list/ geeft ze als tekst terug.
  • Velden als kommalijst versturen. De API for Business wil JSON-tekst, fields=["item_id","caption"], anders dan de Display API op developers.tiktok.com, die fields=open_id,union_id accepteert.
Dit doen met EasyCoexistence

US$ 9 tot US$ 0,75 per verbinding per maand, dalend naarmate je meer verbindingen toevoegt, met een gratis proefperiode van 3 dagen.

Veelgestelde vragen

Heeft TikTok een officiële Python- of Node.js-SDK voor de Accounts API?

De SDK van TikTok voor de API for Business bestaat in Python, JavaScript en Java, maar de lijst met endpoints dekt advertenties, rapportages en Business Center, zonder /business/- of /tt_user/-endpoint.

Waarom geeft een TikTok-aanroep HTTP 200 zonder data terug?

TikTok meldt fouten in het code-veld van een HTTP 200-antwoord. Lees code en bericht: 40002 is een parameterfout, 40001 een ontbrekende machtiging en 40100 een afgeremde aanroep.

Welke Python- en Node.js-versies hebben deze voorbeelden nodig?

Python 3.9 of later met requests, plus Flask voor de webhook, en Node.js 18 of later, waarvan de ingebouwde fetch en node:crypto de rest dekken.

Kan ik de TikTok API vanuit de browser aanroepen?

Houd de aanroepen op je server. Het tokentype van TikTok is Bearer, bruikbaar door iedereen die het bezit, en de tokenendpoints hebben de client_secret van je app nodig.

Lees verder

Koppel je eerste kanaal in twee minuten.

Geen platformbeoordelingen om op te wachten. Verbind WhatsApp, Instagram, TikTok of een ander kanaal, vraag je AI om te posten, te reageren of een rapport te maken, en zie het aan het werk.

  • 3 dagen gratis
  • Op elk moment opzegbaar
  • Alleen officiële API's
  • 24/7 bewaakt

Geverifieerd op