Se connecterCommencer l’essai gratuit
easyCoexistence API officielles

API TikTok en Python et Node.js : exemples fonctionnels

L'API for Business de TikTok fonctionne depuis Python ou Node.js avec de simples requêtes HTTPS : envoyez chaque appel à https://business-api.tiktok.com/open_api/v1.3 avec le token du compte dans l'en-tête Access-Token et son open_id comme business_id. TikTok répond à la plupart des appels avec un HTTP 200 et un champ code, valant 0 en cas de succès : vérifiez-le, et attendez 5 minutes en cas de 40100.

easyCoexistence donne à Claude, ChatGPT ou à votre propre code les mêmes tâches TikTok sous forme d'outils, de publish_tiktok_post et reply_to_comment jusqu'à get_social_insights, et fournit à vos scripts un token à jour via get_social_credentials ou l'API partenaire.

HTTP 200

Statut de la plupart des réponses TikTok, erreurs comprises ; seul un code de 0 dans le corps signifie que l'appel a réussi.

40100

Code d'erreur pour un appel limité : TikTok demande une pause de 5 minutes après une limite par minute, et jusqu'à 00:00 UTC après une limite quotidienne.

5xx

Erreurs serveur, après lesquelles TikTok suggère d'attendre environ 5 minutes avant de rappeler.

Final /

Les chemins se terminent par une barre oblique ; TikTok donne /tt_user/oauth2/refresh_token sans elle comme cause d'une erreur 404 page not found.

3 languages

Python, JavaScript et Java dans le SDK API for Business de TikTok, dont la liste d'endpoints ne comporte aucun endpoint /business/.

HMAC-SHA256

Signature dans l'en-tête Tiktok-Signature de chaque webhook, calculée sur le timestamp, un point et le corps, avec la clé secrète de l'application.

De quoi chaque appel à l'API TikTok a-t-il besoin ?

Les mêmes cinq éléments, quelle que soit la tâche :

  • L'URL de base https://business-api.tiktok.com/open_api/v1.3, avec un chemin qui se termine par une barre oblique, comme /business/video/list/.
  • Le token d'accès du compte, dans un en-tête Access-Token, renouvelé avant l'expiration de ses 24 heures.
  • business_id, l'open_id du compte : dans la chaîne de requête en GET, dans le corps JSON en POST.
  • Les paramètres de liste et d'objet en GET, comme fields et filters, envoyés sous forme de texte JSON : fields=["item_id","caption"].
  • Une vérification du code dans la réponse, car TikTok renvoie des erreurs comme 40002 ou 40100 avec un HTTP 200 et des données seulement lorsque code vaut 0.

Comment gérer l'enveloppe d'erreur de TikTok en Python ?

Avec un petit client qui place business_id là où chaque méthode l'attend, renvoie les données quand code vaut 0 et lève une TikTokError dans le cas contraire. Il rejoue un appel limité après la pause de 5 minutes de TikTok, car 40100 signifie que TikTok a refusé l'appel, et ne rejoue une erreur 5xx qu'en GET, parce qu'une publication qui s'est terminée par une erreur serveur a pu tout de même atteindre TikTok. Il nécessite requests, et les exemples Python suivants le réutilisent :

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

Et en Node.js ?

Le même client, avec fetch intégré à Node.js 18 et versions ultérieures, sans rien à installer. Il encode les paramètres de liste en JSON pour GET, place business_id dans le corps pour POST, et conserve le code de TikTok dans l'erreur, afin que l'appelant puisse distinguer 40102 ou 40105, un problème de token, de 40001, une autorisation manquante :

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

Comment publier une vidéo par URL et vérifier son statut ?

POST /business/video/publish/ avec video_url et post_info, puis interrogez /business/publish/status/ avec le share_id comme publish_id. La boucle s'arrête sur FAILED avec le motif donné par TikTok, et sur PUBLISH_COMPLETE elle continue d'attendre jusqu'à l'arrivée de post_ids, ce qui, selon TikTok, peut prendre encore jusqu'à trois minutes. video_url doit se trouver sur un domaine ou un préfixe d'URL vérifié pour votre application :

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

Comment publier des photos ?

Lisez d'abord les paramètres autorisés du compte, puis POST /business/photo/publish/. Une publication de photo exige privacy_level, qui doit être l'une des valeurs de privacy_level_options renvoyées par /business/video/settings/ ; et lorsque comment_disabled vaut true à cet endroit, disable_comment doit valoir true également. Le share_id renvoyé se suit avec la même fonction d'attente que pour une vidéo :

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

Comment lister les vidéos d'un compte ?

GET /business/video/list/ avec les champs voulus, dont item_id, jusqu'à 20 publications par page, de la plus récente à la plus ancienne. Passez le cursor renvoyé, un horodatage UTC en millisecondes, tant que has_more vaut true, et attendez-vous à des pages courtes : les règles de confiance et de sécurité de TikTok peuvent renvoyer moins de max_count avant la fin de la liste.

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


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

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

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

Comment lire les commentaires et y répondre ?

