התחברותהתחילו תקופת ניסיון
easyCoexistence ממשקי API רשמיים

פרסום ב-Instagram, ב-TikTok וב-Facebook מ-Python דרך ממשק API אחד

עם easyCoexistence, קוד Python מפרסם ב-Instagram, Facebook, TikTok, YouTube ו-LinkedIn דרך ה-API הרשמי של כל רשת. כל חשבון נכנס פעם אחת דרך קישור מאוחסן; הסקריפט שלכם מביא אחר כך אסימון טרי ל-TikTok, YouTube או LinkedIn בקריאת GET אחת, ואילו הקריאות ל-Instagram ול-Facebook עוברות דרך כלי ה-MCP של easyCoexistence, שמחזיקים את האסימון. כלי MCP נותנים לסוכן Python את אותם חשבונות.

1,000 bytes

כמה טקסט יכול לשאת הודעת DM אחת ב-Instagram דרך ה-API, בספירה ב-UTF-8, כך שאימוג'ים תופסים יותר מקום.

24 hours

כמה זמן תקף אסימון הגישה של TikTok API for Business, ואסימון הרענון שלו נשאר תקף שנה.

1 hour

כמה זמן תקף אסימון הגישה של משתמש Google, מסוג שכל קריאת YouTube API נושאת.

OAuthClientProvider

מטפל ה-OAuth של MCP Python SDK, שרושם את הלקוח, מריץ את הכניסה עם PKCE ומרענן אסימונים.

1 attempt

אירועי תגובה, אזכור והודעת DM שמועברים אליכם נשלחים פעם אחת בלבד ואינם נשמרים, לכן יש לאשר כל אחד מיד.

איך Python מקבל אסימון עבור Instagram, Facebook, TikTok, YouTube או LinkedIn?

דרך סשן חיבור ב-Partner API של easyCoexistence, מאומת במפתח ec_live_ שלכם. קריאת POST ל-/connect-sessions עם channel שמוגדר ל-instagram, facebook, tiktok, youtube או linkedin מחזירה קישור מאוחסן ללקוח אחד, בתוקף לשעה. הלקוח נכנס עם הכניסה של הרשת עצמה ונוחת ב-redirect_url עם status=connected ו-channel_id. השרת שלכם מאשר זאת בקריאת GET ל-/connect-sessions/{session} ולא סומך על מחרוזת השאילתה. הקוד שלכם לא צריך אפליקציית מפתחים משלו ב-Meta, TikTok, Google או LinkedIn.

לאחר מכן מבקשים פרטי גישה בתחילת כל משימה. GET ל-/channels/{id}?credentials=1 מחזיר את כתובת הבסיס של ה-API של הרשת, מזהה החשבון ברשת, ואסימון גישה (Access Token) ש-easyCoexistence מרעננת ב-TikTok, ב-YouTube וב-LinkedIn. האסימון של TikTok תקף 24 שעות ושל Google שעה, לכן מביאים אותו לכל משימה במקום לשמור אותו. אסימוני Instagram ו-Facebook אינם מוחזרים לעולם; הקריאות להם עוברות דרך כלי ה-MCP.

Connect an account, then fetch its credentials per job
import os
import requests

EC = "https://easycoexistence.com/api/v1"
KEY = {"Authorization": f"Bearer {os.environ['EC_API_KEY']}"}  # ec_live_...

# A hosted sign-in link for one customer on one network
session = requests.post(f"{EC}/connect-sessions", headers=KEY, json={
    "channel": "instagram",  # or facebook, tiktok, youtube, linkedin
    "redirect_url": "https://app.example.com/connected",
    "external_ref": "customer_4821",
}).json()
print(session["url"])  # they come back with ?session=...&status=connected&channel_id=...

def credentials(channel_id: str) -> dict:
    """The network's API base and a token that is valid now. Call it per job."""
    r = requests.get(f"{EC}/channels/{channel_id}", headers=KEY, params={"credentials": 1})
    r.raise_for_status()
    creds = r.json()["credentials"]
    if not creds.get("access_token"):
        raise RuntimeError(creds.get("note", "This channel is not connected."))
    return creds

