התחברותהתחילו תקופת ניסיון
easyCoexistence ממשקי API רשמיים

TikTok API ב-Python וב-Node.js: דוגמאות עבודה

ה-API של TikTok for Business עובד מ-Python או מ-Node.js עם בקשות HTTPS רגילות: כל קריאה נשלחת לכתובת https://business-api.tiktok.com/open_api/v1.3, עם אסימון הגישה של החשבון בכותרת Access-Token ועם open_id שלו כ-business_id. TikTok עונה לרוב הקריאות ב-HTTP 200 ושדה code, שערכו 0 בהצלחה, לכן בודקים אותו, ואם הקוד הוא 40100 ממתינים 5 דקות.

easyCoexistence נותן ל-Claude, ל-ChatGPT או לקוד שלכם את אותן משימות TikTok ככלים, מהכלי publish_tiktok_post ועד הכלי get_social_insights, ומעביר לסקריפטים שלכם אסימון עדכני דרך get_social_credentials או Partner API.

HTTP 200

הסטטוס של רוב התשובות של TikTok, כולל שגיאות. רק קוד 0 בגוף התשובה אומר שהקריאה הצליחה.

40100

קוד לקריאה שהוגבלה: TikTok מבקש הפסקה של 5 דקות אחרי מגבלה לדקה, ועד 00:00 UTC אחרי מגבלה יומית.

5xx

שגיאות שרת, שאחריהן TikTok ממליץ לחכות כ-5 דקות לפני קריאה נוספת.

Final /

נתיבים מסתיימים בסלאש. TikTok מציין שהנתיב /tt_user/oauth2/refresh_token בלי סלאש גורם לשגיאת 404 (הדף לא נמצא).

3 languages

ה-SDK של TikTok ל-API for Business זמין ב-Python, JavaScript ו-Java, אך רשימת נקודות הקצה שלו אינה כוללת את הנתיב /business/ בכלל.

HMAC-SHA256

החתימה נמצאת בכותרת Tiktok-Signature של כל וובהוק, מחושבת על חותמת הזמן, נקודה והגוף, ומוצפנת במפתח הסוד של האפליקציה.

מה צריכה כל קריאה ל-API של TikTok?

אותם חמישה דברים, לא משנה המשימה:

  • כתובת הבסיס https://business-api.tiktok.com/open_api/v1.3, ואחריה נתיב שמסתיים בסלאש, כגון /business/video/list/
  • אסימון הגישה של החשבון בכותרת Access-Token, שמתחדש לפני שיעברו 24 השעות שלו
  • business_id, כלומר open_id של החשבון: במחרוזת השאילתה בבקשות GET ובגוף הבקשה בבקשות POST
  • רשימות ופרמטרים של אובייקטים ב-GET, כמו fields ו-filters, נשלחים כטקסט JSON, למשל fields=["item_id","caption"]
  • בדיקה של השדה code בתשובה, כי TikTok שולח שגיאות כמו 40002 או 40100 עם HTTP 200, ונותן data רק כש-code שווה ל-0 בלבד

איך מטפלים בעטיפת השגיאות של TikTok ב-Python?

עם לקוח קטן ששם את business_id במקום שכל שיטה מצפה לו, מחזיר data כש-code הוא 0 ומעלה TikTokError אחרת. הוא חוזר על קריאה שהוגבלה אחרי ההפסקה של 5 הדקות של TikTok, כי 40100 אומר ש-TikTok סירב לקריאה, וחוזר על 5xx רק ב-GET, כי פרסום שהסתיים בשגיאת שרת עלול בכל זאת להגיע ל-TikTok. הוא צריך את requests, והדוגמאות המאוחרות ב-Python משתמשות בו שוב:

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"])

איך מטפלים בזה ב-Node.js?

אותו לקוח, על fetch המובנה ב-Node.js 18 ומעלה, בלי שום דבר להתקין. הוא מקודד פרמטרים של רשימה כ-JSON ב-GET, שם את business_id בגוף בקשות POST, ושומר את ה-code של TikTok בשגיאה, כך שהקוראים מבדילים בין 40102 או 40105, בעיית אסימון, לבין 40001, הרשאה חסרה:

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);

איך מפרסמים סרטון לפי כתובת ובודקים את הסטטוס שלו?

קריאת POST אל /business/video/publish/ עם video_url ו-post_info, ואז בדיקה חוזרת של /business/publish/status/ עם share_id כ-publish_id. הלולאה נעצרת ב-FAILED עם הסיבה של TikTok, וב-PUBLISH_COMPLETE ממשיכה לחכות עד שיגיע post_ids, מה ש-TikTok אומר שעשוי לקחת עד שלוש דקות נוספות. video_url חייב להיות בקידומת של כתובת ה-URL שאומתה לאפליקציה שלכם:

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);

