Prijavite seZapočnite besplatni probni period
easyCoexistence Zvanični API-ji

TikTok API u Python i Node.js: radni primeri

API TikToka za poslovne naloge radi iz Pythona ili Node.js-a običnim HTTPS zahtevima: svaki poziv šaljite na https://business-api.tiktok.com/open_api/v1.3, s tokenom naloga u zaglavlju Access-Token i open_id naloga kao business_id. TikTok većinu poziva odgovara sa HTTP 200 i poljem code, gde 0 znači uspeh, pa ga proverite, a na 40100 pauzirajte 5 minuta.

easyCoexistence daje Claude, ChatGPT ili vašem kodu iste TikTok poslove kao alatke, od publish_tiktok_post i reply_to_comment do get_social_insights, a vašim skriptama predaje aktuelni token kroz get_social_credentials ili Partner API.

HTTP 200

Status većine odgovora TikToka, uključujući greške; samo code 0 u telu znači da je poziv uspeo.

40100

Kod za ograničen poziv: TikTok traži pauzu od 5 minuta posle ograničenja po minutu, a posle dnevnog do 00:00 UTC.

5xx

Greške servera, posle kojih TikTok savetuje čekanje od oko 5 minuta pre novog poziva.

Final /

Putanje se završavaju kosom crtom; TikTok navodi /tt_user/oauth2/refresh_token bez nje kao uzrok odgovora 404 page not found.

3 languages

Python, JavaScript i Java u TikTokovom SDK-ju za API for Business, čija lista endpointa ne sadrži nijedan /business/ endpoint.

HMAC-SHA256

Potpis u zaglavlju Tiktok-Signature svakog webhooka računa se nad vremenskim žigom, tačkom i telom, uz tajnu aplikacije kao ključ.

Šta je potrebno svakom pozivu TikTok API-ja?

Isto pet stvari, bez obzira na posao:

  • Osnovna adresa https://business-api.tiktok.com/open_api/v1.3, sa putanjom koja se završava kosom crtom, na primer /business/video/list/.
  • Token naloga u zaglavlju Access-Token, obnovljen pre isteka 24 sata.
  • business_id, open_id naloga: u query stringu kod GET, a u JSON telu kod POST.
  • Parametri liste i objekta kod GET, kao što su fields i filters, šalju se kao JSON tekst: fields=["item_id","caption"].
  • Provera polja code u odgovoru, jer TikTok šalje greške kao 40002 ili 40100 uz HTTP 200, a podatke samo kad je code 0.

Kako u Pythonu obrađujete omotač grešaka TikToka?

Malim klijentom koji stavlja business_id tamo gde svaka metoda to očekuje, vraća podatke kad je code 0 i diže TikTokError inače. Ponavlja ograničen poziv posle TikTokove pauze od 5 minuta, jer 40100 znači da je TikTok odbio poziv, a 5xx ponavlja samo kod GET, jer objava koja se završila greškom servera možda je ipak stigla do TikToka. Treba mu requests, a kasniji primeri u Pythonu koriste ga ponovo:

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

Kako se to radi u Node.js-u?

Isti klijent na ugrađenom fetch-u u Node.js 18 i novijem, bez ičega za instalaciju. Parametre liste za GET kodira kao JSON, stavlja business_id u telo kod POST i čuva TikTokov code u grešci, pa pozivaoci mogu da razlikuju 40102 ili 40105, problem s tokenom, od 40001, nedostajuće dozvole:

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

Kako objaviti video preko URL-a i proveriti njegov status?

POST /business/video/publish/ sa video_url i post_info, zatim proveravajte /business/publish/status/ sa share_id kao publish_id. Petlja staje na FAILED uz TikTokov razlog, a na PUBLISH_COMPLETE čeka dok ne stigne post_ids, za šta TikTok kaže da može da potraje još do tri minuta. video_url mora biti na domenu ili prefiksu URL-a koji je verifikovan za vašu aplikaciju:

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

Kako objavljujete fotografije?

Prvo pročitajte dozvoljena podešavanja naloga, pa POST /business/photo/publish/. Objava fotografije zahteva privacy_level, koji mora biti jedan od privacy_level_options iz /business/video/settings/, a kad je comment_disabled tu true, disable_comment mora biti true takođe. Vraćeni share_id prati ista funkcija čekanja kao za 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);

Kako izlistati videe naloga?

GET /business/video/list/ sa poljima koja želite, među njima item_id, do 20 objava po stranici, od najnovijih. Prosledite vraćeni cursor, UTC vremensku oznaku u milisekundama, dok je has_more true, i očekujte kratke stranice: pravila TikToka o bezbednosti mogu vratiti manje od max_count pre kraja liste.

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

Kako čitati komentare i odgovarati na njih?

