உள்நுழைஇலவசமாகத் தொடங்குங்கள்
easyCoexistence அதிகாரப்பூர்வ API-கள்

Python மற்றும் Node.js-இல் TikTok API: செயல்படும் எடுத்துக்காட்டுகள்

TikTok-இன் API for Business Python அல்லது Node.js-இலிருந்து வழக்கமான HTTPS கோரிக்கைகளுடன் வேலை செய்கிறது: ஒவ்வொரு அழைப்பையும் https://business-api.tiktok.com/open_api/v1.3 க்கு அனுப்புங்கள், கணக்கின் டோக்கனை Access-Token தலைப்பில் வைத்து, அதன் open_id-ஐ business_id ஆக அனுப்புங்கள். TikTok பெரும்பாலான அழைப்புகளுக்கு HTTP 200 உடன் code புலத்தை அனுப்புகிறது; வெற்றிக்கு code 0. எனவே அதைச் சரிபார்த்து, 40100 வந்தால் 5 நிமிடம் இடைநிறுத்துங்கள்.

easyCoexistence, Claude, ChatGPT அல்லது உங்கள் சொந்தக் குறியீட்டுக்கு அதே TikTok பணிகளைக் கருவிகளாக வழங்குகிறது: publish_tiktok_post முதல் reply_to_comment வரை, get_social_insights வரை.

HTTP 200

பெரும்பாலான TikTok பதில்களின் நிலை, பிழைகளும் சேர்த்து; உடலில் code 0 இருந்தால் மட்டுமே அழைப்பு வெற்றி பெற்றது எனப் பொருள்.

40100

அழைப்பு வேகக் கட்டுப்பாட்டில் சிக்கியதற்கான code: நிமிட வரம்புக்குப் பின் 5 நிமிட இடைநிறுத்தம், நாள் வரம்புக்குப் பின் UTC 00:00 வரை.

5xx

சர்வர் பிழைகள்; அதன் பிறகு மீண்டும் அழைப்பதற்கு முன் சுமார் 5 நிமிடம் காத்திருக்கப் TikTok பரிந்துரைக்கிறது.

Final /

பாதைகள் ஸ்லாஷ் (/) உடன் முடிகின்றன; /tt_user/oauth2/refresh_token ஸ்லாஷ் இல்லாமல் 404 page not found-க்குக் காரணம் என TikTok குறிப்பிடுகிறது.

3 languages

TikTok-இன் API for Business SDK-இல் Python, JavaScript மற்றும் Java உள்ளன; அதன் எண்ட்பாயிண்ட் பட்டியலில் /business/ எண்ட்பாயிண்ட் இல்லை.

HMAC-SHA256

ஒவ்வொரு வெப்ஹூக்கின் Tiktok-Signature தலைப்பிலுள்ள கையொப்பம்: நேர முத்திரை, ஒரு புள்ளி, உடல் ஆகியவற்றின் மீது, ஆப் ரகசியத்தைக் கொண்டு.

TikTok API ஒவ்வொரு அழைப்புக்கும் எவை தேவை?

வேலை எதுவாக இருந்தாலும், தேவைப்படும் ஐந்து விஷயங்கள் ஒன்றே:

  • அடிப்படை URL https://business-api.tiktok.com/open_api/v1.3, சாய்வுக்கோடு (/) உடன் முடியும் பாதையுடன், எடுத்துக்காட்டாக /business/video/list/.
  • கணக்கின் அணுகல் டோக்கன், Access-Token தலைப்பில்; 24 மணி நேரம் முடிவதற்கு முன் புதுப்பிக்கப்பட வேண்டும்.
  • business_id, அதாவது கணக்கின் open_id: GET-இல் வினவல் சரத்திலும், POST-இல் JSON உடலிலும்.
  • GET-இல் fields, filters போன்ற பட்டியல் மற்றும் பொருள் அளபுருக்கள் JSON உரையாக அனுப்பப்படும்: fields=["item_id","caption"].
  • பதிலில் code சரிபார்ப்பு: TikTok 40002 அல்லது 40100 போன்ற பிழைகளை HTTP 200 உடன் அனுப்புகிறது; code 0 ஆக இருந்தால் மட்டுமே data வரும்.

பைத்தானில் TikTok-இன் பிழை உறையை எவ்வாறு கையாள்வது?