איך מפרסמים תמונות?

קודם קוראים את ההגדרות המותרות לחשבון, ואז קריאת POST אל /business/photo/publish/. פוסט תמונה דורש privacy_level, שחייב להיות אחד מ-privacy_level_options מ-/business/video/settings/, וכש-comment_disabled הוא true שם, גם disable_comment חייב להיות true. ה-share_id שמתקבל נבדק עם אותה פונקציית המתנה כמו בסרטון:

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);

איך מציגים את הסרטונים של החשבון?

GET אל /business/video/list/ עם השדות שרוצים, item_id ביניהם, עד 20 פוסטים בעמוד מהחדש לישן. מעבירים את ה-cursor שמוחזר, חותמת זמן UTC באלפיות שנייה, כל עוד has_more הוא true, ומצפים לעמודים קצרים: כללי הבטיחות והאמון של TikTok יכולים להחזיר פחות מ-max_count לפני שהרשימה נגמרת.

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);

איך קוראים תגובות ומשיבים להן?

GET אל /business/comment/list/ עם item_id של הפוסט כ-video_id מחזיר עד 30 תגובות בעמוד, וקריאת POST אל /business/comment/reply/create/ משיבה לאחת מהן בפומבי עם עד 1,200 תווים של טקסט. הדוגמה משיבה לתגובות פומביות ברמה העליונה שאין להן עדיין תשובות, מדלגת על התגובות של החשבון עצמו, ומשאירה את הניסוח לפונקציה שאתם כותבים, כי TikTok עשוי להסתיר תגובות דומות מאוד שנכתבו קרוב זו לזו כספאם:

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);

איך קוראים תובנות של החשבון?

GET אל /business/get/ עם שמות השדות ברשימה fields וטווח תאריכים UTC של עד 60 ימים. followers_count מופיע פעמיים: הסה"כ הנוכחי בשדה data, והסה"כ של כל יום בתוך metrics, לצד הנתונים של אותו יום: video_views, profile_views, likes, comments וגם shares. טווח הדוגמה מסתיים אתמול, כי ספירות יומיות מגיעות באיחור של 24 עד 48 שעות:

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);

איך מאמתים חתימת וובהוק?

מחשבים מחדש HMAC-SHA256 של הערך t, נקודה והגוף הגולמי, במפתח הסוד של האפליקציה, משווים אותו ל-s בזמן קבוע, ובודקים ש-t עדכני. קוראים את הגוף כבייטים לפני שמשהו מנתח אותו, עונים 200 מיד, ורושמים את x-tt-logid כשבדיקה נכשלת. עם Flask ב-Python, ועם המודול http המובנה ב-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);

איך מריצים את אותן משימות דרך easyCoexistence?

ככלי קריאה מ-Claude, מ-ChatGPT או מלקוח MCP אחר שמחובר לכתובת https://easycoexistence.com/api/mcp, כש-account_id נלקח מ-list_social_accounts בכל קריאה. easyCoexistence שולח את קישורי המדיה שלכם ל-TikTok דרך הקידומת המאומתת שלו, עוקב אחרי כל פוסט עד ש-TikTok משלים או נכשל, ומרענן את האסימון, ובקשה שנדחתה מוחזרת עם הקוד וההודעה של 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/" }

איך הקוד שלי משתמש בחשבון שמחובר ל-easyCoexistence?

שולפים את פרטי הגישה של החשבון לכל משימה מ-Partner API ומעבירים אותם לאותו לקוח. GET אל /channels/{id}?credentials=1 עם המפתח ec_live_ שלכם מחזיר api_base, business_id ו-access_token עדכני עם token_expires_at, או אסימון null עם הערה כשהערוץ צריך חיבור מחדש. קריאות, תגובות ותובנות רצות מהקוד שלכם, ואילו פרסומים עוברים דרך POST /channels/{id}/posts או publish_tiktok_post, שמנתבים את המדיה דרך הקידומת המאומתת:

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);