איך מפרסמים ב-Instagram ו-Facebook מ-Python?

ב-Instagram הפרסום נעשה בשני שלבים ב-Graph API של Meta, והאסימון נשלח ככותרת bearer. קריאת POST ל-/{ig-id}/media עם image_url ו-caption יוצרת מכולה. אחרי שקריאת GET של status_code מחזירה FINISHED, קריאת POST ל-/{ig-id}/media_publish עם המכולה כ-creation_id מפרסמת אותה בפרופיל. Meta ממליצה לבדוק בערך פעם בדקה, עד חמש דקות. Reel עובר באותם שלבים, עם media_type שערכו REELS ו-video_url במקום image_url.

פוסט בעמוד Facebook הוא קריאה אחת: קריאת POST ל-/{page-id}/feed עם message ו-link אם רוצים קישור. הוספת published false ו-scheduled_publish_time בין 10 דקות ל-30 יום קדימה גורמת ל-Meta לפרסם בזמן הזה, בלי שמשימה שלכם תרוץ. Meta מורידה מדיה מכתובת ציבורית בשני המקרים, ו-Instagram מקבל רק תמונות JPEG.

Publish a photo on Instagram and schedule a Page post
import time
import requests

def graph(c: dict, path: str, **body) -> dict:
    """Meta's Graph API: a POST when there is a body, a GET when there is none."""
    r = requests.request("POST" if body else "GET", f"{c['graph_api_base']}/{path}",
                         json=body or None, headers={"Authorization": f"Bearer {c['access_token']}"})
    r.raise_for_status()
    return r.json()

def post_to_instagram(channel_id: str, image_url: str, caption: str) -> str:
    c = credentials(channel_id)
    ig = c["account_id_on_meta"]
    container = graph(c, f"{ig}/media", image_url=image_url, caption=caption)["id"]
    for _ in range(5):  # Meta: check about once a minute, for up to five minutes
        status = graph(c, f"{container}?fields=status_code")["status_code"]
        if status == "FINISHED":
            return graph(c, f"{ig}/media_publish", creation_id=container)["id"]
        if status in ("ERROR", "EXPIRED"):
            raise RuntimeError(f"Instagram could not process the media: {status}")
        time.sleep(60)
    raise TimeoutError("The container is still processing")

def schedule_on_facebook(channel_id: str, message: str, publish_at: int) -> str:
    c = credentials(channel_id)
    post = graph(c, f"{c['account_id_on_meta']}/feed", message=message,
                 published=False, scheduled_publish_time=publish_at)  # unix seconds
    return post["id"]

איך מעלים ל-YouTube ומפרסמים ב-LinkedIn מ-Python?

YouTube מקבל את הווידאו כהעלאה ניתנת להמשך. הבקשה הראשונה נשלחת לנקודת הקצה של ההעלאה עם uploadType=resumable ו-part=snippet,status, ומכילה את הכותרת והסטטוס כ-JSON. כתובת Location בתשובה היא כתובת ההפעלה. קריאת PUT של הקובץ לכתובת הזאת מחזירה 201 עם הווידאו החדש. הגדרת privacyStatus ל-private יחד עם זמן publishAt גורמת ל-YouTube לפרסם את הווידאו בעצמו באותו רגע, והשדה selfDeclaredMadeForKids מציין אם הוא מיועד לילדים.

LinkedIn דורש קריאת POST אחת ל-/rest/posts עם אסימון bearer, כותרת LinkedIn-Version וכותרת X-Restli-Protocol-Version 2.0.0. בגוף מופיעים המחבר, הטקסט כ-commentary, ו-visibility, distribution ו-lifecycleState. פרטי הגישה מספקים author_urn, שהוא urn:li:organization לעמוד חברה או urn:li:person לפרופיל, וגם את הגרסה ש-easyCoexistence משתמשת בה. ה-URN של הפוסט החדש חוזר בכותרת x-restli-id.