GET /business/comment/list/ avec l'item_id de la publication comme video_id renvoie jusqu'à 30 commentaires par page, et POST /business/comment/reply/create/ répond à l'un d'eux publiquement avec jusqu'à 1 200 caractères de texte. L'exemple répond aux commentaires publics de premier niveau qui n'ont pas encore de réponse, ignore ceux du compte et confie la formulation à une fonction que vous écrivez, car TikTok peut masquer comme spam des commentaires largement semblables publiés à peu de distance les uns des autres :

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

Comment lire les statistiques du compte ?

GET /business/get/ avec les noms de champs dans fields et une plage de dates UTC de 60 jours au maximum. followers_count apparaît deux fois : le total actuel en haut de data, et le total de chaque jour dans metrics, à côté des video_views, profile_views, likes, comments et shares de ce jour. L'exemple se termine à la veille, car les comptages quotidiens arrivent avec 24 à 48 heures de retard :

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

Comment vérifier la signature d'un webhook ?

Recalculez un HMAC-SHA256 de la valeur t, d'un point et du corps brut, avec la clé secrète de l'application ; comparez-le à s en temps constant, et vérifiez que t est récent. Lisez le corps en octets avant toute analyse, répondez 200 immédiatement, et journalisez x-tt-logid lorsqu'une vérification échoue. Flask pour Python, et le module http intégré pour 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);

Comment exécuter les mêmes tâches via easyCoexistence ?

Sous forme d'appels d'outils depuis Claude, ChatGPT ou un autre client MCP connecté à https://easycoexistence.com/api/mcp, chacun prenant l'account_id renvoyé par list_social_accounts. easyCoexistence envoie vos liens média à TikTok via son propre préfixe d'URL vérifié, suit chaque publication jusqu'à ce que TikTok la termine ou l'échoue, et renouvelle le token, tandis qu'un appel refusé revient avec le code et le message de 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/" }

Comment votre propre code utilise-t-il un compte connecté à easyCoexistence ?

Récupérez les identifiants du compte pour chaque tâche depuis l'API partenaire, et transmettez-les au même client. GET /channels/{id}?credentials=1 avec votre clé ec_live_ renvoie api_base, business_id et un access_token actuel avec token_expires_at, ou un token nul accompagné d'une note lorsque le canal doit être reconnecté. Les lectures, réponses et statistiques s'exécutent alors depuis votre propre code, tandis que les publications passent par POST /channels/{id}/posts ou publish_tiktok_post, qui acheminent les médias par le préfixe vérifié :

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

Erreurs courantes

  • Lire les données sans vérifier le code. Une réponse peut porter HTTP 200, le code 40002 et aucune donnée du tout ; un champ absent est donc souvent une erreur que le code a ignorée.
  • Oublier la barre oblique finale. Les chemins de TikTok se terminent par /, et son annexe des codes de retour donne /tt_user/oauth2/refresh_token, sans la barre oblique, comme appel qui aboutit à une erreur HTTP 404 page not found.
  • Prendre les identifiants de réponse depuis reply_list en Node.js. La référence de TikTok déclare comment_id et video_id de reply_list comme des nombres, que JSON.parse peut arrondir ; /business/comment/reply/list/ les renvoie sous forme de chaînes.
  • Envoyer fields sous forme de liste séparée par des virgules. L'API for Business attend du texte JSON, fields=["item_id","caption"], contrairement à l'API Display sur developers.tiktok.com, qui accepte fields=open_id,union_id.
Faire cela avec EasyCoexistence

De US$ 9 à US$ 0,75 par connexion et par mois, à mesure que vous ajoutez des connexions, avec les 3 premiers jours gratuits.

Questions fréquemment posées

L'API TikTok propose-t-elle un SDK officiel en Python ou Node.js pour l'API Accounts ?

Le SDK API for Business de TikTok existe en Python, JavaScript et Java, mais sa liste d'endpoints couvre les publicités, le reporting et le Business Center, sans endpoint /business/ ni /tt_user/.

Pourquoi un appel TikTok renvoie-t-il un HTTP 200 sans données ?

TikTok signale les erreurs dans le champ code d'une réponse HTTP 200. Lisez code et message : 40002 est une erreur de paramètre, 40001 une autorisation manquante et 40100 un appel limité.

Quelles versions de Python et Node.js ces exemples demandent-ils ?

Python 3.9 ou ultérieur avec requests, plus Flask pour le webhook, et Node.js 18 ou ultérieur, dont fetch et node:crypto intégrés couvrent le reste.

Puis-je appeler l'API TikTok depuis le navigateur ?

Gardez les appels sur votre serveur. Le type de token de TikTok est Bearer, utilisable par quiconque le détient, et les endpoints de token exigent le client_secret de votre application.

Poursuivre la lecture

Connectez votre premier canal en deux minutes.

Aucune validation de plateforme à attendre. Connectez WhatsApp, Instagram, TikTok ou un autre canal, puis demandez à votre IA de publier, de répondre ou de faire un rapport, et regardez-la travailler.

  • 3 jours gratuits
  • Résiliable à tout moment
  • API officielles uniquement
  • Supervisé 24/7

Vérifié le