Log masukMulakan percubaan percuma
easyCoexistence API rasmi

API TikTok dalam Python dan Node.js: contoh yang berfungsi

API for Business TikTok boleh digunakan daripada Python atau Node.js dengan permintaan HTTPS biasa: hantar setiap panggilan ke https://business-api.tiktok.com/open_api/v1.3 dengan token akaun dalam header Access-Token dan open_id-nya sebagai business_id. TikTok membalas kebanyakan panggilan dengan HTTP 200 dan medan code, 0 bermakna berjaya, jadi semak medan itu dan jeda 5 minit apabila mendapat 40100.

easyCoexistence memberikan Claude, ChatGPT atau kod anda sendiri tugas TikTok yang sama sebagai alat, daripada publish_tiktok_post dan reply_to_comment hingga get_social_insights, dan menyerahkan token semasa kepada skrip anda melalui get_social_credentials atau Partner API.

HTTP 200

Status kebanyakan jawapan TikTok, termasuk ralat; hanya code 0 dalam badan menandakan panggilan berjaya.

40100

Kod untuk panggilan yang disekat: TikTok meminta jeda 5 minit selepas had seminit, dan 00:00 UTC selepas had harian.

5xx

Ralat pelayan, selepas itu TikTok mencadangkan menunggu kira-kira 5 minit sebelum memanggil semula.

Final /

Laluan berakhir dengan garis miring; TikTok memberi /tt_user/oauth2/refresh_token tanpanya sebagai punca 404 page not found.

3 languages

Python, JavaScript dan Java dalam SDK API for Business TikTok, yang senarai endpointnya tidak mengandungi sebarang endpoint /business/.

HMAC-SHA256

Tandatangan dalam header Tiktok-Signature setiap webhook, dikira ke atas cap masa, titik dan badan, dengan kunci app secret.

Apa yang diperlukan oleh setiap panggilan API TikTok?

Lima perkara yang sama, tidak kira tugasnya:

  • URL asas https://business-api.tiktok.com/open_api/v1.3, dengan laluan yang berakhir dengan garis miring, seperti /business/video/list/.
  • Token akses akaun dalam header Access-Token, diperbaharui sebelum 24 jam habis.
  • business_id, iaitu open_id akaun: dalam query string bagi GET, dalam badan JSON bagi POST.
  • Parameter senarai dan objek bagi GET, seperti fields dan filters, dihantar sebagai teks JSON: fields=["item_id","caption"].
  • Semakan code dalam jawapan, kerana TikTok menghantar ralat seperti 40002 atau 40100 dengan HTTP 200 dan data hanya apabila code ialah 0.

Bagaimana anda mengendalikan sampul ralat TikTok dalam Python?

Dengan klien kecil yang meletakkan business_id di tempat setiap kaedah memerlukannya, memulangkan data apabila code ialah 0 dan menimbulkan TikTokError jika tidak. Ia mencuba semula panggilan yang disekat selepas jeda 5 minit TikTok, kerana 40100 bermakna TikTok menolak panggilan itu, dan mencuba semula 5xx hanya pada GET, kerana penerbitan yang berakhir dengan ralat pelayan mungkin masih sampai ke TikTok. Ia memerlukan requests, dan contoh Python kemudian menggunakannya semula:

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

Bagaimana pula dalam Node.js?

Klien yang sama pada fetch terbina dalam Node.js 18 dan versi lebih baharu, tanpa perlu pasang apa-apa. Ia mengekodkan parameter senarai sebagai JSON untuk GET, meletakkan business_id dalam badan untuk POST, dan mengekalkan code TikTok pada ralat, supaya pemanggil boleh membezakan 40102 atau 40105, masalah token, daripada 40001, kebenaran yang hilang:

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

Bagaimana anda menerbitkan video melalui URL dan menyemak statusnya?

POST /business/video/publish/ dengan video_url dan post_info, kemudian semak berkala pada /business/publish/status/ dengan share_id sebagai publish_id. Gelung berhenti pada FAILED dengan sebab TikTok, dan pada PUBLISH_COMPLETE ia terus menunggu sehingga post_ids tiba, yang menurut TikTok boleh mengambil masa sehingga tiga minit lagi. video_url mesti berada pada domain atau awalan URL yang telah disahkan untuk aplikasi anda:

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

Bagaimana anda menghantar foto?

Baca dahulu tetapan akaun yang dibenarkan, kemudian POST /business/photo/publish/. Siaran foto memerlukan privacy_level, yang mesti salah satu daripada privacy_level_options dari /business/video/settings/, dan jika comment_disabled ialah true di situ, disable_comment juga mesti true. share_id yang dipulangkan diikuti dengan fungsi tunggu yang sama seperti 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);

Bagaimana anda menyenaraikan video akaun?

GET /business/video/list/ dengan medan yang anda mahu, termasuk item_id, sehingga 20 siaran sehalaman dari yang terbaharu. Hantar cursor yang dipulangkan, cap masa UTC dalam milisaat, selagi has_more ialah true, dan jangkakan halaman yang pendek: peraturan keselamatan dan kepercayaan TikTok boleh memulangkan kurang daripada max_count sebelum senarai tamat:

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

Bagaimana anda membaca komen dan membalasnya?

