Zaloguj sięRozpocznij bezpłatny okres próbny
easyCoexistence Oficjalne API

Instagram API w Pythonie i Node.js: działające przykłady

Instagram API wymaga wyłącznie HTTPS, więc do jego obsługi wystarczą requests w Pythonie i wbudowany fetch w Node.js: POST /<IG_ID>/media, a następnie media_publish, publikuje treść; /<IG_MEDIA_ID>/comments oraz /<IG_COMMENT_ID>/replies odczytują komentarze i na nie odpowiadają; /insights zwraca metryki; a webhook sprawdza się przez HMAC-SHA256 surowej treści żądania. Każdy błąd zawiera kod i subkod, które decydują, czy ponowna próba ma sens.

easyCoexistence uruchamia te same zadania jako narzędzia MCP dla Claude, ChatGPT lub Twojego własnego agenta, z tokenem trzymanym po swojej stronie: publish_instagram_post, reply_to_comment, get_social_insights i set_social_webhook_destination, na oficjalnym API Meta.

v26.0

Najnowsza wersja Graph API, wprowadzona 29 lipca 2026; v25.0 pozostaje dostępna do 29 lipca 2028.

Once a minute

Jak często Meta sugeruje sprawdzać status_code kontenera wideo, nie dłużej niż przez 5 minut.

50

Najwięcej komentarzy, jakie zwraca jedno żądanie GET /<IG_MEDIA_ID>/comments; odpowiedzi pojawiają się wyłącznie po rozwinięciu pól.

2207008

Tymczasowy błąd publikacji, przy którym Meta zaleca 1 do 2 ponowień w ciągu od 30 sekund do 2 minut.

sha256=

Prefiks w X-Hub-Signature-256, poprzedzający HMAC-SHA256 payloadu kluczowanego sekretem aplikacji.

Czego potrzebują przykłady?

Środowiska uruchomieniowego, tokenu i czterech wartości. Przykłady wywołują Instagram API przez Instagram Login na graph.instagram.com; aplikacja Unified Login używa tych samych ścieżek z ID konta, na hoście Graph z Facebook Login i tokenem Business Integration System User. Python wymaga pakietu requests oraz Flask do webhooka, a Node.js w wersji 18 lub nowszej do wbudowanego fetch.

  • GRAPH: https://graph.instagram.com/v26.0, host i wersja API.
  • IG_ID: ID konta profesjonalnego, user_id, który zwraca GET /me.
  • TOKEN: długoterminowy token dostępu Instagram User, przechowywany na serwerze.
  • APP_SECRET i VERIFY_TOKEN: do sprawdzania żądań webhooka.

Jak wywoływać API i obsługiwać błędy w Pythonie?

Przez jedną funkcję pomocniczą, z której korzystają poniższe przykłady w Pythonie. Wysyła token jako access_token, zgłasza MetaError z kodem, subkodem i fbtrace_id Meta i ponawia wyłącznie to, co Meta nazywa tymczasowym: kody 1 i 2, kody limitowania 4, 17 i 80002 oraz subkody 2207001, 2207003, 2207008 i 2207032. Kod 4 z subkodem 2207051 oznacza podejrzenie spamu, więc działanie zatrzymuje się od razu.

Python: the shared helper (requests)
import json
import time

import requests

GRAPH = "https://graph.instagram.com/v26.0"
IG_ID = "<IG_ID>"  # user_id from GET /me
TOKEN = "<TOKEN>"  # long-lived Instagram User access token, server side only

RETRY_CODES = {1, 2, 4, 17, 80002}
RETRY_SUBCODES = {2207001, 2207003, 2207008, 2207032}


class MetaError(Exception):
    def __init__(self, error: dict, status: int):
        super().__init__(error.get("message", f"HTTP {status}"))
        self.code = error.get("code")
        self.subcode = error.get("error_subcode")
        self.fbtrace_id = error.get("fbtrace_id")  # log it: Meta support asks for it

    @property
    def needs_new_token(self) -> bool:
        return self.code in (102, 190)

    @property
    def retryable(self) -> bool:
        if self.subcode == 2207051:  # code 4 with this subcode is suspected spam: stop
            return False
        return self.code in RETRY_CODES or self.subcode in RETRY_SUBCODES