Schedule a YouTube upload and publish a LinkedIn post
import requests

def schedule_on_youtube(channel_id: str, path: str, title: str, publish_at: str) -> str:
    c = credentials(channel_id)
    auth = {"Authorization": f"Bearer {c['access_token']}"}
    start = requests.post(
        "https://www.googleapis.com/upload/youtube/v3/videos",
        params={"uploadType": "resumable", "part": "snippet,status"},
        headers={**auth, "X-Upload-Content-Type": "video/mp4"},
        json={"snippet": {"title": title},
              "status": {"privacyStatus": "private", "publishAt": publish_at,  # ISO 8601
                         "selfDeclaredMadeForKids": False}},
    )
    start.raise_for_status()
    with open(path, "rb") as video:  # streamed, not read into memory
        done = requests.put(start.headers["Location"], data=video,
                            headers={**auth, "Content-Type": "video/mp4"})
    done.raise_for_status()
    return done.json()["id"]

def post_on_linkedin(channel_id: str, text: str) -> str:
    c = credentials(channel_id)
    r = requests.post(f"{c['api_base']}/posts", headers={
        "Authorization": f"Bearer {c['access_token']}",
        "LinkedIn-Version": c["required_headers"]["LinkedIn-Version"],  # YYYYMM
        "X-Restli-Protocol-Version": "2.0.0",
    }, json={
        "author": c["author_urn"],  # urn:li:organization:... or urn:li:person:...
        "commentary": text,
        "visibility": "PUBLIC",
        "distribution": {"feedDistribution": "MAIN_FEED", "targetEntities": [],
                         "thirdPartyDistributionChannels": []},
        "lifecycleState": "PUBLISHED",
        "isReshareDisabledByAuthor": False,
    })
    r.raise_for_status()
    return r.headers["x-restli-id"]  # the new post's URN

איך קוראים ומשיבים לתגובות והודעות DM ב-Python?

מפעילים וובהוק (Webhook) לערוץ, מאמתים כל מסירה, ואז משיבים דרך ה-API של הרשת. קריאת PUT ל-/channels/{id}/webhook עם url מחזירה signing_secret, שמוצג פעם אחת בלבד. תגובות, אזכורים והודעות DM ב-Instagram וב-Facebook, וכן תגובות ב-TikTok, מגיעים כקריאת POST עם platform, account_id, external_id ו-entry, כאשר entry מופיע בדיוק כפי שהרשת שלחה אותו. הכותרת X-EC-Signature היא t=<unix>,v1=<hex>, ו-v1 הוא HMAC-SHA256 של החותמת, נקודה וגוף הבקשה הגולמי. כל אירוע נשלח פעם אחת, בלי עותק וללא ניסיון חוזר, לכן מאשרים קודם ועובדים מתור.

תשובה להודעת DM ב-Instagram נשלחת אל /{ig-id}/messages בתוך 24 שעות מההודעה האחרונה של האדם, ובמקסימום 1,000 בתים. תגובה מקבלת תשובה ציבורית אל /{comment-id}/replies, או תשובה פרטית אחת בתוך 7 ימים. תגובות TikTok מקבלות תשובות ציבוריות דרך business/comment/reply/create/, כי ב-TikTok אין הודעות DM. תגובות YouTube ו-LinkedIn נקראות דרך ה-API שלהן לפי לוח זמנים.

Verify forwarded events and reply to Instagram DMs and comments
import hashlib, hmac, json, queue, time
import requests
from flask import Flask, abort, request

app = Flask(__name__)
jobs: queue.Queue = queue.Queue()  # a worker calls reply_on_instagram() for each event
SECRETS: dict[str, str] = {}  # channel_id -> signing_secret; keep them in your database

def forward_events(channel_id: str, url: str) -> None:
    r = requests.put(f"{EC}/channels/{channel_id}/webhook", headers=KEY, json={"url": url})
    r.raise_for_status()
    SECRETS[channel_id] = r.json()["signing_secret"]  # returned only this once

