TikTok API Pythonissa ja Node.js:ssä: toimivat esimerkit
TikTokin API for Business toimii Pythonilla tai Node.js:llä tavallisilla HTTPS-pyynnöillä: lähetä jokainen kutsu osoitteeseen https://business-api.tiktok.com/open_api/v1.3, tilin token Access-Token-otsakkeessa ja open_id business_id-kenttänä. TikTok vastaa useimpiin kutsuihin HTTP 200:lla ja code-kentällä, jossa 0 tarkoittaa onnistumista. Tarkista se ja odota 5 minuuttia virhekoodin 40100 kohdalla.
easyCoexistence antaa Claudelle, ChatGPT:lle tai omalle koodillesi samat TikTok-tehtävät työkaluina, publish_tiktok_postista reply_to_commentiin ja get_social_insightsiin, ja antaa skriptillesi ajantasaisen tokenin get_social_credentials-työkalun tai Partner API:n kautta.
Useimpien TikTok-vastausten tila, virheetkin mukaan lukien; vain rungon code-arvo 0 tarkoittaa, että kutsu onnistui.
Rajoitetun kutsun koodi: TikTok pyytää 5 minuutin taukoa minuuttirajan jälkeen ja päivärajan jälkeen odottamaan 00:00 UTC:hen saakka.
Palvelinvirheet, joiden jälkeen TikTok suosittelee noin 5 minuutin odotusta ennen uutta kutsua.
Polut päättyvät kauttaviivaan. TikTok mainitsee /tt_user/oauth2/refresh_token ilman sitä syynä virheelle 404 page not found.
Python, JavaScript ja Java kuuluvat TikTokin API for Business -SDK:hon, jonka endpoint-luettelossa ei ole yhtään /business/-endpointia.
Allekirjoitus on jokaisen webhookin Tiktok-Signature-otsakkeessa. Se lasketaan aikaleimasta, pisteestä ja rungosta, avaimena sovelluksen salaisuus.
Mitä jokainen TikTok API -kutsu tarvitsee?
Samat viisi asiaa tehtävästä riippumatta:
- Perus-URL https://business-api.tiktok.com/
open_api/v1.3, jonka polku päättyy kauttaviivaan, esimerkiksi /business/video/list/. - Tilin käyttötoken Access-Token-otsakkeessa, uusittuna ennen kuin sen 24 tunnin voimassaolo päättyy.
business_ideli tilinopen_id: GET-kutsussa kyselymerkkijonossa, POST-kutsussa JSON-rungossa.- Lista- ja objektiparametrit GET-kutsuissa, kuten fields ja filters, lähetettynä JSON-tekstinä: fields=["
item_id","caption"]. - Vastauksen code-kentän tarkistus, sillä TikTok lähettää virheet, kuten 40002 tai 40100, HTTP 200:lla, ja data on mukana vain, kun code on 0.
Miten käsittelet TikTokin virhevastauksen Pythonissa?
Pienellä asiakasohjelmalla, joka asettaa business_id:n sinne, missä kukin metodi sitä odottaa, palauttaa datan, kun code on 0, ja muuten nostaa TikTokErrorin. Rajoitettu kutsu toistetaan TikTokin 5 minuutin tauon jälkeen, koska 40100 tarkoittaa, että TikTok hylkäsi kutsun. Palvelinvirhe 5xx toistetaan vain GET-kutsuissa, sillä julkaisu, joka päättyi palvelinvirheeseen, on saattanut silti mennä TikTokille perille. Tarvitset requests-kirjaston, ja myöhemmät Python-esimerkit käyttävät tätä samaa ohjelmaa:
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"])Miten käsittelet sen Node.js:ssä?
Sama asiakasohjelma Node.js 18:n ja uudempien versioiden sisäänrakennetulla fetchillä, jota ei tarvitse asentaa. Se koodaa listaparametrit JSON-muotoon GET-kutsuissa, asettaa business_id:n runkoon POST-kutsuissa ja säilyttää TikTokin code-arvon virheessä, jotta kutsuja voi erottaa 40102:n tai 40105:n, eli tokenongelman, 40001:stä, eli puuttuvasta oikeudesta:
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);Miten julkaiset videon URL-osoitteesta ja tarkistat sen tilan?
POST /business/video/publish/ video_url:n ja post_info:n kanssa, minkä jälkeen kysytään /business/publish/status/-polusta share_id:llä publish_id-kenttänä. Silmukka pysähtyy, kun tila on FAILED, ja TikTokin ilmoittama syy kerrotaan. Kun tila on PUBLISH_COMPLETE, odotetaan edelleen, kunnes post_ids saapuu, mikä TikTokin mukaan voi kestää vielä jopa kolme minuuttia. video_url:n täytyy sijaita domainissa tai URL-etuliitteessä, jonka sovellus on vahvistanut:
# 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);Miten julkaiset kuvia?
Lue ensin tilin sallitut asetukset ja tee sitten POST /business/photo/publish/. Kuvajulkaisu vaatii privacy_level-kentän, jonka arvon täytyy olla yksi /business/video/settings/-polun privacy_level_options-arvoista. Jos comment_disabled on siellä tosi, myös disable_comment on oltava tosi. Palautettua share_id:tä seurataan samalla odotusfunktiolla kuin videota:
# 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);Miten listaat tilin videot?
GET /business/video/list/ halutuilla kentillä, joihin item_id kuuluu, enintään 20 julkaisua sivulla uusimmasta alkaen. Anna palautettu cursor, UTC-aikaleima millisekunteina, niin kauan kuin has_more on tosi, ja varaudu lyhyisiin sivuihin: TikTokin luottamus- ja turvallisuussäännöt voivat palauttaa vähemmän kuin max_count ennen kuin lista päättyy.
# 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);Miten luet kommentit ja vastaat niihin?
GET /business/comment/list/ palauttaa julkaisun item_id:n video_id-kentässä enintään 30 kommenttia sivulla, ja POST /business/comment/reply/create/ vastaa yhteen niistä julkisesti enintään 1 200 merkin tekstillä. Esimerkki vastaa päätason julkisiin kommentteihin, joihin ei ole vielä vastauksia, ohittaa tilin omat kommentit ja jättää sanamuodon funktiolle, jonka kirjoitat itse, sillä TikTok voi piilottaa lähes samanlaiset lähellä toisiaan lähetetyt kommentit roskapostina:
# 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);Miten luet tilin tilastot?
GET /business/get/ kentillä fields-parametrissa ja UTC-päivämäärävälillä, enintään 60 päivää. followers_count tulee kahdesti: nykyinen kokonaismäärä data-kentän yläosassa ja kunkin päivän määrä metrics-kentässä päivän video_views-, profile_views-, likes-, comments- ja shares-arvojen rinnalla. Esimerkki päättyy eiliseen, sillä päivittäiset luvut saapuvat 24–48 tuntia myöhässä:
# 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);Miten varmistat webhookin allekirjoituksen?
Laske uudelleen HMAC-SHA256 t-arvosta, pisteestä ja raakarungosta, avaimena sovelluksen salaisuus, vertaa sitä s-arvoon vakioajassa ja tarkista, että t on tuore. Lue runko tavuina ennen kuin mikään jäsentää sen, vastaa heti 200 ja kirjaa x-tt-logid, kun tarkistus epäonnistuu. Flask Pythonissa ja Node.js:n sisäänrakennettu http-moduuli:
# 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);Miten teet samat tehtävät easyCoexistencen kautta?
Työkalukutsuina Claudesta, ChatGPT:stä tai muusta MCP-asiakkaasta, joka on yhdistetty osoitteeseen https://easycoexistence.com/api/mcp. Jokainen kutsu ottaa account_id:n list_social_accounts-työkalulta. easyCoexistence lähettää medialinkkisi TikTokille omalla vahvistetulla URL-etuliitteellään, seuraa jokaista julkaisua, kunnes TikTok suorittaa tai hylkää sen, ja uusii tokenin. Hylätty kutsu palautuu TikTokin koodilla ja viestillä:
// 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/" }Miten oma koodisi käyttää easyCoexistenceen yhdistettyä tiliä?
Hae tilin tunnukset jokaista tehtävää varten Partner API:sta ja anna ne samalle asiakasohjelmalle. GET /channels/{id}?credentials=1 avaimella ec_live_ palauttaa kentät api_base ja business_id, ajantasaisen access_tokenin sekä token_expires_at-kentän, tai tyhjän tokenin huomautuksen kanssa, jos kanava pitää yhdistää uudelleen. Luku-, vastaus- ja tilastokutsut ajetaan sitten omasta koodistasi, kun taas julkaisut kulkevat POST /channels/{id}/posts- tai publish_tiktok_post-kutsun kautta, jotka reitittävät median vahvistetun etuliitteen kautta:
# 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);Yleiset virheet
- Datan lukeminen ilman code-tarkistusta. Vastaus voi olla HTTP 200, code 40002 ja ilman dataa, joten puuttuva kenttä on usein virhe, jonka koodi ohitti.
- Lopun kauttaviivan pudottaminen. TikTokin polut päättyvät /-merkkiin, ja sen palautuskoodiliitteessä /tt_user/oauth2/refresh_token ilman sitä on kutsu, joka päättyy virheeseen HTTP 404 page not found.
- Vastausten tunnisteiden ottaminen reply_list-kentästä Node.js:ssä. TikTokin viitteet määrittelevät reply_listin comment_id:n ja video_id:n numeroiksi, jotka JSON.parse voi pyöristää, kun taas /business/comment/reply/list/ palauttaa ne merkkijonoina.
- Kenttien lähettäminen pilkkulistana. API for Business haluaa JSON-tekstin, fields=["item_id","caption"], toisin kuin developers.tiktok.comin Display API, joka ottaa fields=open_id,union_id.
US$ 9:stä US$ 0,75:een yhteyttä kohden kuukaudessa, ja hinta laskee, kun lisäät yhteyksiä. Ensimmäiset 3 päivää ovat ilmaista kokeilua.
Usein kysytyt kysymykset
Onko TikTokilla virallinen Python- tai Node.js-SDK Accounts API:lle?
TikTokin API for Business -SDK on saatavilla Pythonille, JavaScriptille ja Javalle, mutta sen endpoint-luettelo kattaa mainokset, raportoinnin ja Business Centerin, eikä siinä ole yhtään /business/- tai /tt_user/-endpointia.
Miksi TikTok-kutsu palauttaa HTTP 200:n ilman dataa?
TikTok ilmoittaa virheet HTTP 200 -vastauksen code-kentässä. Lue code ja viesti: 40002 on parametrivirhe, 40001 puuttuva oikeus ja 40100 rajoitettu kutsu.
Mitä Python- ja Node.js-versioita nämä esimerkit tarvitsevat?
Python 3.9 tai uudempi requests-kirjastolla sekä Flask webhookia varten, ja Node.js 18 tai uudempi, jonka sisäänrakennettu fetch ja node:crypto kattavat loput.
Voinko kutsua TikTok API:a selaimesta?
Pidä kutsut palvelimellasi. TikTokin tokenin tyyppi on Bearer, jolloin kuka tahansa tokenin haltija voi käyttää sitä, ja tokenin päätepisteet tarvitsevat sovelluksesi client_secret-arvon.
Lue lisää
Yhdistä ensimmäinen kanavasi kahdessa minuutissa.
Ei alustojen tarkastuksia odotettavana. Yhdistä WhatsApp, Instagram, TikTok tai jokin muu kanava, pyydä sitten tekoälyäsi julkaisemaan, vastaamaan tai raportoimaan ja seuraa, kun se hoitaa homman.
- 3 päivää ilmaiseksi
- Peruuta milloin tahansa
- Vain viralliset API:t
- Valvottu 24/7
Vahvistettu