def wait_seconds(resp) -> int:
    """estimated_time_to_regain_access from X-Business-Use-Case-Usage, at least 60 s."""
    try:
        usage = json.loads(resp.headers.get("X-Business-Use-Case-Usage", "{}"))
        minutes = max(e.get("estimated_time_to_regain_access", 0) for v in usage.values() for e in v)
    except (ValueError, AttributeError, TypeError):
        minutes = 0
    return max(60, int(minutes) * 60)


def graph(method: str, path: str, attempts: int = 3, **params) -> dict:
    if attempts < 1:
        raise ValueError("attempts must be at least 1")
    params["access_token"] = TOKEN
    for attempt in range(1, attempts + 1):
        resp = requests.request(method, f"{GRAPH}/{path}", params=params, timeout=30)
        try:
            data = resp.json()
        except ValueError:
            data = {}
        if resp.ok and "error" not in data:
            return data
        err = MetaError(data.get("error", {}), resp.status_code)
        if not err.retryable or attempt == attempts:
            raise err
        time.sleep(wait_seconds(resp))

Jak wywoływać API i obsługiwać błędy w Node.js?

Tą samą funkcją pomocniczą, dla Node.js 18 lub nowszego, korzystającą z fetch i bez zależności. Wywołanie objęte limitem czeka na estimated_time_to_regain_access, czyli liczbę minut podaną przez Meta w nagłówku X-Business-Use-Case-Usage, a bez niego 60 sekund, ponieważ Meta liczy wywołania wykonane w trakcie limitu. needsNewToken oznacza kody 190 i 102, których żadne ponowienie nie naprawi.

Node.js: the shared helper (fetch, ES module)
const GRAPH = "https://graph.instagram.com/v26.0";
const IG_ID = process.env.IG_ID; // user_id from GET /me
const TOKEN = process.env.TOKEN; // long-lived Instagram User access token, server side only

const RETRY_CODES = new Set([1, 2, 4, 17, 80002]);
const RETRY_SUBCODES = new Set([2207001, 2207003, 2207008, 2207032]);

export class MetaError extends Error {
  constructor(error, status) {
    super(error.message ?? `HTTP ${status}`);
    this.code = error.code;
    this.subcode = error.error_subcode;
    this.fbtraceId = error.fbtrace_id; // log it: Meta support asks for it
  }
  get needsNewToken() {
    return this.code === 190 || this.code === 102;
  }
  get retryable() {
    if (this.subcode === 2207051) return false; // code 4 with this subcode is suspected spam: stop
    return RETRY_CODES.has(this.code) || RETRY_SUBCODES.has(this.subcode);
  }
}

export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

// estimated_time_to_regain_access from X-Business-Use-Case-Usage, at least 60 s
function waitMs(res) {
  try {
    const usage = JSON.parse(res.headers.get("x-business-use-case-usage") ?? "{}");
    const minutes = Math.max(0, ...Object.values(usage).flat().map((e) => e.estimated_time_to_regain_access ?? 0));
    return Math.max(60, minutes * 60) * 1000;
  } catch {
    return 60_000;
  }
}

export async function graph(method, path, params = {}, attempts = 3) {
  const url = new URL(`${GRAPH}/${path}`);
  for (const [key, value] of Object.entries({ ...params, access_token: TOKEN })) {
    url.searchParams.set(key, String(value));
  }
  for (let attempt = 1; attempt <= attempts; attempt++) {
    const res = await fetch(url, { method });
    const data = await res.json().catch(() => ({}));
    if (res.ok && !data.error) return data;
    const err = new MetaError(data.error ?? {}, res.status);
    if (!err.retryable || attempt === attempts) throw err;
    await sleep(waitMs(res));
  }
  throw new Error("attempts must be at least 1");
}

Jak opublikować zdjęcie i Reel w Pythonie?

Oba przypadki idą według przepływu kontenera. Kontener zdjęcia jest gotowy od razu, więc media_publish następuje zaraz po nim. Wideo Reela jest najpierw przetwarzane: funkcja sprawdza status_code co minutę, przez co najwyżej 5 minut, zgodnie z sugestią Meta, publikuje po FINISHED i zatrzymuje się przy ERROR lub EXPIRED. Obrazy muszą być w formacie JPEG, a media muszą znajdować się pod publicznym URL.