GET /business/comment/list/ dengan item_id siaran sebagai video_id memulangkan sehingga 30 komen sehalaman, dan POST /business/comment/reply/create/ membalas satu komen secara awam dengan sehingga 1,200 aksara teks. Contoh ini membalas komen awam peringkat atas yang belum ada balasan, melangkau komen akaun sendiri, dan menyerahkan teks balasan kepada fungsi yang anda tulis, kerana TikTok boleh menyembunyikan komen yang hampir serupa dan dihantar berdekatan sebagai 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);

Bagaimana anda membaca insights akaun?

GET /business/get/ dengan nama medan dalam fields dan julat tarikh UTC sehingga 60 hari. followers_count muncul dua kali: jumlah semasa di bahagian atas data, dan jumlah bagi setiap hari dalam metrics, bersama video_views, profile_views, likes, comments dan shares hari itu. Contoh ini berakhir pada semalam, kerana kiraan harian tiba 24 hingga 48 jam lewat:

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

Bagaimana anda mengesahkan tandatangan webhook?

Kira semula HMAC-SHA256 bagi nilai t, titik dan badan mentah, dikunci dengan app secret, bandingkan dengan s dalam masa malar, dan semak bahawa t masih baharu. Baca badan sebagai bait sebelum apa-apa menghuraikannya, balas 200 serta-merta, dan log x-tt-logid apabila semakan gagal. Flask untuk Python, dan modul http terbina dalam untuk 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);

Bagaimana anda menjalankan tugas yang sama melalui easyCoexistence?

Sebagai panggilan alat daripada Claude, ChatGPT atau klien MCP lain yang disambungkan ke https://easycoexistence.com/api/mcp, setiap satu mengambil account_id daripada list_social_accounts. easyCoexistence menghantar pautan media anda kepada TikTok melalui awalan URL yang disahkannya sendiri, mengikuti setiap siaran sehingga TikTok melengkapkan atau menggagalkannya, dan memperbaharui token, manakala panggilan yang ditolak dikembalikan dengan code dan mesej 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/" }

Bagaimana kod anda sendiri menggunakan akaun yang disambungkan ke easyCoexistence?

Ambil bukti kelayakan akaun bagi setiap tugas daripada Partner API dan hantarkannya kepada klien yang sama. GET /channels/{id}?credentials=1 dengan kunci ec_live_ anda memulangkan api_base, business_id dan access_token semasa dengan token_expires_at, atau token null dengan nota apabila saluran itu perlu disambung semula. Bacaan, balasan dan insights kemudian dijalankan daripada kod anda sendiri, manakala siaran melalui POST /channels/{id}/posts atau publish_tiktok_post, yang menghala media melalui awalan yang disahkan:

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

Kesilapan biasa

  • Membaca data tanpa menyemak code. Jawapan boleh membawa HTTP 200, code 40002 dan tiada data langsung, jadi medan yang hilang selalunya ralat yang dilangkau oleh kod anda.
  • Membuang garis miring akhir. Laluan TikTok berakhir dengan /, dan lampiran kod pulangannya memberikan /tt_user/oauth2/refresh_token, tanpa garis miring, sebagai panggilan yang berakhir dengan HTTP 404 page not found.
  • Mengambil ID balasan daripada reply_list dalam Node.js. Rujukan TikTok mentakrifkan comment_id dan video_id reply_list sebagai nombor, yang boleh dibundarkan oleh JSON.parse; /business/comment/reply/list/ memulangkannya sebagai rentetan.
  • Menghantar fields sebagai senarai dipisahkan koma. API for Business mahukan teks JSON, fields=["item_id","caption"], tidak seperti Display API di developers.tiktok.com, yang menerima fields=open_id,union_id.
Menggunakan EasyCoexistence untuk ini

US$ 9 hingga US$ 0.75 setiap sambungan sebulan, menurun apabila anda menambah sambungan, dengan 3 hari pertama percuma.

Soalan lazim

Adakah TikTok mempunyai SDK rasmi Python atau Node.js untuk Accounts API?

SDK API for Business TikTok tersedia dalam Python, JavaScript dan Java, tetapi senarai endpointnya merangkumi iklan, pelaporan dan Business Center, tanpa mana-mana endpoint /business/ atau /tt_user/.

Mengapa panggilan TikTok memulangkan HTTP 200 tanpa data?

TikTok melaporkan ralat dalam medan code bagi jawapan HTTP 200. Baca code dan message: 40002 ialah ralat parameter, 40001 kebenaran yang hilang dan 40100 panggilan yang disekat.

Versi Python dan Node.js mana yang diperlukan oleh contoh ini?

Python 3.9 atau lebih baharu dengan requests, serta Flask untuk webhook, dan Node.js 18 atau lebih baharu, yang fetch dan node:crypto terbinanya meliputi bahagian lain.

Bolehkah saya memanggil API TikTok daripada pelayar?

Kekalkan panggilan di pelayan anda. Jenis token TikTok ialah Bearer, yang boleh digunakan oleh sesiapa yang memegangnya, dan endpoint token memerlukan client_secret aplikasi anda.

Teruskan membaca

Sambungkan saluran pertama anda dalam masa dua minit.

Tidak perlu menunggu semakan platform. Sambungkan WhatsApp, Instagram, TikTok atau saluran lain, kemudian minta AI anda menyiarkan, membalas atau melaporkan, dan lihat ia bekerja.

  • 3 hari percuma
  • Batal bila-bila masa
  • API rasmi sahaja
  • Dipantau 24/7

Disahkan pada