def verified(raw: bytes, header: str, secret: str) -> bool:
    parts = dict(p.split("=", 1) for p in header.split(",") if "=" in p)
    t, v1 = parts.get("t", ""), parts.get("v1", "")
    if not t.isdigit() or abs(time.time() - int(t)) > 300:
        return False
    mac = hmac.new(secret.encode(), t.encode() + b"." + raw, hashlib.sha256).hexdigest()
    return hmac.compare_digest(mac.encode(), v1.encode())

@app.post("/hooks/social")
def social_event():
    raw = request.get_data()
    event = json.loads(raw)  # platform, account_id, external_id, entry
    secret = SECRETS.get(event.get("account_id"))
    if not secret or not verified(raw, request.headers.get("X-EC-Signature", ""), secret):
        abort(401)
    jobs.put(event)  # sent once and never retried: acknowledge first, work after
    return "", 204

def reply_on_instagram(event: dict, text: str) -> None:
    c, me = credentials(event["account_id"]), event["external_id"]
    for m in event["entry"].get("messaging", []):  # DMs, minus echoes of your own
        if "message" in m and not m["message"].get("is_echo"):
            graph(c, f"{me}/messages", recipient={"id": m["sender"]["id"]}, message={"text": text})
    for ch in event["entry"].get("changes", []):  # comments, minus your own replies
        if ch["field"] == "comments" and ch["value"]["from"]["id"] != me:
            graph(c, f"{ch['value']['id']}/replies", message=text)

איך מפרסמים ב-TikTok מ-Python?

דרך כלי ה-MCP publish_tiktok_post של easyCoexistence. ה-API for Business של TikTok מקבל וידאו כ-video_url, ומאז 16 בנובמבר 2023 מוריד ממנו רק מדומיין או מתחילית כתובת שאומתו לאפליקציית המפתחים שמאחורי האסימון, שהיא של easyCoexistence. הכלי מקבל את הקישור ה-HTTPS שלכם ומעביר ל-TikTok כתובת חתומה בנתיב המדיה המאומת של easyCoexistence, שמזרים את הקובץ בלי לשמור אותו. פוסטים של תמונות מקבלים במקום זאת image_urls, בין 1 ל-35 קבצי JPEG או WebP, ו-get_tiktok_publish_status עוקב אחרי הפוסט בזמן ש-TikTok מעבד אותו.

מ-Python זו קריאה אחת דרך ה-MCP SDK הרשמי, גרסה 2, על Python 3.10 ומעלה. השרת בכתובת https://easycoexistence.com/api/mcp מקבל רק OAuth 2.1, ולכן OAuthClientProvider של ה-SDK רושם את הלקוח שלכם, מריץ כניסה אחת בדפדפן עם PKCE ומרענן אסימונים. אסימוני הגישה תקפים שעה ואסימוני הרענון 60 יום. כל רענון מנפיק זוג חדש, ואחסון שמשמר אותם משאיר שרת backend מחובר.

Publish a TikTok video through the MCP server
import asyncio
import os
from urllib.parse import parse_qs, urlparse

import httpx2
from pydantic import AnyUrl
from mcp import Client
from mcp.client.auth import AuthorizationCodeResult, OAuthClientProvider
from mcp.client.streamable_http import streamable_http_client
from mcp.shared.auth import OAuthClientInformationFull, OAuthClientMetadata, OAuthToken

MCP_URL = "https://easycoexistence.com/api/mcp"

class Storage:  # keep both values in a database, so the browser sign-in happens once
    tokens: OAuthToken | None = None
    client: OAuthClientInformationFull | None = None
    async def get_tokens(self): return self.tokens
    async def set_tokens(self, tokens): self.tokens = tokens
    async def get_client_info(self): return self.client
    async def set_client_info(self, info): self.client = info

async def show_sign_in(url: str) -> None:
    print("Sign in to easyCoexistence:", url)

async def read_callback() -> AuthorizationCodeResult:
    query = parse_qs(urlparse(input("Paste the address you were sent back to: ")).query)
    return AuthorizationCodeResult(code=query["code"][0], state=query["state"][0])