Python: a photo and a Reel
# Uses graph(), IG_ID and time from the helper above
def publish_photo(image_url: str, caption: str) -> str:
    """A JPEG at a public URL: create the container, then publish it."""
    container = graph("POST", f"{IG_ID}/media", image_url=image_url, caption=caption)
    return graph("POST", f"{IG_ID}/media_publish", creation_id=container["id"])["id"]


def publish_reel(video_url: str, caption: str) -> str:
    """A Reel: publish once Meta has processed the video, checking once a minute."""
    cid = graph("POST", f"{IG_ID}/media", media_type="REELS", video_url=video_url, caption=caption)["id"]
    for _ in range(5):  # Meta: once a minute, for no more than 5 minutes
        time.sleep(60)
        status = graph("GET", cid, fields="status_code")["status_code"]
        if status == "FINISHED":
            return graph("POST", f"{IG_ID}/media_publish", creation_id=cid)["id"]
        if status in ("ERROR", "EXPIRED"):
            raise RuntimeError(f"Container {cid} ended as {status}")
    raise TimeoutError(f"Container {cid} is still processing: check it again later")

Jak opublikować zdjęcie i Reel w Node.js?

Te same dwie funkcje, każda zwraca identyfikator nowego medium. Kontener, który po pięciu sprawdzeniach nadal jest w stanie IN_PROGRESS, pozostaje ważny do 24 godzin od utworzenia, więc błąd każe sprawdzić go później, co pozwala uniknąć tworzenia drugiego kontenera przy limicie 400 dziennie na konto.

Node.js: a photo and a Reel
// Uses graph(), sleep() and IG_ID from the helper above
export async function publishPhoto(imageUrl, caption) {
  const { id } = await graph("POST", `${IG_ID}/media`, { image_url: imageUrl, caption });
  return (await graph("POST", `${IG_ID}/media_publish`, { creation_id: id })).id;
}

export async function publishReel(videoUrl, caption) {
  const { id } = await graph("POST", `${IG_ID}/media`, { media_type: "REELS", video_url: videoUrl, caption });
  for (let check = 0; check < 5; check++) {
    await sleep(60_000); // Meta: once a minute, for no more than 5 minutes
    const { status_code: status } = await graph("GET", id, { fields: "status_code" });
    if (status === "FINISHED") return (await graph("POST", `${IG_ID}/media_publish`, { creation_id: id })).id;
    if (status === "ERROR" || status === "EXPIRED") throw new Error(`Container ${id} ended as ${status}`);
  }
  throw new Error(`Container ${id} is still processing: check it again later`);
}

Jak odczytywać komentarze i odpowiadać w Pythonie?

GET /<IG_MEDIA_ID>/comments zwraca komentarze najwyższego poziomu, od najnowszego, do 50 na żądanie, a POST /<IG_COMMENT_ID>/replies publikuje publiczną odpowiedź na jeden z nich. Funkcja pobiera tekst każdej odpowiedzi z podanej przez Ciebie funkcji zwrotnej i pomija komentarze, dla których ta zwróci pusty wynik. Na ukryte komentarze nie można odpowiedzieć, a odpowiedź na odpowiedź trafia do komentarza najwyższego poziomu.

Python: read comments and reply
# Uses graph() from the helper above
def reply_to_comments(media_id: str, write_reply) -> int:
    """Reply in public to each comment write_reply returns text for."""
    page = graph("GET", f"{media_id}/comments", fields="id,text,username,timestamp")
    sent = 0
    for comment in page.get("data", []):
        text = write_reply(comment)
        if text:
            graph("POST", f"{comment['id']}/replies", message=text)
            sent += 1
    return sent


# Example: reply to questions about price
reply_to_comments("<IG_MEDIA_ID>", lambda c: "Prices are in our bio link." if "price" in c["text"].lower() else None)

Jak odczytywać komentarze i odpowiadać w Node.js?

Ta sama pętla w Node.js. Oba wywołania wymagają uprawnień instagram_business_basic i instagram_business_manage_comments, a pole username potrzebuje drugiego. Aby zamiast tego odpowiedzieć prywatnie, POST /<IG_ID>/messages z recipient.comment_id wysyła komentującemu jedną wiadomość prywatną, w ciągu 7 dni od komentarza, a kolejna czeka, aż odpowie.