business_id ஒவ்வொரு முறையின் எதிர்பார்ப்புக்கும் ஏற்ற இடத்தில் வைக்கும் ஒரு சிறிய கிளையன்ட்டுடன்: code 0 ஆக இருந்தால் data திருப்பும், இல்லையெனில் TikTokError எழுப்பும். கட்டுப்பாட்டில் சிக்கிய அழைப்பை TikTok-இன் 5 நிமிட இடைநிறுத்தத்திற்குப் பின் மீண்டும் செய்யும், ஏனெனில் 40100 என்பது TikTok அழைப்பை மறுத்தது என்று பொருள். 5xx பிழையை GET-இல் மட்டுமே மீண்டும் செய்யும், ஏனெனில் சர்வர் பிழையில் முடிந்த வெளியீடு TikTok-ஐ அடைந்திருக்கலாம். இதற்கு requests தேவை; அடுத்த பைத்தான் எடுத்துக்காட்டுகள் இதையே மீண்டும் பயன்படுத்துகின்றன:

Python: a TikTok client that reads the envelope
import json
import os
import time

import requests

API = "https://business-api.tiktok.com/open_api/v1.3"


class TikTokError(Exception):
    def __init__(self, code, message, request_id):
        super().__init__(f"TikTok {code}: {message} (request_id {request_id})")
        self.code = code


class TikTok:
    """One TikTok account: its access token and its business_id, the open_id."""

    def __init__(self, access_token, business_id, pause=300):
        self.http = requests.Session()
        self.http.headers["Access-Token"] = access_token
        self.business_id = business_id
        self.pause = pause  # TikTok's advice after a 40100 or a 5xx: about 5 minutes

    def call(self, method, path, params=None, body=None, tries=3):
        for attempt in range(1, tries + 1):
            if method == "GET":
                query = {"business_id": self.business_id}
                for key, value in (params or {}).items():
                    is_json = isinstance(value, (list, dict))
                    query[key] = json.dumps(value, separators=(",", ":")) if is_json else value
                res = self.http.get(f"{API}/{path}", params=query, timeout=30)
            else:
                payload = {"business_id": self.business_id, **(body or {})}
                res = self.http.post(f"{API}/{path}", json=payload, timeout=30)
            if res.status_code >= 500 and method == "GET" and attempt < tries:
                time.sleep(self.pause)  # a POST is not repeated: it may have reached TikTok
                continue
            res.raise_for_status()  # a 4xx: a wrong path or method, such as a missing final slash
            answer = res.json()
            if answer.get("code") == 0:
                return answer.get("data") or {}
            if answer.get("code") == 40100 and attempt < tries:
                time.sleep(self.pause)  # throttled: TikTok refused the call, so repeating it is safe
                continue
            raise TikTokError(answer.get("code"), answer.get("message"), answer.get("request_id"))


tt = TikTok(os.environ["TIKTOK_ACCESS_TOKEN"], os.environ["TIKTOK_BUSINESS_ID"])

Node.js-இல் இதை எவ்வாறு கையாள்வது?

அதே கிளையன்ட், Node.js 18 மற்றும் அதற்குப் பின் வந்த பதிப்புகளில் உள்ளமைந்த fetch-இல், எதையும் நிறுவாமல். GET-க்கு பட்டியல் அளபுருக்களை JSON ஆக குறியாக்கும், POST-க்கு business_id-ஐ உடலில் வைக்கும், பிழையில் TikTok-இன் code-ஐ வைத்திருக்கும். அதனால் அழைப்பாளர்கள் டோக்கன் பிரச்சினையான 40102 அல்லது 40105-ஐ, அனுமதி இல்லாத 40001-இலிருந்து வேறுபடுத்த முடியும்:

Node.js: the same client on the built-in fetch
const API = "https://business-api.tiktok.com/open_api/v1.3";
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

class TikTokError extends Error {
  constructor(code, message, requestId) {
    super("TikTok " + code + ": " + message + " (request_id " + requestId + ")");
    this.code = code;
  }
}

// One TikTok account: its access token and its business_id, the open_id.
class TikTok {
  constructor(accessToken, businessId, pauseMs = 300000) {
    this.accessToken = accessToken;
    this.businessId = businessId;
    this.pauseMs = pauseMs; // TikTok's advice after a 40100 or a 5xx: about 5 minutes
  }

  async call(method, path, { params = {}, body = {} } = {}, tries = 3) {
    for (let attempt = 1; ; attempt++) {
      const url = new URL(API + "/" + path);
      const init = { method, headers: { "Access-Token": this.accessToken } };
      if (method === "GET") {
        url.searchParams.set("business_id", this.businessId);
        for (const [key, value] of Object.entries(params)) {
          url.searchParams.set(key, typeof value === "object" ? JSON.stringify(value) : String(value));
        }
      } else {
        init.headers["Content-Type"] = "application/json";
        init.body = JSON.stringify({ business_id: this.businessId, ...body });
      }
      const res = await fetch(url, init);
      if (res.status >= 500 && method === "GET" && attempt < tries) {
        await sleep(this.pauseMs); // a POST is not repeated: it may have reached TikTok
        continue;
      }
      if (!res.ok) throw new Error("HTTP " + res.status + " on " + path + ": check the path, its final slash and the method");
      const answer = await res.json();
      if (answer.code === 0) return answer.data ?? {};
      if (answer.code === 40100 && attempt < tries) {
        await sleep(this.pauseMs); // throttled: TikTok refused the call, so repeating it is safe
        continue;
      }
      throw new TikTokError(answer.code, answer.message, answer.request_id);
    }
  }
}