oauth = OAuthClientProvider(
    server_url=MCP_URL,
    client_metadata=OAuthClientMetadata(
        client_name="My social agent",
        redirect_uris=[AnyUrl("http://localhost:3030/callback")],
        scope="mcp",
    ),
    storage=Storage(),
    redirect_handler=show_sign_in,
    callback_handler=read_callback,
)

async def main() -> None:
    timeout = httpx2.Timeout(30.0, read=300.0)
    async with httpx2.AsyncClient(auth=oauth, timeout=timeout) as http:
        async with Client(streamable_http_client(MCP_URL, http_client=http)) as client:
            result = await client.call_tool("publish_tiktok_post", {
                "account_id": os.environ["TIKTOK_CHANNEL_ID"],  # the Partner API channel id
                "video_url": "https://cdn.example.com/launch.mp4",
                "caption": "New drop #behindthescenes",
            })
            print(result.content[0].text)  # a share_id for get_tiktok_publish_status

asyncio.run(main())

איך סוכן AI מבוסס Python משתמש בחשבונות האלה?

דרך אותו סשן MCP. השרת מציג את הכלים לרשתות שבחשבון שלכם, וכל מסגרת סוכנים שמקבלת כלי MCP יכולה להעביר אותם למודל שלה: פרסום בכל רשת, הצגת פוסטים, קריאת תגובות ומענה להן, מענה להודעות DM ב-Instagram וב-Facebook, הגדרת כללי הפיכת תגובה להודעת DM, וקריאת תובנות וניתוחים. ההנחיות של השרת והתיאור של כל כלי נושאים את כללי הרשת, כך שהמודל לומד שתשובות ב-TikTok הן ציבוריות ושתמונות ב-Instagram חייבות להיות JPEG.

מתחילים את הסוכן עם list_social_accounts, כי כל כלי רשת אחר לוקח ממנו account_id, והמזהה הזה הוא אותו channel_id ש-Partner API מחזיר. תשובות שחייבות לצאת בשלוש לפנות בוקר, כשאין סוכן פעיל, שייכות לכללי התגובה והאוטומציות, שרצים על easyCoexistence עצמה.

טעויות נפוצות

  • שמירת האסימון בקובץ הגדרות. האסימון של TikTok פג תוך יום והאסימון של Google תוך שעה, ו-easyCoexistence מרעננת אותם מאחורי הקלעים, לכן קוראים לנקודת הקצה של פרטי הגישה בתחילת כל משימה.
  • מסירת קישור מהדומיין שלכם ל-TikTok. TikTok מוריד מדיה רק מתחיליות כתובת שאומתו לאפליקציה שמחזיקה באסימון, ולכן מפרסמים דרך publish_tiktok_post, שמגיש את הקובץ מכתובת המאומתת של easyCoexistence.
  • מענה לכל אירוע תגובה, כולל התגובות שלכם. התשובות הציבוריות שלכם חוזרות כתגובות חדשות, וההודעות שלכם ב-Instagram חוזרות כ-echo, לכן מדלגים על אירועים שהכותב שלהם הוא החשבון עצמו, אחרת הבוט משיב לעצמו.
  • מדידת הודעת DM בתווים. התקרה היא 1,000 בתים של UTF-8, ולכן טקסט עם אימוג'ים או אותיות עם סימנים דיאקריטיים נגמר מוקדם יותר; יש לקצר לפי אורך מקודד לפני השליחה.
עושים את זה עם EasyCoexistence

easyCoexistence נותנת לקוד ה-Python שלכם ולסוכני ה-AI שלכם גישה ללקוחות ב-WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn ועוד ערוצים, דרך ה-API הרשמי של כל רשת. ה-Partner API מחבר חשבונות ומחלק אסימונים טריים, שרת ה-MCP מעניק לסוכנים את אותם חשבונות ככלים, וכל חיבור מנוטר 24/7. US$ 9 עד US$ 0.75 לחיבור בחודש, והמחיר יורד ככל שמוסיפים חיבורים, עם 3 הימים הראשונים בחינם.