Node.js: read comments and reply
// Uses graph() from the helper above
// Reply in public to each comment writeReply returns text for
export async function replyToComments(mediaId, writeReply) {
  const { data = [] } = await graph("GET", `${mediaId}/comments`, { fields: "id,text,username,timestamp" });
  let sent = 0;
  for (const comment of data) {
    const text = writeReply(comment);
    if (text) {
      await graph("POST", `${comment.id}/replies`, { message: text });
      sent++;
    }
  }
  return sent;
}

// Example: reply to questions about price
await replyToComments("<IG_MEDIA_ID>", (c) => (/price/i.test(c.text) ? "Prices are in our bio link." : null));

Jak odczytywać statystyki w Pythonie?

Statystyki konta przyjmują period=day z metric_type=total_value, a każda metryka zwraca następnie total_value.value; statystyki posta zwracają values[0].value. Przykład prosi o reach, views i accounts_engaged dla konta oraz o reach, views, likes, comments, saved i shares dla posta lub Reela, co referencje Meta podają dla obu. Metryka bez danych jest pomijana, a nie zwracana jako 0.

Python: account and post insights
# Uses graph() and IG_ID from the helper above
def account_insights() -> dict:
    """Reach, views and accounts engaged over the last 24 hours."""
    data = graph("GET", f"{IG_ID}/insights", metric="reach,views,accounts_engaged",
                 period="day", metric_type="total_value")["data"]
    return {m["name"]: m["total_value"]["value"] for m in data}


def post_insights(media_id: str) -> dict:
    """Totals for one post or Reel."""
    data = graph("GET", f"{media_id}/insights", metric="reach,views,likes,comments,saved,shares")["data"]
    return {m["name"]: m["values"][0]["value"] for m in data}

Jak odczytywać statystyki w Node.js?

Te same dwa żądania w Node.js, każde zwraca obiekt kluczowany nazwą metryki. Żadne nie wysyła parametru breakdown: Meta ostrzega, że żądanie podziału, którego metryka nie obsługuje, kończy się błędem unknown, a dane statystyk mogą opóźniać się do 48 godzin, więc ostatnie posty warto odczytać ponownie później.

Node.js: account and post insights
// Uses graph() and IG_ID from the helper above
// Reach, views and accounts engaged over the last 24 hours
export async function accountInsights() {
  const { data } = await graph("GET", `${IG_ID}/insights`, {
    metric: "reach,views,accounts_engaged",
    period: "day",
    metric_type: "total_value",
  });
  return Object.fromEntries(data.map((m) => [m.name, m.total_value?.value]));
}

// Totals for one post or Reel
export async function postInsights(mediaId) {
  const { data } = await graph("GET", `${mediaId}/insights`, { metric: "reach,views,likes,comments,saved,shares" });
  return Object.fromEntries(data.map((m) => [m.name, m.values?.[0]?.value]));
}

Jak weryfikować webhook w Pythonie?

Za pomocą Flask, w dwóch trasach na jednej ścieżce. GET odpowiada na żądanie weryfikacyjne Meta: gdy hub.mode ma wartość subscribe, a hub.verify_token się zgadza, zwraca hub.challenge jako zwykły tekst, w przeciwnym razie 403. POST oblicza sha256= oraz HMAC-SHA256 surowej treści z sekretem aplikacji, porównuje z X-Hub-Signature-256 w stałym czasie i odpowiada 200, zanim rozpocznie się jakakolwiek powolna praca.

Python: webhook verification and signature check (Flask)
import hashlib
import hmac
import json
import os
from queue import Queue

from flask import Flask, abort, request

app = Flask(__name__)
VERIFY_TOKEN = os.environ["VERIFY_TOKEN"]
APP_SECRET = os.environ["APP_SECRET"].encode()
jobs: Queue = Queue()  # swap for your own job queue


@app.get("/webhooks/instagram")
def verify():
    """Meta's verification request: send hub.challenge back when the token matches."""
    args = request.args
    if args.get("hub.mode") == "subscribe" and args.get("hub.verify_token") == VERIFY_TOKEN:
        return args.get("hub.challenge", ""), 200, {"Content-Type": "text/plain"}
    abort(403)


@app.post("/webhooks/instagram")
def receive():
    """An event: check X-Hub-Signature-256 over the raw bytes, then answer at once."""
    raw = request.get_data()
    expected = b"sha256=" + hmac.new(APP_SECRET, raw, hashlib.sha256).hexdigest().encode()
    if not hmac.compare_digest(expected, request.headers.get("X-Hub-Signature-256", "").encode()):
        abort(401)
    for entry in json.loads(raw).get("entry", []):
        jobs.put(entry)  # slow work happens elsewhere; Meta wants a quick 200
    return "", 200

