Mag-log inMagsimula ng Libreng Trial
easyCoexistence Mga Official API

TikTok API sa Python at Node.js: mga working example

Gumagana ang TikTok API for Business mula sa Python o Node.js gamit ang plain HTTPS request: ipadala ninyo ang bawat call sa https://business-api.tiktok.com/open_api/v1.3, na may token ng account sa Access-Token header at open_id nito bilang business_id. Karamihan sa sagot ng TikTok ay HTTP 200 na may code field, kung saan 0 ang tagumpay, kaya tingnan ninyo ito at maghintay ng 5 minuto kapag 40100 ang lumabas.

Binibigyan ng easyCoexistence ng parehong TikTok job bilang tools si Claude, ChatGPT o ang sarili ninyong code, mula publish_tiktok_post at reply_to_comment hanggang get_social_insights, at inihahatid sa mga script ninyo ang kasalukuyang token sa pamamagitan ng get_social_credentials o ng Partner API.

HTTP 200

Status ng karamihan sa sagot ng TikTok, kasama ang mga error; ang code na 0 sa body lang ang nagpapakitang matagumpay ang call.

40100

Code para sa na-throttle na call: humihingi ang TikTok ng 5 minutong pahinga matapos ang per-minute limit, at 00:00 UTC matapos ang daily limit.

5xx

Mga server error, kung saan iminumungkahi ng TikTok na maghintay ng mga 5 minuto bago tumawag ulit.

Final /

Dapat may slash sa dulo ang mga path; ayon sa TikTok, ang /tt_user/oauth2/refresh_token na walang slash ay nagdudulot ng 404 page not found.

3 languages

Python, JavaScript at Java ang nasa API for Business SDK ng TikTok, at walang /business/ endpoint sa listahan ng endpoint nito.

HMAC-SHA256

Ang signature ay nasa Tiktok-Signature header ng bawat webhook, na nakabatay sa timestamp, tuldok, at body, gamit ang app secret bilang key.

Ano ang kailangan ng bawat TikTok API call?

Iisa ang limang bagay na kailangan, anuman ang job:

  • Ang base URL na https://business-api.tiktok.com/open_api/v1.3, na may path na nagtatapos sa slash, tulad ng /business/video/list/.
  • Ang access token ng account sa Access-Token header, na nire-renew bago maubos ang 24 oras nito.
  • business_id, ang open_id ng account: nasa query string sa GET, at nasa JSON body sa POST.
  • Mga parameter na list at object sa GET, tulad ng fields at filters, na ipinapadala bilang JSON text: fields=["item_id","caption"].
  • Pagsusuri ng code sa sagot, dahil nagpapadala ang TikTok ng mga error gaya ng 40002 o 40100 na may HTTP 200 at data lang kapag 0 ang code.

Paano hinahawakan ang error envelope ng TikTok sa Python?

Gamit ang maliit na client na naglalagay ng business_id kung saan ito inaasahan ng bawat method, nagbabalik ng data kapag 0 ang code, at nagtataas ng TikTokError kung hindi. Inuulit nito ang na-throttle na call matapos ang 5 minutong pahinga ng TikTok, dahil ang 40100 ay nangangahulugang tinanggihan ng TikTok ang call. Inuulit lang nito ang 5xx sa GET, dahil ang publish na nagtapos sa server error ay maaaring naabot pa rin ang TikTok. Kailangan nito ang requests, at ginagamit ito ng mga susunod na halimbawa sa 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"])

Paano ito hinahawakan sa Node.js?

Ang parehong client gamit ang fetch na built-in sa Node.js 18 at mas bago, kaya walang kailangang i-install. Ini-encode nito ang list parameter bilang JSON para sa GET, inilalagay ang business_id sa body para sa POST, at pinapanatili ang code ng TikTok sa error, para malaman ng tumatawag kung problema sa token ang 40102 o 40105, o kulang na permission ang 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);

Paano mag-publish ng video sa pamamagitan ng URL at tingnan ang status nito?

POST sa /business/video/publish/ na may video_url at post_info, saka i-poll ang /business/publish/status/ gamit ang share_id bilang publish_id. Humihinto ang loop sa FAILED kasama ang dahilan ng TikTok, at sa PUBLISH_COMPLETE ay patuloy na naghihintay hanggang dumating ang post_ids, na ayon sa TikTok ay maaaring tumagal ng hanggang tatlo pang minuto. Ang video_url ay dapat nasa domain o URL prefix na na-verify para sa app ninyo:

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

Paano mag-post ng larawan?

Basahin muna ang mga pinapayagang setting ng account, saka mag-POST sa /business/photo/publish/. Kailangan ng photo post ang privacy_level, na dapat isa sa privacy_level_options mula sa /business/video/settings/, at kapag true ang comment_disabled doon, dapat ding true ang disable_comment. Sinusundan ang ibinalik na share_id ng parehong wait function gaya ng 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);

Paano ilista ang mga video ng account?

GET sa /business/video/list/ na may mga field na gusto ninyo, kasama ang item_id, hanggang 20 post kada page simula sa pinakabago. Ipasa ang ibinalik na cursor, isang UTC timestamp sa milliseconds, habang true ang has_more, at asahan ang mas maiikling page: maaaring magbalik ng mas kaunti sa max_count ang trust and safety rules ng TikTok bago matapos ang listahan.

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

Paano basahin ang comment at sumagot sa mga ito?

