Conectați-văÎncepeți perioada de probă gratuită
easyCoexistence API-uri oficiale

TikTok API în Python și Node.js: exemple funcționale

API-ul TikTok for Business funcționează din Python sau Node.js prin cereri HTTPS simple: fiecare apel se trimite la https://business-api.tiktok.com/open_api/v1.3, cu token-ul contului în antetul Access-Token și valoarea open_id a contului ca business_id. TikTok răspunde la majoritatea apelurilor cu HTTP 200 și un câmp code, 0 la succes, deci verificați-l și așteptați 5 minute la 40100.

easyCoexistence oferă lui Claude, ChatGPT sau propriului dumneavoastră cod aceleași sarcini TikTok ca unelte, de la publish_tiktok_post și reply_to_comment până la get_social_insights, și livrează scripturilor dumneavoastră un token curent prin get_social_credentials sau Partner API.

HTTP 200

Statusul majorității răspunsurilor TikTok, inclusiv al erorilor; doar un code de 0 în corp înseamnă că apelul a reușit.

40100

Codul pentru un apel limitat: TikTok cere o pauză de 5 minute după o limită pe minut și până la 00:00 UTC după una zilnică.

5xx

Erori de server, după care TikTok recomandă așteptarea a circa 5 minute înainte de un nou apel.

Final /

Căile se termină cu o bară oblică; TikTok indică /tt_user/oauth2/refresh_token fără ea drept cauză a erorii 404 page not found.

3 languages

Python, JavaScript și Java în SDK-ul TikTok API for Business, a cărui listă de endpoint-uri nu include niciun endpoint /business/.

HMAC-SHA256

Semnătura se află în antetul Tiktok-Signature al fiecărui webhook-ului, peste marcajul temporal, un punct și corpul cererii, cu secretul aplicației drept cheie.

Ce are nevoie fiecare apel către API-ul TikTok?

Aceleași cinci lucruri, indiferent de sarcină:

  • URL-ul de bază https://business-api.tiktok.com/open_api/v1.3, cu o cale care se termină cu o bară oblică, de exemplu /business/video/list/.
  • Token-ul de acces al contului, în antetul Access-Token, reînnoit înainte ca cele 24 de ore să expire.
  • business_id, adică valoarea open_id a contului: în șirul de interogare la GET, în corpul JSON la POST.
  • Parametrii de listă și de obiect la GET, de exemplu fields și filters, trimiși ca text JSON: fields=["item_id","caption"].
  • O verificare a câmpului code din răspuns, deoarece TikTok trimite erori precum 40002 sau 40100 cu HTTP 200 și date doar când code este 0.

Cum tratați structura de erori TikTok în Python?

Cu un client mic care pune business_id acolo unde îl cere fiecare metodă, returnează datele când code este 0 și ridică o excepție TikTokError în rest. Repetă un apel limitat după pauza de 5 minute a TikTok, deoarece 40100 înseamnă că TikTok a refuzat apelul, și repetă un 5xx doar la GET, pentru că o publicare încheiată cu eroare de server poate totuși să fi ajuns la TikTok. Are nevoie de requests, iar exemplele Python de mai jos îl reutilizează:

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

Cum tratați asta în Node.js?

Același client, pe fetch-ul integrat în Node.js 18 și versiunile ulterioare, fără nimic de instalat. Codifică parametrii de listă ca JSON la GET, pune business_id în corp la POST și păstrează codul TikTok în eroare, astfel încât apelanții pot deosebi 40102 sau 40105, probleme cu token-ul, de 40001, o permisiune lipsă:

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

Cum publicați un video după URL și verificați starea lui?

POST /business/video/publish/ cu video_url și post_info, apoi interogați /business/publish/status/ cu share_id ca publish_id. Bucla se oprește la FAILED, cu motivul dat de TikTok, iar la PUBLISH_COMPLETE continuă să aștepte până apare post_ids, ceea ce TikTok spune că poate dura până la trei minute în plus. video_url trebuie să se afle pe un domeniu sau pe un prefix de URL verificat pentru aplicația dumneavoastră:

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

Cum publicați fotografii?

Citiți mai întâi setările permise ale contului, apoi POST /business/photo/publish/. O postare foto necesită privacy_level, care trebuie să fie una dintre valorile din privacy_level_options de la /business/video/settings/, iar dacă comment_disabled este true acolo, disable_comment trebuie să fie și el true. share_id returnat se urmărește cu aceeași funcție de așteptare ca pentru un 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);

Cum listați videoclipurile unui cont?

GET /business/video/list/ cu câmpurile dorite, printre care item_id, până la 20 de postări pe pagină, de la cele mai noi. Transmiteți cursorul returnat, un marcaj temporal UTC în milisecunde, cât timp has_more este true, și așteptați-vă la pagini scurte: regulile de siguranță și încredere ale TikTok pot returna mai puține decât max_count înainte ca lista să se termine.

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

Cum citiți comentariile și le răspundeți?