Jak weryfikować webhook w Node.js?

Za pomocą wbudowanego modułu http, bez frameworka. Treść jest zbierana jako surowe bajty, zanim cokolwiek ją sparsuje, ponieważ sparsowana i ponownie zserializowana treść nie zgadza się już z podpisem, który obliczyła Meta. Meta ponawia nieudane powiadomienie przez do 36 godzin, więc handler powinien też pomijać zdarzenia już przetworzone.

Node.js: webhook verification and signature check (node:http)
import crypto from "node:crypto";
import http from "node:http";

const { VERIFY_TOKEN, APP_SECRET } = process.env;
const PATH = "/webhooks/instagram";
const jobs = []; // swap for your own job queue

http
  .createServer((req, res) => {
    const url = new URL(req.url, "http://localhost");
    if (url.pathname !== PATH) return res.writeHead(404).end();

    if (req.method === "GET") {
      // Meta's verification request: send hub.challenge back when the token matches
      const ok =
        url.searchParams.get("hub.mode") === "subscribe" &&
        url.searchParams.get("hub.verify_token") === VERIFY_TOKEN;
      return res
        .writeHead(ok ? 200 : 403, { "Content-Type": "text/plain" })
        .end(ok ? url.searchParams.get("hub.challenge") ?? "" : "");
    }

    const chunks = [];
    req.on("data", (chunk) => chunks.push(chunk));
    req.on("end", () => {
      const raw = Buffer.concat(chunks); // the exact bytes Meta signed
      const expected = Buffer.from("sha256=" + crypto.createHmac("sha256", APP_SECRET).update(raw).digest("hex"));
      const given = Buffer.from(req.headers["x-hub-signature-256"] ?? "");
      if (given.length !== expected.length || !crypto.timingSafeEqual(given, expected)) {
        return res.writeHead(401).end();
      }
      res.writeHead(200).end(); // answer first, work after
      try {
        for (const entry of JSON.parse(raw.toString("utf8")).entry ?? []) jobs.push(entry);
      } catch {
        // not JSON: nothing to queue
      }
    });
  })
  .listen(3000);

Które błędy Meta powinien ponawiać kod?

Wyłącznie tymczasowe, ponieważ pozostałe zwracają tę samą odpowiedź, dopóki coś się nie zmieni: plik, URL, uprawnienie lub stan konta. Referencje błędów Meta podają działanie dla każdego kodu, który rozróżniają powyższe funkcje pomocnicze:

1, 2Temporary or downtime: wait, then retry
4, 17, 80002Throttling: wait for estimated_time_to_regain_access, then retry
4 with 2207051Suspected spam: stop, since a retry repeats the action
2207001, 2207003, 2207032Server error, download timeout or failed container: try again
2207008Container briefly missing: retry 1 to 2 times within 2 minutes
190, 102Token expired or invalid: refresh it while valid, or sign in again
10, 200 to 299Permission missing or removed: request it at sign-in
25 with 2207050Account restricted: the owner acts in the Instagram app
9 with 2207042Daily publishing limit: try again the next day
9004 with 2207052Media not fetched from the URL: fix the link

Jak uruchomić ten sam kod na danych uwierzytelniających easyCoexistence?

Nie uruchomisz go na tokenie easyCoexistence: tokeny Instagrama nie są nigdy wydawane (warunki Meta), więc get_social_credentials i GET /api/v1/channels/:id?credentials=1 w Partner API zwracają ID konta i bazę API bez tokena. Te same zadania działają zamiast tego jako narzędzia MCP, przez Claude, ChatGPT lub innego klienta MCP, a powyższe funkcje pomocnicze działają bez zmian na tokenie z Twojej własnej aplikacji Meta.

What get_social_credentials returns for an Instagram account
{
  "platform": "instagram",
  "graph_api_base": "https://graph.instagram.com/<VERSION>",
  "account_id_on_meta": "<IG_ID>",
  "access_token": null,
  "token_note": "Meta's terms do not allow handing this account's access token to other apps, so it is not shown. ..."
}

Jak wykonać te same zadania przez łącznik MCP?