שאלות נפוצות

צריך אפליקציית מפתחים משלי ב-Meta, TikTok, Google או LinkedIn?

לא. החשבונות נכנסים דרך האפליקציה של easyCoexistence עצמה בכל רשת, וקריאת פרטי הגישה נותנת לקוד שלכם את האסימון של אותו חשבון ב-TikTok, ב-YouTube וב-LinkedIn, מוכן לשימוש מול ה-API של הרשת.

איזו גרסת Python ואילו ספריות צריך?

ה-Partner API וה-API של הרשתות הם HTTPS רגיל עם JSON, ולכן requests, httpx או כל לקוח HTTP אחר של Python קורא להם. ה-MCP Python SDK, גרסה 2, שבו משתמשים לפרסום ב-TikTok ולכלי הסוכנים, דורש Python 3.10 ומעלה.

אילו רשתות שולחות תגובות והודעות DM לנקודת הקצה שלכם?

Instagram ו-Facebook מעבירים תגובות, אזכורים והודעות DM, ו-TikTok מעביר תגובות, וכולם חתומים בסוד החתימה של הערוץ. YouTube ו-LinkedIn לא שולחים אירועים כאלה, לכן קוראים את התגובות שלהם דרך ה-API שלהן לפי לוח זמנים.

כמה עולה easyCoexistence ל-Python?

US$ 9 עד US$ 0.75 לחיבור בחודש, והמחיר יורד ככל שמוסיפים חיבורים, והוא זהה בכל רשת. ה-Partner API ומחבר ה-MCP כלולים, בלי תשלום לכל משתמש, ו-3 הימים הראשונים בחינם.

המשיכו לקרוא

פרסום ל-Instagram, TikTok ו-Facebook מ-Node.js באמצעות ממשק API אחדפרסום, תזמון ומענה ב-Instagram, Facebook, TikTok, YouTube ו-LinkedIn מ-Node.js וגם TypeScript עם fetch, וכלי MCP לסוכן שלכם.ממשק API לרשתות חברתיות לסוכני AI: פרסום, תזמון, תגובות ומדידהממשק API ושרת MCP שמאפשרים לסוכני AI לפרסם, לתזמן, להגיב ולקרוא אנליטיקה ברשתות חברתיות, דרך ה-API הרשמי של כל רשת.שרת MCP לרשתות חברתיות עבור Claude ו-ChatGPTמחבר MCP אחד לכל רשת: Claude או ChatGPT מפרסמים, מתזמנים, מגיבים לתגובות ולהודעות DM וקוראים אנליטיקה, דרך ממשקי API רשמיים.אסימוני גישה ל-Instagram: אסימונים לטווח ארוך, 60 יום ורענוןאיך פועלים אסימוני הגישה של Instagram Login: אסימון של שעה אחרי ההתחברות, אסימון לטווח ארוך בתוקף 60 יום, ורענון כשהוא בן 24 שעות.ה-API for Business של TikTok לעומת Content Posting APIמדוע ה-API for Business של TikTok ולא developers.tiktok.com: תגובות והוובהוק (Webhook) שלהן, תובנות, החשבונות שמתחברים וחידוש האסימונים.אירועי וובהוק (Webhook) של Instagram: תגובות, תיוגים והודעות DMכך מגיעים תגובות, תיוגים והודעות DM של Instagram לנקודת הקצה שלכם כאירועי וובהוק: מה כל payload כולל, איך נחתמות המסירות ומה לבדוק.

מחברים את הערוץ הראשון שלכם תוך שתי דקות.

בלי לחכות לאישורים של הפלטפורמות. מחברים את WhatsApp, Instagram, TikTok או ערוץ אחר, מבקשים מה-AI לפרסם, להשיב או להפיק דוח, ורואים אותו עובד.

  • 3 ימי ניסיון חינם
  • ביטול בכל עת
  • רק ממשקי API רשמיים
  • ניטור 24/7

נבדק ב-