Ang GET sa /business/comment/list/ na may item_id ng post bilang video_id ay nagbabalik ng hanggang 30 comment kada page, at ang POST sa /business/comment/reply/create/ ay sumasagot sa isa sa publiko, na may hanggang 1,200 character na teksto. Sinasagot ng halimbawa ang mga top-level na public comment na wala pang reply, nilalaktawan ang sariling comment ng account, at iniiwan ang wording sa function na isusulat ninyo, dahil maaaring itago ng TikTok ang halos magkakatulad na comment na sunod-sunod na naipost bilang 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);

Paano basahin ang insights ng account?

GET sa /business/get/ na may mga pangalan ng field sa fields at UTC na date range hanggang 60 araw. Dalawang beses lumalabas ang followers_count: ang kasalukuyang kabuuan sa itaas ng data, at ang kabuuan sa bawat araw sa loob ng metrics, kasama ang video_views, profile_views, likes, comments at shares ng araw na iyon. Nagtatapos ang halimbawa sa kahapon, dahil dumarating nang 24 hanggang 48 oras na huli ang daily count:

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

Paano i-verify ang signature ng webhook?

I-recompute ang HMAC-SHA256 ng halaga ng t, tuldok, at raw body, naka-key sa app secret, ihambing ito sa s sa constant time, at tiyaking bago ang t. Basahin ang body bilang bytes bago pa may mag-parse, sumagot agad ng 200, at i-log ang x-tt-logid kapag pumalya ang check. Flask para sa Python, at ang built-in na http module para sa 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);

Paano patakbuhin ang parehong job sa pamamagitan ng easyCoexistence?

Bilang tool call mula sa Claude, ChatGPT o ibang MCP client na konektado sa https://easycoexistence.com/api/mcp, kung saan kinukuha ang account_id mula sa list_social_accounts sa bawat tawag. Ipinapadala ng easyCoexistence ang media link ninyo sa TikTok sa pamamagitan ng sarili nitong na-verify na URL prefix, sinusundan ang bawat post hanggang makumpleto o mabigo ito ng TikTok, at nire-renew ang token. Kapag tinanggihan ang isang call, ibinabalik nito ang code at message ng 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/" }

Paano gamitin ng sarili ninyong code ang account na konektado sa easyCoexistence?

Kunin ang credentials ng account kada job mula sa Partner API at ipasa ang mga ito sa parehong client. Ang GET sa /channels/{id}?credentials=1 na may ec_live_ key ninyo ay nagbabalik ng api_base, business_id, at kasalukuyang access_token na may token_expires_at, o null na token na may note kapag kailangang i-reconnect ang channel. Ang pagbasa, mga reply at insights ay tumatakbo na mula sa sarili ninyong code, habang dumadaan sa POST /channels/{id}/posts o publish_tiktok_post ang mga post, na nagruruta ng media sa na-verify na prefix:

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

Mga karaniwang pagkakamali

  • Pagbabasa ng data nang hindi tinitingnan ang code. Maaaring may HTTP 200, code 40002 at walang data ang sagot, kaya kadalasan ang nawawalang field ay error na nilampasan ng code.
  • Pagkalimot sa huling slash. Nagtatapos sa / ang path ng TikTok, at ayon sa appendix ng return code nito, ang /tt_user/oauth2/refresh_token na walang slash ay tawag na nauuwi sa HTTP 404 page not found.
  • Pagkuha ng reply ID mula sa reply_list sa Node.js. Itinuturing ng reference ng TikTok na number ang comment_id at video_id ng reply_list, na maaaring bilugan ng JSON.parse; ibinabalik ng /business/comment/reply/list/ ang mga ito bilang string.
  • Pagpapadala ng fields bilang comma list. Gusto ng API for Business ang JSON text, fields=["item_id","caption"], hindi tulad ng Display API sa developers.tiktok.com na tumatanggap ng fields=open_id,union_id.
Ginagawa ito gamit ang EasyCoexistence

Mula US$ 9 hanggang US$ 0.75 kada koneksyon kada buwan, bumababa habang nagdadagdag kayo ng koneksyon, na may free trial sa unang 3 araw.

Mga madalas itanong

Mayroon bang opisyal na Python o Node.js SDK ang TikTok para sa Accounts API?

Ang SDK ng TikTok para sa API for Business ay may Python, JavaScript at Java, pero ang listahan ng endpoint nito ay sumasaklaw sa ads, reporting at Business Center, na walang /business/ o /tt_user/ na endpoint.

Bakit nagbabalik ng HTTP 200 na walang data ang isang TikTok call?

Iniuulat ng TikTok ang mga error sa code field ng sagot na HTTP 200. Basahin ang code at message: ang 40002 ay parameter error, ang 40001 ay kulang na permission at ang 40100 ay na-throttle na call.

Aling bersyon ng Python at Node.js ang kailangan ng mga halimbawang ito?

Python 3.9 o mas bago na may requests, kasama ang Flask para sa webhook, at Node.js 18 o mas bago, na ang built-in na fetch at node:crypto ang sumasaklaw sa iba.

Puwede ko bang tawagin ang TikTok API mula sa browser?

Sa server ninyo dapat manatili ang mga call. Ang token type ng TikTok ay Bearer, na magagamit ng sinumang may hawak nito, at kailangan ng token endpoints ang client_secret ng app ninyo.

Magpatuloy sa pagbabasa

I-connect ang inyong unang channel sa loob ng dalawang minuto.

Walang review ng platform na hihintayin. I-connect ang WhatsApp, Instagram, TikTok o iba pang channel, pagkatapos ay utusan ang inyong AI na mag-post, mag-reply o gumawa ng report, at panoorin itong gumana.

  • 3 araw na libre
  • Mag-cancel anumang oras
  • Official API lang
  • Minomonitor 24/7

Na-verify noong