const tt = new TikTok(process.env.TIKTOK_ACCESS_TOKEN, process.env.TIKTOK_BUSINESS_ID);

வீடியோவை URL மூலம் எவ்வாறு வெளியிட்டு அதன் நிலையைச் சரிபார்ப்பது?

video_url மற்றும் post_info உடன் POST /business/video/publish/, பின்னர் share_id-ஐ publish_id ஆகக் கொண்டு /business/publish/status/ ஐத் தொடர்ந்து சோதிக்கவும். FAILED வந்தால் TikTok-இன் காரணத்துடன் சுழற்சி நிற்கும்; PUBLISH_COMPLETE வந்தால் post_ids வரும் வரை காத்திருக்கும், இதற்கு மேலும் மூன்று நிமிடம் வரை ஆகலாம் என TikTok கூறுகிறது. video_url உங்கள் ஆப்புக்குச் சரிபார்க்கப்பட்ட டொமைன் அல்லது URL முன்னொட்டில் இருக்க வேண்டும்:

Publish a video and wait until it is public: Python, then Node.js
# Python
def wait_until_live(tt, share_id, interval=30, give_up_after=7200):
    deadline = time.time() + give_up_after
    while time.time() < deadline:
        status = tt.call("GET", "business/publish/status/", params={"publish_id": share_id})
        if status["status"] == "FAILED":
            raise RuntimeError(f"TikTok did not publish {share_id}: {status.get('reason')}")
        if status["status"] == "PUBLISH_COMPLETE" and status.get("post_ids"):
            return status["post_ids"]
        time.sleep(interval)  # post_ids can follow PUBLISH_COMPLETE by up to three minutes
    raise TimeoutError(f"{share_id} was not public after {give_up_after} s")


video = tt.call("POST", "business/video/publish/", body={
    "video_url": "https://media.example.com/tiktok/launch.mp4",  # on a verified domain or URL prefix
    "post_info": {
        "caption": "Our spring menu is live #food",
        "is_brand_organic": True,  # the Promotional content label, for the account's own business
        "is_branded_content": False,
    },
})
print("Live:", wait_until_live(tt, video["share_id"]))

// Node.js
async function waitUntilLive(tt, shareId, everyMs = 30000, giveUpAfterMs = 7200000) {
  const deadline = Date.now() + giveUpAfterMs;
  while (Date.now() < deadline) {
    const s = await tt.call("GET", "business/publish/status/", { params: { publish_id: shareId } });
    if (s.status === "FAILED") throw new Error("TikTok did not publish " + shareId + ": " + s.reason);
    if (s.status === "PUBLISH_COMPLETE" && s.post_ids && s.post_ids.length) return s.post_ids;
    await sleep(everyMs); // post_ids can follow PUBLISH_COMPLETE by up to three minutes
  }
  throw new Error(shareId + " was not public after " + giveUpAfterMs / 1000 + " s");
}

async function publishVideo(tt) {
  const video = await tt.call("POST", "business/video/publish/", {
    body: {
      video_url: "https://media.example.com/tiktok/launch.mp4", // on a verified domain or URL prefix
      post_info: { caption: "Our spring menu is live #food", is_brand_organic: true, is_branded_content: false },
    },
  });
  return waitUntilLive(tt, video.share_id);
}

publishVideo(tt).then((postIds) => console.log("Live:", postIds), console.error);

புகைப்படங்களை எவ்வாறு வெளியிடுவது?

முதலில் கணக்கின் அனுமதிக்கப்பட்ட அமைப்புகளைப் படியுங்கள், பின்னர் POST /business/photo/publish/. புகைப்பட வெளியீட்டிற்கு privacy_level தேவை; அது /business/video/settings/ இலிருந்து வரும் privacy_level_options-இல் ஒன்றாக இருக்க வேண்டும். அங்கே comment_disabled true ஆக இருந்தால் disable_comment-உம் true ஆக இருக்க வேண்டும். திரும்பும் share_id-ஐ வீடியோவைப் போலவே அதே காத்திருப்பு செயல்பாட்டுடன் பின்தொடருங்கள்:

Publish a photo post: Python, then Node.js
# Python
def publish_photos(tt, image_urls, title, caption):
    settings = tt.call("GET", "business/video/settings/")
    if "PUBLIC_TO_EVERYONE" not in settings["privacy_level_options"]:
        raise RuntimeError(f"Private account, choose from {settings['privacy_level_options']}")
    photo = tt.call("POST", "business/photo/publish/", body={
        "photo_images": image_urls,  # 1 to 35 JPG, JPEG or WebP links on a verified domain or prefix
        "photo_cover_index": 0,
        "post_info": {
            "title": title,  # up to 90 UTF-16 code units
            "caption": caption,  # up to 4,000
            "privacy_level": "PUBLIC_TO_EVERYONE",
            "disable_comment": settings["comment_disabled"],  # True when the account takes no comments
            "is_brand_organic": True,
            "is_branded_content": False,
        },
    })
    return wait_until_live(tt, photo["share_id"])


print(publish_photos(tt, ["https://media.example.com/menu/1.jpg", "https://media.example.com/menu/2.jpg"],
                     "Spring menu", "Four new dishes, from Friday #food"))

// Node.js
async function publishPhotos(tt, imageUrls, title, caption) {
  const settings = await tt.call("GET", "business/video/settings/");
  if (!settings.privacy_level_options.includes("PUBLIC_TO_EVERYONE")) {
    throw new Error("Private account, choose from " + settings.privacy_level_options.join(", "));
  }
  const photo = await tt.call("POST", "business/photo/publish/", {
    body: {
      photo_images: imageUrls, // 1 to 35 JPG, JPEG or WebP links on a verified domain or prefix
      photo_cover_index: 0,
      post_info: {
        title, // up to 90 UTF-16 code units
        caption, // up to 4,000
        privacy_level: "PUBLIC_TO_EVERYONE",
        disable_comment: settings.comment_disabled, // true when the account takes no comments
        is_brand_organic: true,
        is_branded_content: false,
      },
    },
  });
  return waitUntilLive(tt, photo.share_id);
}

publishPhotos(tt, ["https://media.example.com/menu/1.jpg", "https://media.example.com/menu/2.jpg"],
  "Spring menu", "Four new dishes, from Friday #food").then(console.log, console.error);

கணக்கின் வீடியோக்களை எவ்வாறு பட்டியலிடுவது?

GET /business/video/list/ உடன் நீங்கள் விரும்பும் fields, அவற்றில் item_id, ஒரு பக்கத்திற்கு 20 பதிவுகள் வரை, புதியவற்றிலிருந்து. has_more true ஆக இருக்கும் வரை திரும்பிய cursor-ஐ அனுப்புங்கள்; அது மில்லி விநாடிகளில் UTC நேர முத்திரை. குறுகிய பக்கங்களை எதிர்பாருங்கள்: TikTok-இன் நம்பிக்கை மற்றும் பாதுகாப்பு விதிகள் பட்டியல் முடிவதற்கு முன் max_count-ஐ விடக் குறைவானதைத் திருப்பலாம்.

List recent videos across pages: Python, then Node.js
# Python
def recent_videos(tt, how_many=60):
    params = {"fields": ["item_id", "create_time", "caption", "share_url", "video_views", "likes", "comments"],
              "max_count": 20}
    videos = []
    while len(videos) < how_many:
        page = tt.call("GET", "business/video/list/", params=params)
        videos += page.get("videos", [])
        if not page.get("has_more"):
            break
        params["cursor"] = page["cursor"]  # posts published before this UTC time, in milliseconds
    return videos[:how_many]


for v in recent_videos(tt):
    print(v["item_id"], v.get("video_views"), (v.get("caption") or "")[:60])

// Node.js
async function recentVideos(tt, howMany = 60) {
  const params = {
    fields: ["item_id", "create_time", "caption", "share_url", "video_views", "likes", "comments"],
    max_count: 20,
  };
  const videos = [];
  while (videos.length < howMany) {
    const page = await tt.call("GET", "business/video/list/", { params });
    videos.push(...(page.videos ?? []));
    if (!page.has_more) break;
    params.cursor = page.cursor; // posts published before this UTC time, in milliseconds
  }
  return videos.slice(0, howMany);
}

recentVideos(tt).then((videos) => {
  for (const v of videos) console.log(v.item_id, v.video_views, (v.caption || "").slice(0, 60));
}, console.error);

கருத்துகளைப் படித்து அவற்றுக்குப் பதிலளிப்பது எப்படி?

GET /business/comment/list/, இடுகையின் item_id-ஐ video_id ஆகக் கொண்டு, ஒரு பக்கத்திற்கு 30 கருத்துகள் வரை திருப்பும். POST /business/comment/reply/create/ ஒரு கருத்துக்குப் பொதுவில் 1,200 எழுத்துகள் வரை பதிலளிக்கும். எடுத்துக்காட்டு, பதில்கள் இல்லாத மேல்நிலைப் பொதுக் கருத்துகளுக்கு மட்டும் பதிலளிக்கும், கணக்கின் சொந்தக் கருத்துகளைத் தவிர்க்கும், சொற்களை நீங்கள் எழுதும் ஒரு செயல்பாட்டிடம் விடும்; ஏனெனில் அருகருகே இடப்பட்ட பெரும்பாலும் ஒத்த கருத்துகளை TikTok ஸ்பேம் எனக் கருதி மறைக்கக்கூடும்:

Reply to new comments on a video: Python, then Node.js
# Python
def reply_to_new_comments(tt, video_id, write_reply):
    page = tt.call("GET", "business/comment/list/", params={
        "video_id": video_id,  # the post's item_id
        "status": "PUBLIC",
        "sort_field": "create_time",
        "sort_order": "desc",
        "max_count": 30,
    })
    for comment in page.get("comments", []):
        if comment.get("owner") or comment.get("replies") or comment.get("parent_comment_id"):
            continue  # the account's own comments, threads with replies, and replies
        text = write_reply(comment)
        if text:
            tt.call("POST", "business/comment/reply/create/", body={
                "video_id": video_id, "comment_id": comment["comment_id"], "text": text,  # up to 1,200 characters
            })


def reply_for(comment):
    if "price" in (comment.get("text") or "").lower():
        return f"Hi {comment.get('display_name') or 'there'}, the price list is pinned on our profile."
    return None  # leave the rest to a person


reply_to_new_comments(tt, "<ITEM_ID>", reply_for)

// Node.js
async function replyToNewComments(tt, videoId, writeReply) {
  const page = await tt.call("GET", "business/comment/list/", {
    params: { video_id: videoId, status: "PUBLIC", sort_field: "create_time", sort_order: "desc", max_count: 30 },
  });
  for (const comment of page.comments ?? []) {
    if (comment.owner || comment.replies || comment.parent_comment_id) continue; // own, already replied to, or a reply
    const text = writeReply(comment);
    if (text) {
      await tt.call("POST", "business/comment/reply/create/", {
        body: { video_id: videoId, comment_id: comment.comment_id, text }, // up to 1,200 characters
      });
    }
  }
}

function replyFor(comment) {
  if ((comment.text || "").toLowerCase().includes("price")) {
    return "Hi " + (comment.display_name || "there") + ", the price list is pinned on our profile.";
  }
  return null; // leave the rest to a person
}

replyToNewComments(tt, "<ITEM_ID>", replyFor).catch(console.error);

கணக்கின் நுண்ணறிவுகளை எவ்வாறு படிப்பது?

GET /business/get/ உடன் fields-இல் புலப் பெயர்கள், மற்றும் 60 நாட்கள் வரையிலான UTC தேதி வரம்பு. followers_count இருமுறை வரும்: data-வின் மேலே தற்போதைய மொத்தம், மற்றும் metrics-இன் உள்ளே ஒவ்வொரு நாளின் மொத்தமும், அந்த நாளின் video_views, profile_views, likes, comments மற்றும் shares உடன். தினசரி எண்ணிக்கைகள் 24 முதல் 48 மணி நேரம் தாமதமாக வருவதால் எடுத்துக்காட்டு நேற்று வரை முடிகிறது:

Daily account metrics for the last 7 days: Python, then Node.js
# Python
from datetime import datetime, timedelta, timezone


def daily_insights(tt, days=7):
    yesterday = datetime.now(timezone.utc).date() - timedelta(days=1)  # counts arrive 24 to 48 h late
    data = tt.call("GET", "business/get/", params={
        "fields": ["followers_count", "video_views", "profile_views", "likes", "comments", "shares"],
        "start_date": (yesterday - timedelta(days=days - 1)).isoformat(),  # UTC, up to 60 days back
        "end_date": yesterday.isoformat(),
    })
    print("Followers now:", data.get("followers_count"))
    for day in data.get("metrics", []):
        print(day["date"], day.get("followers_count"), day.get("video_views"), day.get("likes"))


daily_insights(tt)

// Node.js
async function dailyInsights(tt, days = 7) {
  const utcDay = (daysAgo) => new Date(Date.now() - daysAgo * 86400000).toISOString().slice(0, 10);
  const data = await tt.call("GET", "business/get/", {
    params: {
      fields: ["followers_count", "video_views", "profile_views", "likes", "comments", "shares"],
      start_date: utcDay(days), // UTC, up to 60 days back
      end_date: utcDay(1), // counts arrive 24 to 48 h late
    },
  });
  console.log("Followers now:", data.followers_count);
  for (const day of data.metrics ?? []) console.log(day.date, day.followers_count, day.video_views, day.likes);
}

dailyInsights(tt).catch(console.error);

வெப்ஹூக் கையொப்பத்தை எவ்வாறு சரிபார்ப்பது?