GET /business/comment/list/ sa item_id objave kao video_id vraća do 30 komentara po stranici, a POST /business/comment/reply/create/ odgovara na jedan javno, sa do 1.200 znakova teksta. Primer odgovara na komentare najvišeg nivoa bez odgovora, preskače komentare samog naloga i ostavlja tekst funkciji koju pišete, jer TikTok može sakriti uglavnom slične komentare poslate u kratkom razmaku kao spam:

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

Kako čitati uvide naloga?

GET /business/get/ sa nazivima polja u fields i UTC opsegom datuma do 60 dana. followers_count dolazi dvaput: trenutni ukupan broj na vrhu data, i ukupan broj za svaki dan unutar metrics, uz video_views, profile_views, likes, comments i shares tog dana. Primer se završava juče, jer dnevni brojevi stižu sa kašnjenjem od 24 do 48 sati:

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

Kako proveriti potpis webhooka?

Ponovo izračunajte HMAC-SHA256 nad vrednošću t, tačkom i sirovim telom, uz tajnu aplikacije kao ključ, uporedite s u konstantnom vremenu i proverite da je t nedavno. Telo čitajte kao bajtove pre nego što ga bilo šta parsira, odmah odgovorite 200 i zapišite x-tt-logid kad provera ne uspe. Flask za Python i ugrađeni modul http za 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);

Kako iste poslove pokrenuti kroz easyCoexistence?

Kao alatke za Claude, ChatGPT ili drugog MCP klijenta povezanog na https://easycoexistence.com/api/mcp, pri čemu svaka uzima account_id iz list_social_accounts. easyCoexistence šalje vaše linkove medija TikToku preko sopstvenog potvrđenog prefiksa URL-a, prati svaku objavu dok TikTok ne završi ili ne odbaci, i obnavlja token, a odbijen poziv vraća sa TikTokovim code i message:

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/" }

Kako vaš kod koristi nalog povezan s easyCoexistence?

Uzmite akreditive naloga za svaki posao iz Partner API-ja i prosledite ih istom klijentu. GET /channels/{id}?credentials=1 sa vašim ec_live_ ključem vraća api_base, business_id i aktuelni access_token sa token_expires_at, ili null token sa napomenom kad kanal treba ponovo povezati. Čitanja, odgovori i uvidi se onda pokreću iz vašeg koda, dok objave idu preko POST /channels/{id}/posts ili publish_tiktok_post, koje medije šalju kroz potvrđeni prefiks:

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

Česte greške

  • Čitanje podataka bez provere code. Odgovor može imati HTTP 200, code 40002 i uopšte bez podataka, pa je nedostajuće polje često greška koju je kod preskočio.
  • Izostavljanje završne kose crte. Putanje TikToka se završavaju sa /, a dodatak s povratnim kodovima navodi /tt_user/oauth2/refresh_token bez nje kao poziv koji se završava sa HTTP 404 page not found.
  • Uzimanje ID-jeva odgovora iz reply_list u Node.js-u. TikTokova referenca navodi comment_id i video_id iz reply_list kao brojeve, koje JSON.parse može zaokružiti, dok /business/comment/reply/list/ ih vraća kao stringove.
  • Slanje polja kao zarezima odvojene liste. API for Business traži JSON tekst, fields=["item_id","caption"], za razliku od Display API-ja na developers.tiktok.com, koji prima fields=open_id,union_id.
Ovo radite uz EasyCoexistence

Od US$ 9 do US$ 0,75 po vezi mesečno, cena pada kako dodajete veze, a prva 3 dana su besplatna.

Često postavljana pitanja

Da li TikTok ima zvanični SDK za Python ili Node.js za Accounts API?

SDK TikToka za API for Business dolazi u Python, JavaScript i Java, ali njegova lista endpointa obuhvata oglase, izveštavanje i Business Center, bez /business/ ili /tt_user/ endpointa.

Zašto TikTok poziv vraća HTTP 200 bez podataka?

TikTok prijavljuje greške u polju code odgovora HTTP 200. Pročitajte code i message: 40002 je greška parametra, 40001 nedostajuća dozvola, a 40100 ograničen poziv.

Koje verzije Pythona i Node.js trebaju ovim primerima?

Python 3.9 ili noviji sa requests, uz Flask za webhook, i Node.js 18 ili noviji, čiji ugrađeni fetch i node:crypto pokrivaju ostalo.

Mogu li da pozivam TikTok API iz pregledača?

Držite pozive na svom serveru. TikTokov tip tokena je Bearer, pa ga može koristiti svako ko ga ima, a endpointi za tokene traže client_secret vaše aplikacije.

Nastavite sa čitanjem

Povežite prvi kanal za dva minuta.

Bez čekanja na odobrenja platformi. Povežite WhatsApp, Instagram, TikTok ili drugi kanal, zatim zamolite svoj AI da objavi, odgovori ili napravi izveštaj, i gledajte kako radi.

  • 3 dana besplatno
  • Otkažite bilo kada
  • Samo zvanični API-ji
  • Nadzor 24/7

Provereno na