Pytając asystenta albo wywołując narzędzia samodzielnie. publish_instagram_post tworzy i publikuje kontener, czekając na przetwarzanie wideo, albo planuje publikację przez scheduled_at do 90 dni naprzód; reply_to_comment odpowiada publicznie albo prywatnie w wiadomości prywatnej, gdy private ma wartość true; get_social_insights przekazuje nazwy metryk wprost do Meta; a set_social_webhook_destination przekazuje komentarze, wzmianki i wiadomości prywatne na Twój endpoint, podpisane nagłówkiem X-EC-Signature.

MCP tool calls for the same jobs
[
  {
    "name": "publish_instagram_post",
    "arguments": {
      "account_id": "<from list_social_accounts>",
      "type": "REELS",
      "video_url": "https://cdn.example.com/launch.mp4",
      "caption": "Launch day.",
      "scheduled_at": "2026-11-06T09:00:00-03:00"
    }
  },
  {
    "name": "list_social_comments",
    "arguments": { "account_id": "<ACCOUNT_ID>", "post_id": "<IG_MEDIA_ID>" }
  },
  {
    "name": "reply_to_comment",
    "arguments": { "account_id": "<ACCOUNT_ID>", "comment_id": "<IG_COMMENT_ID>", "text": "Prices are in our bio link." }
  },
  {
    "name": "get_social_insights",
    "arguments": {
      "account_id": "<ACCOUNT_ID>",
      "metrics": ["reach", "views", "accounts_engaged"],
      "period": "day",
      "params": { "metric_type": "total_value" }
    }
  },
  {
    "name": "set_social_webhook_destination",
    "arguments": { "account_id": "<ACCOUNT_ID>", "url": "https://hooks.example.com/instagram" }
  }
]

Typowe błędy

  • Haszowanie sparsowanego JSON. Meta podpisuje surowe bajty, więc parser ciała JSON frameworka psuje sprawdzenie X-Hub-Signature-256; zachowaj surową treść i dopiero potem ją sparsuj.
  • Ponowne wywołanie media_publish po przekroczeniu czasu bez sprawdzenia. Jeśli status_code kontenera ma wartość PUBLISHED, post jest już opublikowany.
  • Odczytywanie kodu 4 jako limitu bez subkodu. Z subkodem 2207051 oznacza, że Instagram podejrzewa spam, a ponowienie powtórzy działanie, które właśnie zostało ograniczone.
  • Wysyłanie sekretu aplikacji lub tokenu z kodu przeglądarki lub aplikacji mobilnej. Meta stwierdza, że żądania z sekretem aplikacji należą wyłącznie do kodu po stronie serwera.
Z EasyCoexistence zrobisz to

Od US$ 9 do US$ 0.75 za połączenie miesięcznie, spadając wraz z dodawaniem połączeń, z pierwszymi 3 dniami bezpłatnie.

Najczęściej zadawane pytania

Czy potrzebuję SDK do wywoływania Instagram API?

Nie. Każde wywołanie to żądanie HTTPS z tokenem dostępu, więc wystarczą requests w Pythonie albo fetch w Node.js, jak pokazują przykłady na tej stronie.

Dlaczego media_publish kończy się błędem zaraz po utworzeniu kontenera Reela?

Wideo nadal się przetwarza: błąd 9007 z subkodem 2207027. Sprawdzaj status_code kontenera co minutę i publikuj, gdy pokaże FINISHED.

Której wersji API powinien używać kod?

Tej, którą Meta nadal obsługuje: v26.0 jest najnowsza, a każda wersja działa co najmniej dwa lata. Wywołanie usuniętej wersji trafia na następną najstarszą dostępną.

Ile kosztuje easyCoexistence za dostęp do API dla konta Instagram?

Każde konto Instagram to jedno połączenie: od US$ 9 do US$ 0.75 za połączenie miesięcznie, spadając wraz z dodawaniem połączeń, z pierwszymi 3 dniami bezpłatnie.

Czytaj dalej

Połącz pierwszy kanał w dwie minuty.

Bez czekania na weryfikację przez platformy. Połącz WhatsApp, Instagram, TikTok lub inny kanał, a potem poproś swoją AI o opublikowanie posta, odpowiedź lub raport i zobacz, jak działa.

  • 3 dni za darmo
  • Rezygnacja w każdej chwili
  • Tylko oficjalne API
  • Monitorowanie 24/7

Zweryfikowano w