t மதிப்பு, ஒரு புள்ளி, மூல உடல் ஆகியவற்றின் HMAC-SHA256-ஐ மீண்டும் கணக்கிட்டு, ஆப் ரகசியத்தைக் கொண்டு, s உடன் நிலையான நேரத்தில் ஒப்பிடுங்கள்; t சமீபத்தியதா என்பதையும் சரிபார்க்கவும். எதையும் பாகுபடுத்துவதற்கு முன் உடலை பைட்டுகளாகப் படியுங்கள், உடனே 200 பதில் அளியுங்கள், சரிபார்ப்பு தோல்வியுற்றால் x-tt-logid-ஐப் பதிவு செய்யுங்கள். பைத்தானுக்கு Flask, Node.js-க்கு உள்ளமைந்த http தொகுதி:

Receive a signed TikTok webhook: Python with Flask, then Node.js
# Python
import hashlib
import hmac
import json
import os
import time
from queue import Queue

from flask import Flask, request

app = Flask(__name__)
events = Queue()


def signature_ok(raw, header, secret, max_age=300):
    fields = {}
    for part in (header or "").split(","):
        key, sep, value = part.strip().partition("=")
        if sep:
            fields[key] = value
    t, s = fields.get("t", ""), fields.get("s", "").lower()
    if not t.isdigit() or len(s) != 64:
        return False
    expected = hmac.new(secret.encode(), t.encode() + b"." + raw, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, s) and abs(time.time() - int(t)) <= max_age


@app.post("/tiktok/webhook")
def tiktok_webhook():
    raw = request.get_data()  # the bytes TikTok signed, before any JSON parsing
    if not signature_ok(raw, request.headers.get("Tiktok-Signature"), os.environ["TIKTOK_APP_SECRET"]):
        app.logger.warning("Bad signature, x-tt-logid %s", request.headers.get("X-Tt-Logid"))
        return "", 401
    events.put(json.loads(raw))  # its content field is itself a JSON string: work on it elsewhere
    return "", 200

// Node.js
const { createServer } = require("node:http");
const { createHmac, timingSafeEqual } = require("node:crypto");

function signatureOk(raw, header, secret, maxAgeSec = 300) {
  const fields = {};
  for (const part of String(header ?? "").split(",")) {
    const i = part.indexOf("=");
    if (i > 0) fields[part.slice(0, i).trim()] = part.slice(i + 1).trim();
  }
  if (!/^\d+$/.test(fields.t ?? "") || !/^[0-9a-f]{64}$/i.test(fields.s ?? "")) return false;
  const expected = createHmac("sha256", secret).update(fields.t + ".").update(raw).digest();
  const fresh = Math.abs(Date.now() / 1000 - Number(fields.t)) <= maxAgeSec;
  return timingSafeEqual(expected, Buffer.from(fields.s, "hex")) && fresh;
}

const inbox = [];
createServer((req, res) => {
  if (req.method !== "POST" || req.url !== "/tiktok/webhook") return res.writeHead(404).end();
  const chunks = [];
  req.on("data", (chunk) => chunks.push(chunk));
  req.on("end", () => {
    const raw = Buffer.concat(chunks); // the bytes TikTok signed
    if (!signatureOk(raw, req.headers["tiktok-signature"], process.env.TIKTOK_APP_SECRET)) {
      console.warn("Bad signature, x-tt-logid", req.headers["x-tt-logid"]);
      return res.writeHead(401).end();
    }
    res.writeHead(200).end(); // answer first: TikTok retries anything but a 200 for up to 72 hours
    inbox.push(JSON.parse(raw.toString("utf8")));
  });
}).listen(3000);

அதே பணிகளை easyCoexistence வழியாக எவ்வாறு இயக்குவது?

https://easycoexistence.com/api/mcp-உடன் இணைக்கப்பட்ட Claude, ChatGPT அல்லது வேறு MCP கிளையன்ட்டிலிருந்து கருவி அழைப்புகளாக, ஒவ்வொன்றும் list_social_accounts-இலிருந்து account_id-ஐ எடுத்துக்கொள்ளும். easyCoexistence உங்கள் மீடியா இணைப்புகளை அதன் சொந்தச் சரிபார்க்கப்பட்ட URL முன்னொட்டு வழியாக TikTok-க்கு அனுப்புகிறது, ஒவ்வொரு இடுகையையும் TikTok முடிக்கும் அல்லது தோல்வியடையும் வரை பின்தொடர்கிறது, டோக்கனைப் புதுப்பிக்கிறது. மறுக்கப்பட்ட அழைப்பு TikTok-இன் code மற்றும் 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/" }

easyCoexistence-உடன் இணைக்கப்பட்ட கணக்கை உங்கள் சொந்தக் குறியீடு எவ்வாறு பயன்படுத்துகிறது?