GET /business/comment/list/ cu item_id-ul postării drept video_id returnează până la 30 de comentarii pe pagină, iar POST /business/comment/reply/create/ răspunde unuia public, cu cel mult 1.200 de caractere de text. Exemplul răspunde comentariilor publice de nivel superior care nu au încă răspunsuri, sare peste cele ale contului și lasă formularea unei funcții pe care o scrieți, deoarece TikTok poate ascunde ca spam comentariile aproape identice postate în apropiere:

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

Cum citiți statisticile contului?

GET /business/get/ cu numele câmpurilor în fields și un interval de date UTC de până la 60 de zile. followers_count apare de două ori: totalul curent în vârful lui data și totalul pentru fiecare zi din metrics, alături de video_views, profile_views, likes, comments și shares ale zilei respective. Exemplul se încheie ieri, deoarece cifrele zilnice sosesc cu 24 până la 48 de ore întârziere:

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

Cum verificați semnătura unui webhook?

Recalculați un HMAC-SHA256 al valorii t, un punct și corpul brut al cererii, cu secretul aplicației drept cheie, comparați cu s în timp constant și verificați că t este recent. Citiți corpul ca octeți înainte ca orice să îl parseze, răspundeți imediat cu 200 și înregistrați x-tt-logid când o verificare eșuează. Flask pentru Python și modulul http integrat pentru 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);

Cum rulați aceleași sarcini prin easyCoexistence?

Ca apeluri de unelte din Claude, ChatGPT sau alt client MCP conectat la https://easycoexistence.com/api/mcp, fiecare luând account_id din list_social_accounts. easyCoexistence trimite linkurile media către TikTok prin propriul prefix de URL verificat, urmărește fiecare postare până când TikTok o finalizează sau o respinge și reînnoiește token-ul, iar un apel refuzat revine cu codul și mesajul 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/" }

Cum folosește propriul cod un cont conectat la easyCoexistence?

Preluați acreditările contului pentru fiecare sarcină din Partner API și transmiteți-le aceluiași client. GET /channels/{id}?credentials=1 cu cheia dumneavoastră ec_live_ returnează api_base, business_id și un access_token curent cu token_expires_at, sau un token null cu o notă când canalul trebuie reconectat. Citirile, răspunsurile și statisticile rulează apoi din propriul cod, în timp ce postările trec prin POST /channels/{id}/posts sau publish_tiktok_post, care direcționează media prin prefixul verificat:

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

Greșeli frecvente

  • Citirea datelor fără verificarea code. Un răspuns poate avea HTTP 200, codul 40002 și deloc date, așa că un câmp lipsă este adesea o eroare pe care codul a ignorat-o.
  • Eliminarea barei finale. Căile TikTok se termină cu /, iar anexa sa cu codurile de returnare dă /tt_user/oauth2/refresh_token, fără bară, ca apel care se încheie cu HTTP 404 page not found.
  • Preluarea ID-urilor de răspuns din reply_list în Node.js. Documentația de referință TikTok tipizează comment_id și video_id din reply_list ca numere, pe care JSON.parse le poate rotunji; /business/comment/reply/list/ le returnează ca șiruri de caractere.
  • Trimiterea câmpurilor ca listă separată prin virgule. API for Business vrea text JSON, fields=["item_id","caption"], spre deosebire de Display API de pe developers.tiktok.com, care acceptă fields=open_id,union_id.
Faceți acest lucru cu EasyCoexistence

De la US$ 9 până la US$ 0,75 pe conexiune pe lună, pe măsură ce adăugați conexiuni, cu perioada de probă gratuită de 3 zile.

Întrebări frecvente

Are TikTok un SDK oficial Python sau Node.js pentru Accounts API?

SDK-ul TikTok API for Business există în Python, JavaScript și Java, dar lista sa de endpoint-uri acoperă reclame, raportare și Business Center, fără niciun endpoint /business/ sau /tt_user/.

De ce returnează un apel TikTok HTTP 200 fără date?

TikTok raportează erorile în câmpul code al unui răspuns HTTP 200. Citiți code și message: 40002 este o eroare de parametru, 40001 o permisiune lipsă, iar 40100 un apel limitat.

Ce versiuni Python și Node.js cer aceste exemple?

Python 3.9 sau mai nou cu requests, plus Flask pentru webhook-ul, și Node.js 18 sau mai nou, al cărui fetch și node:crypto integrate acoperă restul.

Pot apela API-ul TikTok din browser?

Păstrați apelurile pe serverul dumneavoastră. Tipul de token TikTok este Bearer, utilizabil de oricine îl deține, iar endpoint-urile de token necesită client_secret al aplicației dumneavoastră.

Continuați să citiți

Conectați primul canal în două minute.

Fără recenzii de platformă de așteptat. Conectați WhatsApp, Instagram, TikTok sau alt canal, apoi cereți AI-ului să publice, să răspundă sau să raporteze și urmăriți-l cum lucrează.

  • 3 zile gratuit
  • Anulați oricând
  • Doar API-uri oficiale
  • Monitorizat 24/7

Verificat la