טעויות נפוצות

  • קריאת נתונים בלי לבדוק את השדה code: תשובה יכולה להגיע עם HTTP 200, קוד 40002 ואין בה נתונים בכלל, ולכן שדה חסר הוא לעתים שגיאה שהקוד דילג עליה.
  • השמטת הסלאש בסוף. הנתיבים של TikTok מסתיימים בסלאש, ונספח קודי ההחזרה שלו מציין את /tt_user/oauth2/refresh_token, בלי סלאש, כקריאה שמסתיימת בשגיאת 404 (הדף לא נמצא).
  • לקיחת מזהי תגובות מהשדה reply_list ב-Node.js: TikTok מגדיר את השדות comment_id וגם video_id של reply_list כמספרים, ו-JSON.parse עלול לעגל אותם, בעוד ש-/business/comment/reply/list/ מחזיר אותם כמחרוזות.
  • שליחת שדות כרשימה מופרדת בפסיקים: ה-API for Business דורש טקסט JSON, כמו fields=["item_id","caption"], בניגוד ל-Display API ב-developers.tiktok.com, שמקבל ערכים מופרדים בפסיקים, למשל fields=open_id,union_id
עושים את זה עם EasyCoexistence

מ-US$ 9 ועד US$ 0.75 לחיבור בחודש, שיורד ככל שמוסיפים חיבורים, עם תקופת ניסיון של 3 ימים.

שאלות נפוצות

האם ל-TikTok יש SDK רשמי ל-Python או ל-Node.js עבור Accounts API?

ה-SDK של TikTok ל-API for Business זמין ב-Python, JavaScript ו-Java, אבל רשימת נקודות הקצה שלו מכסה מודעות, דיווח ו-Business Center, ואין בה נתיב /business/ או /tt_user/ כלל.

למה קריאה ל-TikTok מחזירה HTTP 200 בלי נתונים?

TikTok מדווח על שגיאות בשדה code של תשובה עם HTTP 200. קראו את code ואת ההודעה: 40002 היא שגיאת פרמטר, 40001 הרשאה חסרה ו-40100 קריאה שהוגבלה.

באילו גרסאות Python ו-Node.js הדוגמאות צריכות לעבוד?

Python 3.9 ומעלה עם requests, ועוד Flask לוובהוק, ו-Node.js 18 ומעלה, שכוללים את fetch ואת node:crypto המובנים, וזה מספיק לשאר.

האם אפשר לקרוא ל-API של TikTok מהדפדפן?

השאירו את הקריאות בשרת שלכם. סוג האסימון של TikTok הוא Bearer, וכל מי שמחזיק בו יכול להשתמש בו, ונקודות הקצה של האסימונים דורשות את client_secret של האפליקציה.

המשיכו לקרוא

מדריך TikTok API ל-2026: מהאפליקציה שלכם ועד הפוסט הראשוןמסלול ה-TikTok API ב-2026 לפי הסדר: איזה API, בדיקת אפליקציה, הרשאות, אסימונים, פרסום, סטטוס, תגובות, וובהוקים, נתונים ומגבלות.שינויים ב-TikTok API ב-2026: מה הפסיק לעבוד ומה לעשותשינויים ב-TikTok API ב-2026, מהחדש לישן: משך אסימונים, is_business_account, מגבלות תגובה, טופס הגישה והסנדבוקס, עם התיקון לכל אחד.למה חיבור TikTok API מפסיק לעבוד, ואיך שומרים אותו פעיללמה חיבור TikTok API for Business נפסק: אסימון בן 24 שעות, אסימון רענון בן שנה, ביטול גישה, שינויי חשבון וחיבור מחדש.איך מעלים סרטון ל-TikTok דרך ה-APIפרסמו סרטון ב-TikTok עם ה-API לעסקים: נקודת הקצה לפרסום, גוף ה-JSON, המזהה share_id שמוחזר והקריאה לסטטוס, ב-curl וב-Python.אימות וובהוקים (Webhook) של TikTok: כותרת החתימה ואיך בודקים אותהאימות וובהוק של TikTok API for Business באמצעות כותרת Tiktok-Signature וחתימת ה-HMAC-SHA256, עם קוד Node.js מוכן.מגבלות קצב של TikTok API: קריאות לכל חשבון, אפליקציה ונקודת קצהמגבלות קצב של TikTok API: 40 קריאות לדקה לכל חשבון ולכל נקודת קצה, 600 או 1,000 לדקה לאפליקציה ב-Accounts API, וארבע רמות.

מחברים את הערוץ הראשון שלכם תוך שתי דקות.

בלי לחכות לאישורים של הפלטפורמות. מחברים את WhatsApp, Instagram, TikTok או ערוץ אחר, מבקשים מה-AI לפרסם, להשיב או להפיק דוח, ורואים אותו עובד.

  • 3 ימי ניסיון חינם
  • ביטול בכל עת
  • רק ממשקי API רשמיים
  • ניטור 24/7

נבדק ב-