Partner API வழியாக ஒவ்வொரு வேலைக்கும் கணக்கின் நற்சான்றிதழ்களைப் பெற்று அதே கிளையன்ட்டுக்கு அனுப்புங்கள். உங்கள் ec_live_ விசையுடன் GET /channels/{id}?credentials=1, api_base, business_id மற்றும் token_expires_at உடன் தற்போதைய access_token-ஐத் திருப்பும்; சேனலுக்கு மீண்டும் இணைக்க வேண்டும் என்றால் குறிப்புடன் null டோக்கன் திருப்பும். வாசிப்புகள், பதில்கள் மற்றும் நுண்ணறிவுகள் உங்கள் சொந்தக் குறியீட்டிலிருந்து இயங்கும்; இடுகைகள் POST /channels/{id}/posts அல்லது publish_tiktok_post வழியாகச் செல்லும், அவை மீடியாவை சரிபார்க்கப்பட்ட முன்னொட்டு வழியாக அனுப்பும்:

A current token from the Partner API, into the same client: Python, then Node.js
# Python
def tiktok_for(channel_id):
    res = requests.get(f"https://easycoexistence.com/api/v1/channels/{channel_id}", params={"credentials": "1"},
                       headers={"Authorization": f"Bearer {os.environ['EC_API_KEY']}"}, timeout=30)
    res.raise_for_status()
    creds = res.json()["credentials"]
    if not creds.get("access_token"):
        raise RuntimeError(creds.get("note"))  # the channel needs reconnecting
    return TikTok(creds["access_token"], creds["business_id"])


print(recent_videos(tiktok_for("<CHANNEL_ID>"), 20))

// Node.js
async function tiktokFor(channelId) {
  const res = await fetch("https://easycoexistence.com/api/v1/channels/" + channelId + "?credentials=1", {
    headers: { Authorization: "Bearer " + process.env.EC_API_KEY },
  });
  if (!res.ok) throw new Error("HTTP " + res.status + " from easyCoexistence");
  const { credentials } = await res.json();
  if (!credentials.access_token) throw new Error(credentials.note); // the channel needs reconnecting
  return new TikTok(credentials.access_token, credentials.business_id);
}

tiktokFor("<CHANNEL_ID>").then((account) => recentVideos(account, 20)).then(console.log, console.error);

பொதுவான தவறுகள்

  • code-ஐச் சரிபார்க்காமல் தரவைப் படிப்பது. ஒரு பதில் HTTP 200, code 40002 மற்றும் data இல்லாமல் வரலாம்; எனவே காணாமல் போன புலம் பெரும்பாலும் குறியீடு தவிர்த்த பிழையாகும்.
  • இறுதி slash-ஐ விடுவது. TikTok-இன் பாதைகள் / உடன் முடியும்; அதன் திரும்பும் code இணைப்பு /tt_user/oauth2/refresh_token-ஐ, slash இல்லாமல், 404 page not found உடன் முடியும் அழைப்பாகக் கொடுக்கிறது.
  • Node.js-இல் reply_list-இலிருந்து பதில் ID-களை எடுப்பது. TikTok-இன் குறிப்பு reply_list-இன் comment_id மற்றும் video_id-ஐ எண்களாக வகைப்படுத்துகிறது; JSON.parse அவற்றை நெருங்கிய மதிப்பாக மாற்றக்கூடும். /business/comment/reply/list/ அவற்றைச் சரங்களாகத் திருப்புகிறது.
  • fields-ஐ காற்புள்ளிப் பட்டியலாக அனுப்புவது. API for Business JSON உரையை எதிர்பார்க்கிறது: fields=["item_id","caption"]. developers.tiktok.com-இன் Display API போலன்றி, அது fields=open_id,union_id-ஐ ஏற்கிறது.
EasyCoexistence மூலம் இதைச் செய்வது

உங்கள் ஸ்கிரிப்ட்களுக்கு get_social_credentials அல்லது Partner API வழியாக தற்போதைய டோக்கனையும் வழங்குகிறது. ஒரு இணைப்புக்கு மாதம் US$ 9 முதல் US$ 0.75 வரை, நீங்கள் இணைப்புகளைச் சேர்க்கும்போது குறைகிறது, முதல் 3 நாட்கள் இலவசம்.

அடிக்கடி கேட்கப்படும் கேள்விகள்

TikTok Accounts API-க்கு அதிகாரப்பூர்வ Python அல்லது Node.js SDK உள்ளதா?

TikTok-இன் API for Business SDK Python, JavaScript மற்றும் Java-வில் வருகிறது; ஆனால் அதன் எண்ட்பாயிண்ட் பட்டியல் விளம்பரங்கள், அறிக்கையிடல் மற்றும் Business Center-ஐ உள்ளடக்குகிறது. /business/ அல்லது /tt_user/ எண்ட்பாயிண்ட் இல்லை.

TikTok அழைப்பு ஏன் தரவு இல்லாமல் HTTP 200 திருப்புகிறது?

TikTok பிழைகளை HTTP 200 பதிலின் code புலத்தில் தெரிவிக்கிறது. code மற்றும் message-ஐப் படியுங்கள்: 40002 என்பது அளபுரு பிழை, 40001 அனுமதி இல்லாதது, 40100 கட்டுப்பாட்டில் சிக்கிய அழைப்பு.

இந்த எடுத்துக்காட்டுகளுக்கு எந்த Python மற்றும் Node.js பதிப்புகள் தேவை?

requests உடன் Python 3.9 அல்லது அதற்குப் பின், வெப்ஹூக்குக்கு Flask உடன், மற்றும் Node.js 18 அல்லது அதற்குப் பின், அதன் உள்ளமைந்த fetch மற்றும் node:crypto மீதமுள்ளவற்றை ஈடுசெய்யும்.

உலாவியிலிருந்து TikTok API-ஐ அழைக்க முடியுமா?

அழைப்புகளை உங்கள் சர்வரிலேயே வைத்திருங்கள். TikTok-இன் டோக்கன் வகை Bearer; அதை வைத்திருக்கும் எவரும் பயன்படுத்தக்கூடியது. டோக்கன் எண்ட்பாயிண்ட்டுகளுக்கு உங்கள் ஆப்பின் client_secret தேவை.

தொடர்ந்து படிக்கவும்

TikTok API வழிகாட்டி 2026: உங்கள் ஆப்ஸிலிருந்து முதல் பதிவு வரை2026 இல் TikTok API பாதை: API, ஆப் ஆய்வு, ஸ்கோப்கள், டோக்கன்கள், வெளியீடு, ஸ்டேட்டஸ், கருத்துகள், வெப்ஹூக்குகள், இன்சைட்ஸ், வரம்புகள்.2026 இல் TikTok API மாற்றங்கள்: என்ன நின்றது, என்ன செய்வது2026 இல் TikTok API மாற்றங்கள்: டோக்கன் ஆயுட்காலம், is_business_account, கருத்து வரம்பு, அணுகல் படிவம், ஒவ்வொரு திருத்தமும்.TikTok API இணைப்பு ஏன் நின்றுபோகிறது, அதை எப்படி இயக்கத்தில் வைப்பதுTikTok API for Business இணைப்பு ஏன் நின்றுபோகிறது: 24 மணி நேர டோக்கன், ஓராண்டு ரெஃப்ரெஷ் டோக்கன், அணுகல் ரத்து, மீண்டும் இணைப்பது.API வழியாக TikTok-க்கு வீடியோ பதிவிடுவது எப்படிAPI for Business வழியாக TikTok-க்கு வீடியோ பதிவிடுங்கள். பப்ளிஷ் எண்ட்பாயிண்ட், JSON body, share_id, ஸ்டேட்டஸ் அழைப்பு; curl, Python உதாரணங்களுடன்.வெப்ஹூக்குகளைச் சரிபார்த்தல்: TikTok-இன் கையொப்ப ஹெடரும் அதைச் சரிபார்க்கும் முறையும்TikTok API for Business வெப்ஹூக்கைச் சரிபார்க்கவும்: Tiktok-Signature ஹெடர், HMAC-SHA256, செயலி ரகசியம், Node.js குறியீடு.TikTok API வரம்புகள்: ஒவ்வொரு கணக்கு, ஆப் மற்றும் எண்ட்பாயிண்ட்டுக்கும்TikTok API வரம்புகள்: ஒரு கணக்கிற்கு நிமிடத்திற்கு 40 அழைப்புகள், ஆப்பிற்கு 600 அல்லது 1,000, மற்றும் நான்கு ஆப் நிலைகள்.

உங்கள் முதல் சேனலை இரண்டு நிமிடங்களில் இணையுங்கள்.

காத்திருக்க வேண்டிய தளச் மதிப்பாய்வுகள் எதுவும் இல்லை. WhatsApp, Instagram, TikTok அல்லது வேறொரு சேனலை இணையுங்கள். பிறகு போஸ்ட் செய்ய, பதிலளிக்க அல்லது ரிப்போர்ட் தர உங்கள் AI-யிடம் கேளுங்கள், அது செயல்படுவதைப் பாருங்கள்.

  • 3 நாட்கள் இலவசம்
  • எப்போது வேண்டுமானாலும் ரத்து செய்யலாம்
  • அதிகாரப்பூர்வ API-கள் மட்டுமே
  • 24/7 கண்காணிப்பு

இதில் சரிபார்க்கப்பட்டது: