# Reeling public documentation Reeling prepares and schedules social content through authorized connections. Account, plan, platform and app-review requirements apply. Use the dated platform matrix and returned capabilities. A request receipt is not proof of public publication. ## Developer resources - Developer hub: https://reeling.app/developers - MCP source: https://github.com/yomariano/reeling-mcp - Runnable examples: https://github.com/yomariano/reeling-examples - Hosted Streamable HTTP: https://mcp.reeling.app/mcp - Legacy SSE: https://mcp.reeling.app/sse - OpenAPI reference: https://api.reeling.app/api/v1/openapi.json The local adapter is installed from a versioned GitHub release: npx -y github:yomariano/reeling-mcp#v1.0.1. Do not assume the unscoped npm package is published. Keep API keys out of URLs, chat and committed files. Check project/channel reads first and review each write action in the client. ## Plans ### Starter Monthly: USD 2.99; yearly: USD 29.00. - 1 Project Workspace - 3 Connected Channels - 30 Scheduled Posts / month - Direct Multi-Platform Publishing - Basic Analytics & Performance Tracking - 21-Day Auto-Purge Media Storage - AI Caption & Hook Generator ### Creator Monthly: USD 5.99; yearly: USD 64.00. - 3 Projects - Up to 10 Connected Channels - Unlimited Scheduled Posts - AI Content Adaptor & Smart Queue - 500 AI Video & Caption Credits / month - Real-Time Multi-Platform Metrics - Unified Social Inbox & Direct Replies - Full MCP Server & Developer API Access ### Agency Monthly: USD 19.99; yearly: USD 215.00. - Unlimited Projects & Brands - Unlimited Connected Channels - Unlimited Scheduled Posts - 2,000 AI Video & Caption Credits / month - Agency Collaboration & Client Approval Workflows - Inbound Video Repurposing Webhooks - Outbound Signed Event Webhooks - Full MCP Server & Developer API Access - Priority 24/7 Dedicated Support ## Developer guides ### Reeling MCP server setup https://reeling.app/developers/mcp Reviewed: 2026-10-20 Connect an MCP client to Reeling to discover projects, inspect connected channels and prepare reviewed social-publishing actions. Start with account reads before enabling writes. #### Choose local or hosted transport The open-source adapter runs locally over stdio with Node.js 22 or later. The hosted endpoint uses Streamable HTTP at https://mcp.reeling.app/mcp. Legacy SSE remains available at /sse for existing clients. Choose the transport your installed client supports; URL and header configuration differs between clients. The source is installable from a versioned GitHub tag. The unscoped npm package name reeling-mcp is not currently published, so use the exact GitHub command below. - Open-source adapter and releases: https://github.com/yomariano/reeling-mcp - Hosted installation reference: https://mcp.reeling.app/install #### Configure the local adapter Use this command-and-arguments shape in Claude Desktop or Cursor’s supported MCP configuration. Replace YOUR_API_KEY only in your local secret configuration. Never commit a real key or paste it into chat. Reload the client connection after saving. The GitHub tag pins the adapter source. Review the release and dependency lockfile before installing it. If npx is unavailable to a desktop client, install Node.js and use its absolute executable path. ``` { "mcpServers": { "reeling": { "command": "npx", "args": [ "-y", "github:yomariano/reeling-mcp#v1.0.1" ], "env": { "REELING_API_KEY": "YOUR_API_KEY" } } } } ``` - Generate a configuration template: /tools/mcp-config-generator - Cursor MCP configuration: https://cursor.com/docs/context/mcp #### Check projects and channels first Create a project and connect its destinations in Reeling. Create an API key under Settings, then allow reeling_list_projects and reeling_list_channels. Select the exact project instead of choosing the first item from a multi-project account. Channel capabilities describe the server’s configured integration, not proof of a successful post or approval for every visibility setting. Consult the platform requirements and inspect channel options before enabling a write. - API authentication and account reads: /developers/api - Current platform requirements: /developers/social-publishing-api #### Approve consequential tools deliberately Publishing, replies, metric synchronization and AI generation can change external state or consume a plan allowance. Keep client-side tool approval enabled and review the destination, content, schedule and visibility. A Reeling API key is not a read-only credential. The MCP publish tool exposes a subset of the REST options. When your workflow needs an exact channel ID or a platform-specific setting absent from the tool schema, use the reviewed REST example rather than assuming the adapter forwards it. - Request-draft and status-polling examples: /developers/examples #### Recover from setup errors A connection error can come from a missing Node executable, a client using a different PATH, unsupported transport or malformed JSON. Confirm that tools/list works before investigating account permissions. For authentication and authorization errors, check the API key, current plan, project ownership and channel permissions. Do not assume every 403 requires payment. Preserve an existing post ID after an ambiguous publish timeout and check its status before retrying. - Reeling plans: /pricing - MCP architecture documentation: https://modelcontextprotocol.io/docs/learn/architecture ### Reeling publishing API reference https://reeling.app/developers/api Reviewed: 2026-10-20 Use the Reeling REST API at https://api.reeling.app/api/v1 to discover projects and channels, submit reviewed video requests and check per-destination delivery results. #### Authenticate with a header Provide X-API-Key or Authorization: Bearer in your request headers. Create and revoke keys in your Reeling account. Account and plan eligibility apply. Keep keys in an environment variable or secret manager; do not put them in URLs, GitHub examples or screenshots. Start with project discovery. The example below makes one account read; its output can contain private project identifiers and names. ``` curl --fail-with-body \ -H "X-API-Key: $REELING_API_KEY" \ https://api.reeling.app/api/v1/projects ``` - Open the interactive API portal: /developers - Current machine-readable OpenAPI document: https://api.reeling.app/api/v1/openapi.json #### Select a project and channel GET /projects returns projects owned by the authenticated account. Pass a projectId query parameter to GET /channels. Choose the correct channel ID from that project, and inspect GET /channels/{id}/options where the provider exposes choices. The runnable account example requires explicit project selection for multi-project accounts. It emits platform/capability summaries and omits private names and IDs from its report. This reduces accidental disclosure when sharing a connection check. ``` node examples/read-account.mjs node --env-file=.env examples/read-account.mjs --live-read ``` - Download the runnable account example: https://github.com/yomariano/reeling-examples/blob/main/examples/read-account.mjs #### Review a publishing request POST /publish accepts a video URL or multipart video upload. Include project_id, channel_ids and platforms explicitly. The example uses private YouTube visibility and a future timestamp with a timezone. The media URL and UUIDs are placeholders, not a runnable upload. The scheduling script validates the date and identifiers, displays a local request draft first, and only sends when you pass --publish. A real submission can consume plan allowance. Retain its post_id and original request context. ``` { "project_id": "YOUR_PROJECT_UUID", "channel_ids": [ "YOUR_CHANNEL_UUID" ], "platforms": [ "youtube" ], "video_url": "https://example.com/owned-video.mp4", "title": "A useful workflow", "caption": "A short demonstration.", "youtube": { "privacy_status": "private", "made_for_kids": false }, "scheduled_for": "2026-12-01T15:00:00Z" } ``` - Runnable scheduling example: https://github.com/yomariano/reeling-examples/blob/main/examples/schedule-video.mjs - Platform access and media requirements: /developers/social-publishing-api #### Follow the post through delivery GET /posts/{id} returns a top-level status and publish_results for individual destinations. Check published, upload_status, url and error. A success flag on the request or upload can precede final publication. TikTok inbox delivery requires a separate action in the TikTok app. Use bounded polling, back off for rate limits and save the existing post ID. An expired observation window is an unknown result, not permission to upload the same content again. ``` node examples/poll-status.mjs node --env-file=.env examples/poll-status.mjs --live-read ``` - Inspect the polling source: https://github.com/yomariano/reeling-examples/blob/main/lib/api.mjs - Monitor failures without duplicate posts: /blog/monitor-social-publishing-failures #### Read analytics with their definitions GET /analytics/overview accepts projectId and optional startDate/endDate filters. Missing provider metrics remain unavailable; they should not silently become measured zeroes. Provider definitions and available permissions differ. The example reads the stored overview. It does not request a metric synchronization or claim that platform views are website visits. Keep the returned account analytics private. - Analytics example source: https://github.com/yomariano/reeling-examples/blob/main/examples/read-analytics.mjs - UTM campaign link builder: /tools/utm-builder ### Social publishing API requirements https://reeling.app/developers/social-publishing-api Reviewed: 2026-10-20 A shared publishing API simplifies requests, but each destination still controls authorization, visibility, media acceptance and delivery. Check the actual channel capabilities before submitting. #### Compare the destination workflows This is a workflow comparison, reviewed October 20, 2026. It combines Reeling’s maintained integration reference with the provider documentation linked below. It is not a live upload test or an account approval claim. Provider access can change; inspect the connected account before use. Destination | Reeling workflow | Check before publishing YouTube | Video upload with explicit privacy and audience settings. | Connected channel, app/account capability, title, privacy and made-for-kids setting. TikTok | Inbox delivery; direct mode depends on current app and creator capabilities. | Creator options, visibility eligibility and whether finishing in TikTok is required. Instagram | Reel through an authorized Business or Creator connection. | Professional account, relevant permissions, current app/tester access and media readiness. #### Choose visibility instead of relying on defaults For a first YouTube integration check, select private visibility explicitly. The API supports privacyStatus and audience-related fields; inspect the intended channel and verify the actual destination after upload. A private test is different from a public Short. TikTok requires approved scope and user authorization for Direct Post. Its documentation restricts unaudited clients and requires an audit to lift visibility restrictions. Reeling’s inbox flow requires finishing the post in TikTok. Never describe an inbox receipt as a public post. - YouTube video insertion reference: https://developers.google.com/youtube/v3/docs/videos/insert - TikTok Direct Post requirements: https://developers.tiktok.com/docs/content-posting-api-get-started #### Prepare the actual media file Reeling’s overall v1 ingestion cap is 100 MiB. Individual destinations can impose smaller limits, duration rules or codec constraints. Review the returned capabilities and inspect the final export rather than trusting its filename. Plan the frame, captions and file size before you send. These local tools make useful estimates, but they do not transcode, upload or validate a file against a destination API. - Video file-size and bitrate calculator: /tools/video-file-size-calculator - Video aspect-ratio calculator: /tools/video-aspect-ratio-calculator - Subtitle converter: /tools/subtitle-converter #### Use one channel for the first integration The account may contain several channels for the same platform. Select project_id and channel_ids deliberately and run one reviewed destination before expanding to a mixed request. This makes failures and permissions easier to investigate. If one platform succeeds and another fails, preserve both outcomes. Correct only the failed destination after checking for an existing upload; do not blindly resubmit the entire multi-platform request. - Draft a request from the examples: /developers/examples - REST status reference: /developers/api #### Where direct provider APIs still matter A unified API does not replace platform policy or application approval. For provider-specific behavior, use the primary documentation and your returned channel options. Reeling’s supported fields may cover only part of the provider’s complete API. The maintained platform matrix in the main developer portal covers additional destinations, inbox coverage and metric availability. Choose a workflow based on its current requirements rather than the number of platform logos. - Reeling platform matrix: /developers#platform-rules - Meta Instagram publishing documentation: https://developers.facebook.com/docs/instagram-platform/content-publishing/ ### Reeling API and MCP examples https://reeling.app/developers/examples Reviewed: 2026-10-20 Clone the open-source Reeling examples to check account access, draft a video request, poll delivery and read analytics. Every account example starts with an offline fixture or a local request draft. #### Clone and run without credentials Use Node.js 22 or later. The examples use Node’s built-in fetch and test runner and have no npm dependencies. The tests cover explicit channel selection, private/inbox defaults, per-platform failure handling, polling timeouts and ambiguous POST errors. The default results are labeled offline fixtures. They demonstrate output shapes and recovery logic; they do not represent customer data or successful live posts. ``` git clone https://github.com/yomariano/reeling-examples.git cd reeling-examples npm test node examples/read-account.mjs node examples/poll-status.mjs node examples/read-analytics.mjs ``` - Open reeling-examples on GitHub: https://github.com/yomariano/reeling-examples #### Configure a real account read Create a local ignored .env using the documented variable names. Use your own project and channel IDs. Node does not load the file automatically; pass --env-file=.env. The account script requires --live-read before it sends either discovery GET. Your API key can authorize writes. The scripts constrain their operations, but the key itself is not read-only. Keep the file and live outputs out of source control. ``` node --env-file=.env examples/read-account.mjs --live-read ``` - Account read source: https://github.com/yomariano/reeling-examples/blob/main/examples/read-account.mjs - API setup guide: /developers/api #### Draft before publishing Set the media URL, exact channel, project, caption and intended time locally. The scheduling script prints the request first without submitting. Review the destination, visibility and audience settings before adding --publish. The example selects one channel per invocation and defaults to private YouTube visibility and TikTok inbox delivery. For several destinations, make explicit reviewed requests instead of silently selecting every connected channel. ``` node --env-file=.env examples/schedule-video.mjs # After reviewing the payload and platform options: node --env-file=.env examples/schedule-video.mjs --publish ``` - Scheduling example source: https://github.com/yomariano/reeling-examples/blob/main/examples/schedule-video.mjs - Publishing requirements: /developers/social-publishing-api #### Poll status and read analytics Save the returned post_id. The polling example makes at most 12 reads, spaced five seconds apart. It reports processing, failure, reported publication and timeout separately. A scheduled post may remain pending beyond the observation window. The analytics example reads the selected project’s stored overview. Its output is private account data. The supplied code does not request synchronization, manufacture missing metrics or infer revenue attribution. ``` node --env-file=.env examples/poll-status.mjs --live-read node --env-file=.env examples/read-analytics.mjs --live-read ``` - Polling logic and tests: https://github.com/yomariano/reeling-examples/blob/main/test/examples.test.mjs #### Plan an editorial calendar Use the free calendar builder for dates, topic rotation and timezone labels. Download a CSV and review it in a spreadsheet with an owner and status. It is an editorial worksheet, not a bulk-upload contract. For assistant integrations, generate a local or hosted MCP template and replace the placeholder key in your client. First verify project and channel reads; inspect the tool schema before approving publishing. - Build a content calendar: /tools/content-calendar - Build an MCP configuration: /tools/mcp-config-generator - Adapter source and architecture: https://github.com/yomariano/reeling-mcp ### Social publishing workflow lab https://reeling.app/developers/workflow-lab Reviewed: 2026-10-21 Inspect a publishing workflow before connecting an account. This lab combines executable examples, delivery decisions and a dated observation of the public Reeling MCP endpoint. #### Start with a reproducible offline check The examples run with Node.js 22 or later and no third-party dependencies. Their default mode uses local fixtures or prints a request draft. It does not publish a post, require credentials or spend an AI allowance. Run the tests, inspect the project and channel summary, then review the scheduling draft and status output. Passing fixture tests establishes the example’s local behavior; it does not demonstrate delivery to a live social account. ``` git clone https://github.com/yomariano/reeling-examples.git cd reeling-examples npm test node examples/read-account.mjs node examples/schedule-video.mjs node examples/poll-status.mjs ``` - Runnable source, fixtures and tests: https://github.com/yomariano/reeling-examples #### Review three workflow contracts A useful demonstration shows the input, expected behavior and a failure case. Keep workspace selection, submission and delivery evidence separate when recording a tutorial or evaluating an integration. Stage | What to check | Evidence to retain Select the workspace | Choose the exact project and owned channel; inspect destination capabilities. | A redacted account summary and the selection rule. Draft the request | Review media ownership, destination, timezone, future date and visibility. Approve the write explicitly. | The redacted request and the reviewed adapter version. Check delivery and recover | Poll the existing post ID with a bounded wait; inspect each destination result. | Per-destination status, public URL if returned, and any unresolved error. - REST API authentication and request fields: /developers/api - Destination requirements: /developers/social-publishing-api #### What does a successful request prove? An accepted request is the start of a delivery workflow. Some destinations need additional actions, and an ambiguous timeout can occur after a request reaches the server. Review the existing item before attempting another write. Observation | What it establishes | Next check Request accepted | The service accepted a submission. | Retain its post ID and inspect delivery status. Scheduled or processing | Work remains queued or in progress. | Poll with a time limit; do not describe it as published. Delivered to an inbox or companion | The content reached the next step in a handoff. | Complete and verify the destination’s required action. One destination failed | That destination reports an error. | Inspect its error before repeating any successful destinations. Submission timed out | The client did not receive a definitive response. | Look for an existing item before creating a duplicate. - Status polling and duplicate prevention example: https://github.com/yomariano/reeling-examples/blob/main/examples/poll-status.mjs #### A dated public MCP observation On 21 October 2026 we made five sequential tools/list requests to the public hosted MCP endpoint. The downloadable record contains the observation time, HTTP status, elapsed time, sorted tool names and a source checksum. No account credentials were used and no account tools were executed. This small observation checks public tool discovery at one point in time. It is not a load test, uptime study, account authorization test or proof that any tool published successfully. Re-run the script to collect your own current result. ``` node examples/observe-mcp.mjs --samples=5 --write ``` - Download the dated observation JSON: https://reeling.app/resources/evidence/mcp-observations-2026-10-21.json - Review the observation method: https://github.com/yomariano/reeling-examples/blob/main/examples/observe-mcp.mjs #### Move from fixtures to an account deliberately Create a Reeling project, connect the intended destination and generate an API key in Settings. First run the explicit live-read mode and select the correct project. Keep the key in local secret configuration. The publishing example requires a separate --publish flag after request review. A Reeling API key is not a read-only credential. Live publishing may consume plan allowance and change an external account. Inspect the current platform requirements and exact REST or MCP schema before sending. - Account setup and executable examples: /developers/examples - MCP setup and approval controls: /developers/mcp #### Reuse this lab in a useful tutorial The example repository is MIT licensed. Include the tested revision, observation date, redacted inputs, expected output and a failure case when adapting it. Explain whether a step was run against fixtures, an authenticated read or a live publishing destination. A useful comparison asks whether the workflow can select the intended account, express the required settings and verify the resulting delivery. Cite the current documentation for competing products and record unresolved limits instead of extrapolating from a successful request. - Compare Reeling and Buffer: /vs/buffer - Compare Reeling and Hootsuite: /vs/hootsuite - All developer guides: /developers ## Free browser tools ### UTM campaign link builder https://reeling.app/tools/utm-builder Create a tagged link for a social post, newsletter or campaign. Keep your existing URL parameters and copy a ready-to-use result. ### Video aspect ratio calculator https://reeling.app/tools/video-aspect-ratio-calculator See how a clip fits a portrait, square or landscape canvas. Compare the crop with letterboxing before you edit. ### Video hook template builder https://reeling.app/tools/hook-generator Turn a topic into editable video opening lines. Pick a niche, compare the templates and write a hook you can deliver on. ### SRT & WebVTT subtitle converter https://reeling.app/tools/subtitle-converter Convert SRT to WebVTT or WebVTT to SRT, shift caption timing and download the result. Your subtitle file stays in your browser. ### Video script timer https://reeling.app/tools/video-script-timer Estimate how long your script takes to say. Set your speaking pace, leave room for pauses and find a word budget for your video. ### Video file size & bitrate calculator https://reeling.app/tools/video-file-size-calculator Estimate video file size from duration and bitrate, or calculate a video bitrate budget for an upload size limit. ### Social post formatter https://reeling.app/tools/social-post-formatter Clean caption spacing, keep useful line breaks and check your text against Reeling field limits. Copy or download your post without signing up. ### Social caption previewer https://reeling.app/tools/caption-previewer Preview caption spacing for Instagram, Threads, Bluesky or YouTube and check text counts before preparing a post. Free and local to your browser. ### Social content calendar builder https://reeling.app/tools/content-calendar Plan up to eight weeks of posting dates, topic rotations and timezone labels. Download a free CSV worksheet for your editorial calendar. ### Reeling MCP config generator https://reeling.app/tools/mcp-config-generator Generate a local or hosted Reeling MCP configuration template for your client. Copy valid JSON with placeholder credentials, without signing up. ### Reddit, Quora & Medium spam & shadowban checker https://reeling.app/tools/social-spam-checker Review posts for Reddit, Quora and Medium with a checklist for links, attribution and community rules. Inspect suggestions before publishing. ## Platform reference (15 channel integrations) https://reeling.app/integrations Reviewed: 2026-10-15 Reeling implementation coverage, not a guarantee that an individual account is authorized. Check Connect Channels and returned capabilities before publishing. ### YouTube https://reeling.app/integrations/youtube Video upload; choose privacy and audience settings. Public uploads depend on the connected channel and the app's current capability. Inbox: Read comments and reply, with the required Google permissions. Metrics: Video views, likes and comment counts; shares are not fetched. Limits: 100 MiB; MP4, MOV or WebM. Title: 100 characters. ### TikTok https://reeling.app/integrations/tiktok Inbox delivery requires finishing the post in TikTok. Public Direct Post is awaiting TikTok audit; inspect creator options before using direct mode. Inbox: Comment reading and replies are not implemented. Metrics: Delivery status only; engagement and view metrics are not fetched. Limits: 100 MiB; MP4, MOV or WebM. Duration and interactions depend on creator options. ### Instagram https://reeling.app/integrations/instagram Reels for Business or Creator accounts you own or manage, currently with tester access. Inbox: Read comments and reply, subject to permissions. Metrics: Likes, comments and available Insights views/reach/shares; missing permissions can leave metrics unavailable. Limits: 100 MiB; MP4 or MOV. Caption: 2,200 characters. ### Facebook https://reeling.app/integrations/facebook Video publishing to a Page with admin/publishing permission; not personal-profile publishing. Inbox: Not implemented. Metrics: Not fetched. Limits: 100 MiB; MP4 or MOV. Description: 5,000 characters. ### LinkedIn https://reeling.app/integrations/linkedin Video publishing through an authorized connection. Company pages require Community Management API approval; review is in progress. Inbox: Not implemented. Metrics: Not fetched. Limits: 100 MiB; MP4, MOV or WebM. ### Threads https://reeling.app/integrations/threads Video container publishing through an authorized Threads profile. Development-mode accounts may need tester access. Inbox: Comment reading and replies are not implemented. Metrics: Available Insights views, likes, replies, reposts and quotes. Limits: 100 MiB; MP4 or MOV. Text: 500 characters. ### Pinterest https://reeling.app/integrations/pinterest Video Pin to a selected board. Production publishing needs appropriate Pinterest app access; Trial access can reject Pin creation. Inbox: Not implemented. Metrics: Not fetched. Limits: 100 MiB; MP4 or MOV. Title: 100; description: 500 characters. ### Bluesky https://reeling.app/integrations/bluesky Video post using your handle and app password; video upload requires a verified Bluesky email. Inbox: Read replies and reply to a thread. Metrics: Likes, replies, reposts and quotes. The current views field is an interaction total, not measured impressions. Limits: 50 MiB; MP4, MOV or WebM. Text: 300 characters. ### X (Twitter) https://reeling.app/integrations/x Publish via the Reeling Companion Chrome extension through your authenticated x.com browser session (or via X OAuth API with write permission). Inbox: Not implemented. Metrics: Not fetched. Limits: 280 weighted characters (or up to 25,000 on X Premium via Companion). ### Telegram https://reeling.app/integrations/telegram Video via a bot with posting rights in the chosen chat or channel; a private chat is not a public backlink. Inbox: Not implemented. Metrics: Not fetched. Limits: 50 MiB; MP4, MOV or WebM. Caption: 1,024 characters. ### Discord https://reeling.app/integrations/discord Video/message to the channel belonging to your incoming webhook. Visibility follows that channel's access controls. Inbox: Not implemented. Metrics: Not fetched. Limits: 25 MiB advertised capability; server/channel limits may be lower. Content: 2,000 characters. ### Mastodon https://reeling.app/integrations/mastodon Video status using an instance URL and access token; instance permissions and limits apply. Inbox: Not implemented. Metrics: Not fetched. Limits: 40 MiB advertised capability; use that conservative cap. Text: 500 characters in this integration. ### Reddit https://reeling.app/integrations/reddit Submission via Reeling Companion Chrome extension (or Reddit OAuth). Includes Pre-Publish Spam & AutoModerator Detector with 1-Click Auto-Fix. Inbox: Not implemented. Metrics: Not fetched. Limits: 100 MiB video or text post. Title: 300 characters. ### Medium https://reeling.app/integrations/medium Story and article publishing via the Reeling Companion Chrome extension through your authenticated Medium session. Includes Pre-Publish Spam & AI Cliché Shield. Inbox: Not implemented. Metrics: Not fetched. Limits: Full-length stories and articles; up to 5 comma-separated topic tags. ### Quora https://reeling.app/integrations/quora Answer and share publishing via the Reeling Companion Chrome extension through your authenticated Quora session. Includes Pre-Publish 'Burden of Proof' Spam Detector. Inbox: Not implemented. Metrics: Not fetched. Limits: Standalone posts and shares; 75+ words recommended when including external links. ## Comparison guides ### Reeling vs Buffer https://reeling.app/vs/buffer Buffer is a strong starting point for a small queue, including a free API option. Reeling suits a project-based video workflow when its account requirements and network coverage fit your destinations. Reviewed: 2026-10-15 ### Reeling vs Hootsuite https://reeling.app/vs/hootsuite Hootsuite packages publishing with customer care, reporting and governance. Reeling focuses on a smaller publishing and developer workflow; compare operational requirements before comparing subscription totals. Reviewed: 2026-10-15 ### Reeling vs Metricool https://reeling.app/vs/metricool Metricool organizes work by brands and emphasizes reporting. Reeling organizes publishing by projects. Map your actual accounts and API needs before deciding which plan is sufficient. Reviewed: 2026-10-15 ### Reeling vs Later https://reeling.app/vs/later Later is built around visual Instagram grid planning, social sets and Link in Bio landing pages. Reeling suits a project-based video workflow and developer REST/MCP automation when your channels match its supported destinations. Reviewed: 2026-10-15 ### Reeling vs Publer https://reeling.app/vs/publer Publer prices plans per connected social account and tier, with bulk scheduling and RSS tools. Reeling bundles up to 10 channels and REST/MCP access into its Creator plan. Reviewed: 2026-10-15 ### Reeling vs Sprout Social https://reeling.app/vs/sprout-social Sprout Social is an enterprise social media management, customer care and social listening suite billed per seat. Reeling provides a lightweight video publishing and MCP developer workspace for solo creators and small teams. Reviewed: 2026-10-15 ## Publishing guides and original observations ### How Reddit, Quora, and Medium Detect & Delete Spam Posts (And How to Check Before You Publish) https://reeling.app/blog/reddit-quora-medium-spam-filter-rules-pre-publish-detector Published: 2026-10-21; modified: 2026-10-21; author: Reeling product team Review a practical pre-publish checklist for Reddit, Quora and Medium: community rules, attribution, useful answers and the limits of automated spam checks. #### Why community posts get silently removed without a notification Unlike traditional social feeds that simply lower impressions on promotional posts, community-driven platforms—specifically Reddit, Quora, and Medium—rely on deterministic rule engines and automated classifiers that either silently hide your post from public feeds, collapse it under a quality warning, or suspend your account. Because Reddit's global spam filter and Quora's moderation bots often leave the post visible when viewed from your own logged-in browser session, creators frequently keep publishing the same flagged patterns until their domain or account is permanently shadowbanned. Checking for these platform-specific triggers before dispatching the post prevents avoidable removals. #### Reddit: URL shortener bans, AutoModerator YAML rules, and the 9:1 ratio Reddit operates two layers of automated moderation: the site-wide Reddit spam filter and subreddit-specific AutoModerator YAML rules configured by volunteer moderators. 1. Site-Wide URL Shortener Hard Block: Reddit's global spam filter automatically and silently removes any post or comment containing URL shorteners or link-in-bio redirects (such as bit.ly, tinyurl.com, t.co, amzn.to, linktr.ee, cutt.ly, or rb.gy) because they obscure the destination domain. 2. Affiliate & Referral Parameters: Links containing query parameters like ?ref=, ?aff=, ?tag=, or ?partner= are stripped by AutoModerator and frequently trigger site-wide account shadowbans. 3. Vote Manipulation & DM Funnels: Phrases like "upvote if", "please upvote", "free karma", or "DM me for the link" violate Reddit's Content Policy and match standard AutoModerator removal regexes. 4. The 9:1 Self-Promotion Rule & Low-Context Link Drops: Subreddits routinely remove posts that drop an external link with fewer than 45 words of standalone text, or posts that cram 3+ outbound links into a single submission. Similarly, titles with >45% ALL-CAPS characters or commercial ad copy ("Buy now", "Sign up today") are auto-removed by AutoModerator. ``` // Example draft that trips 3 Reddit removal filters: { "platform": "reddit", "title": "CHECK OUT OUR NEW AI TOOL — 100% FREE SIGN UP NOW!", "content": "Upvote if you find this useful! Grab it here: https://bit.ly/my-tool?ref=reddit" } // Flagged by Reeling Spam Shield (Safety Score: 10/100 - High Removal Risk): // - Banned URL shortener (bit.ly) // - Affiliate/referral parameter (?ref=) // - Vote manipulation phrase ("Upvote if") // - Excessive ALL-CAPS & commercial pitch in title ``` #### Quora: Zero-tolerance affiliate bans and the 'Burden of Proof' link rule Quora's moderation bot evaluates every answer and share against two primary spam policies that catch marketers off guard: 1. Zero-Tolerance Affiliate & Masked Links: Quora explicitly prohibits affiliate links (?ref=, ?tag=, amzn.to, ClickBank, ShareASale) and masked URL shorteners. Unlike Medium, adding an affiliate disclosure does not exempt a Quora post—bots delete the post immediately and repeat violations lead to account bans. 2. The "Burden of Proof" Spam Rule: Quora's official policy states that a post must answer the question completely on Quora itself; if an external link does more to answer the prompt than the written text on Quora, the post is classified as traffic-driving spam and deleted. In practice, any Quora post containing an outbound URL with fewer than 75 words of standalone explanation—or multiple external URLs—faces a high deletion rate. 3. Short-Answer Auto-Collapse: Even without links, Quora answers under 45 words are automatically collapsed into the hidden "Answers That Need Improvement" accordion at the bottom of the page. - Connect Quora & Medium in Reeling: /connect #### Medium: Undisclosed affiliate links and 'Network-Only' AI cliché demotion Medium allows outbound links and affiliate marketing, but enforces strict curation and anti-abuse rules: 1. Undisclosed Affiliate Links: Medium requires an explicit, visible FTC disclosure inside any story containing affiliate or referral links. Publishing affiliate URLs without a disclosure word (such as "Disclosure:", "affiliate", or "commission") can result in immediate account suspension. 2. Cloaked & Shortened URLs: Medium's automated anti-spam sweeps flag stories containing shortened or obfuscated URLs (bit.ly, tinyurl.com) and stories with high outbound link density (4+ links in a short <250-word post). 3. Unedited AI Phrasing ("Network-Only" Distribution Demotion): Medium's curation classifiers and human editors restrict unedited AI-generated articles to "Network-Only" distribution (removing them from topic feeds and the Partner Program paywall). Drafts saturated with classic LLM giveaway clichés—such as "delve into", "in today's fast-paced digital landscape", "rich tapestry", "testament to", "game-changer", or "unlock the full potential"—are prime candidates for distribution demotion. #### How Reeling's Pre-Publish Spam Shield & 1-Click Auto-Fix works Reeling embeds a real-time Pre-Publish Spam & Removal Risk Detector directly inside the Web Composer (/compose), the Reeling Companion Chrome Extension popup, and the REST API v1 (/api/v1/publish). As you type or adapt copy for Reddit, Quora, or Medium, the Spam Shield calculates a live Safety Score (0–100), highlights the exact platform rule triggered, and offers a 1-Click "Auto-Fix Triggers" button. Clicking Auto-Fix automatically strips affiliate/tracking URL parameters (?ref=, ?aff=, ?tag=, utm_*), normalizes ALL-CAPS titles into sentence case, removes vote-manipulation and hard-sell CTAs, strips external links on thin Quora posts, and replaces AI giveaway clichés on Medium with natural human phrasing. If you automate publishing from an AI agent via MCP or the REST API, you can also pass auto_sanitize_spam: true or strict_spam_check: true in your POST /api/v1/publish request. ``` curl -X POST https://api.reeling.app/api/v1/publish \ -H "X-API-Key: rl_live_your_api_key" \ -H "Content-Type: application/json" \ -d '{ "project_id": "YOUR_PROJECT_UUID", "platforms": ["reddit", "quora", "medium"], "title": "How we reduced video rendering latency by 42%", "content": "Full technical breakdown of our FFmpeg pipeline...", "auto_sanitize_spam": true, "strict_spam_check": true }' ``` - Open the Reeling Composer to test the Spam Shield: /compose - Explore the Reeling REST API & MCP documentation: /developers Source: Reeling Composer & Pre-Publish Spam Shield: https://reeling.app/compose Source: Reeling API v1 & MCP Documentation: https://reeling.app/developers ### How to Automate X (Twitter), Reddit, Medium, and Quora from Remote AI Agents (MCP & OpenClaw) Without API Paywalls https://reeling.app/blog/automate-x-reddit-medium-quora-mcp-reeling-companion Published: 2026-10-21; modified: 2026-10-21; author: Reeling product team Set up Reeling companion workflows for X, Reddit, Medium and Quora. Review MCP requests, account access and platform requirements before publishing. #### Why traditional cloud APIs fail on X, Medium, Quora, and Reddit Developers building autonomous content agents (using OpenClaw on a Hetzner VPS, Claude Desktop, or Cursor) quickly run into four walls when trying to publish text, threads, and articles: • X (Twitter) locked programmatic write access behind paid developer tiers starting at $200/month. • Medium deprecated issuing new public integration tokens. • Quora has never offered a public write API for answers or shares. • Cloudflare Turnstile and bot management aggressively block headless browsers and requests originating from datacenter IPs (Hetzner, AWS, DigitalOcean) on Quora, Medium, and Reddit. To solve this without fragile headless-browser proxies or $200/mo API fees, Reeling pairs its cloud REST API & MCP server with the Reeling Companion Chrome Extension. #### How the Hybrid Cloud + Chrome Companion Bridge works When you install Reeling Companion in Google Chrome on your computer and stay logged into X, Medium, Quora, and Reddit, the extension maintains a lightweight background heartbeat with your Reeling account. 1. Your remote AI agent (for example, an OpenClaw instance running on a Hetzner VPS) calls reeling_publish_post via MCP or POST /api/v1/publish using your X-API-Key. 2. Reeling validates the payload, runs the Pre-Publish Spam & Shadowban Shield for Reddit, Quora, and Medium, and places the job into your encrypted Companion Queue (upload_status: "queued_for_companion"). 3. Within ~3 seconds, your Chrome browser's Reeling Companion picks up the queued job, executes the publication directly inside your genuine, logged-in browser session on x.com, medium.com, quora.com, or reddit.com, and reports the live published URL back to the Reeling backend. 4. The API/MCP call resolves synchronously with the live post URL (published: true, url: "https://x.com/..."). ``` // MCP Tool Call: reeling_publish_post { "project_id": "9c282b95-fb6c-4a0d-a7bf-3459ef02c0a5", "platforms": ["x", "reddit", "medium", "quora"], "title": "5 Lessons from Scaling Our AI Voice Pipeline", "caption": "Here is what actually worked when we moved our inference pipeline to production...", "subreddit": "SaaS" } ``` #### Step-by-step setup for Chrome and remote MCP agents Setting up the bridge takes less than two minutes: 1. Log into your X (Twitter), Medium, Quora, and Reddit accounts in Google Chrome. 2. Open chrome://extensions, enable Developer mode, click Load unpacked, and select the reeling-companion extension directory. 3. Click the Reeling Companion icon in your Chrome toolbar to verify that Browser Sessions show "Logged in" for X, Medium, Quora, and Reddit. 4. In Reeling (/connect), connect your X, Medium, Quora, and Reddit handles in Companion mode. 5. Configure reeling-mcp in your AI agent (Claude Desktop, Cursor, or OpenClaw) with your REELING_API_KEY. - Connect X, Medium, Quora & Reddit on Reeling: /connect - Reeling MCP Server Setup Guide: /developers/mcp Source: Reeling Connect Channels & Companion Setup: https://reeling.app/connect Source: Reeling MCP & REST API Reference: https://reeling.app/developers ### Reeling MCP discovery: a reproducible public check https://reeling.app/blog/mcp-discovery-observations Published: 2026-10-20; modified: 2026-10-20; author: Reeling product team Inspect five public Reeling MCP discovery responses, the advertised tool names, raw observations and a script you can run yourself. #### What we observed At 2026-10-20T15:40:11.117Z, five sequential JSON-RPC tools/list requests to https://mcp.reeling.app/mcp each returned HTTP 200. Each response advertised the same 14 named tools. The measured request durations ranged from 62 to 330 milliseconds, with a median of 67 milliseconds. These are original observations from one local development machine. The durations include the network round trip and response parsing. They are not a service-level commitment, a sustained uptime measurement or a comparison with another provider. #### Reproduce the observation The dependency-free script sends only tools/list requests. It does not provide a credential or call a publishing, generation, analytics or account-discovery tool. The JSON output records the method, timestamp, tool names, durations and a SHA-256 checksum of the script. Clone the example repository, inspect the script, then run the command below. Your durations and advertised tool set may differ as the service changes. Keep the timestamp with the raw result when comparing observations. ``` git clone https://github.com/yomariano/reeling-examples.git cd reeling-examples node examples/observe-mcp.mjs --samples=5 --write ``` - Inspect the observation script: https://github.com/yomariano/reeling-examples/blob/main/examples/observe-mcp.mjs - Download the dated raw observations: /resources/evidence/mcp-observations-2026-10-20.json #### The advertised tool surface The returned names cover project/channel discovery, publishing and status, analytics, inbox operations and generation. An advertised tool is an interface, not evidence that an account can execute it. The adapter can describe platform capabilities that still depend on authorization, plan eligibility and provider access. Public metadata discovery is useful for checking the endpoint and inspecting the contract before configuring a credential. It does not test a full client session, authenticate a user or demonstrate successful media publication. ``` reeling_adapt_content_ai reeling_create_storyboard reeling_evaluate_content_jev reeling_generate_video reeling_get_analytics reeling_get_channel_options reeling_get_inbox reeling_get_post_status reeling_list_channels reeling_list_projects reeling_publish_post reeling_reply_to_comment reeling_stitch_storyboard reeling_sync_metrics ``` #### Keep account evidence separate The earlier October 15 reference check used an authorized key for two REST GET requests. It reported one project and six channels while excluding account identifiers and credentials from the saved result. That is a different observation from the public MCP metadata check described here. Neither observation uploaded, scheduled or published content. To evaluate your own workflow, first run offline fixtures, then inspect the exact account and channel through a deliberate read. A real publishing acceptance test requires the intended media, visibility and destination checks. - Dated REST read-access evidence: /resources/evidence/readonly-check-2026-10-15.json - Reeling MCP setup guide: /developers/mcp - Runnable example workflow: /developers/examples #### How to cite this check Cite the observation date, exact endpoint, method and five-request sample alongside the raw JSON. Report the narrow result: public tool metadata was readable at that time. Do not describe these five samples as proof of general availability, publishing reliability or customer performance. If you run the same script later, retain its source checksum and any failures. A partial run should remain partial; successful samples should not silently replace an unavailable endpoint or parse error. Source: Raw public MCP observation data: https://reeling.app/resources/evidence/mcp-observations-2026-10-20.json Source: Reproducible source: https://github.com/yomariano/reeling-examples/blob/main/examples/observe-mcp.mjs Source: MCP architecture documentation: https://modelcontextprotocol.io/docs/learn/architecture ### TikTok, Instagram and YouTube publishing API workflows https://reeling.app/blog/publishing-api-workflows Published: 2026-10-20; modified: 2026-10-20; author: Reeling product team Compare video-publishing workflows for TikTok, Instagram and YouTube. Review account access, visibility, processing and delivery checks. #### Define the workflow you actually need Start with one channel, one owned video and one intended audience. Decide whether the job needs a draft, private upload, scheduled publication or public delivery. These are different outcomes, so a useful API comparison must keep them separate. The comparison below concerns implementation behavior and primary provider documentation reviewed on October 20, 2026. It is not a side-by-side performance benchmark, a live three-platform upload test or a claim that every account is approved. #### YouTube: make privacy explicit YouTube’s video insertion method accepts metadata and status fields, including privacyStatus and the audience declaration. Choose the value deliberately instead of relying on defaults. For an initial integration check, the supplied Reeling example requests private visibility. After upload, inspect processing and visibility and check the channel. An uploaded file is not automatically the public Short your campaign expects. The final video format and YouTube’s current behavior still determine how it is presented. - YouTube video insertion reference: https://developers.google.com/youtube/v3/docs/videos/insert #### TikTok: distinguish inbox delivery and Direct Post TikTok Direct Post requires appropriate app scope and authorization from the target creator. Its documentation describes visibility restrictions for unaudited clients and an audit to lift them. Account-specific creator options matter before selecting visibility and interactions. Reeling also supports inbox delivery, where the creator finishes in TikTok. An inbox receipt establishes delivery into that workflow, not a public post. Design the handoff so the creator knows what remains to do. - TikTok Direct Post requirements: https://developers.tiktok.com/docs/content-posting-api-get-started #### Instagram: check professional-account access Reeling’s Instagram implementation uses an authorized Business or Creator connection, and the maintained platform reference documents the current access phase. The media must be ready for the publishing flow and the account must grant the needed permissions. Check the real connection and current Meta requirements before promising that another customer account can use it. A successful tester connection is useful evidence for that account, not blanket approval for every account. - Instagram content publishing documentation: https://developers.facebook.com/docs/instagram-platform/content-publishing/ #### Choose direct APIs or a shared adapter deliberately Direct provider APIs expose each platform’s contract in detail and leave your application responsible for authorization, uploads and status handling. A shared adapter can normalize request construction and scheduling, but it may not expose every provider option. For Reeling, use the REST example when exact channel IDs or platform-specific controls are required. Check the MCP tool schema before assuming it can carry the same settings. Keep the underlying provider documentation nearby and use the narrowest workflow that completes the job. - Reeling requirements comparison: /developers/social-publishing-api - Runnable API examples: /developers/examples - Reeling MCP setup: /developers/mcp #### Evaluate with a small acceptance test Write down the exact account, media shape, intended time, privacy and success evidence. Run one reviewed destination first, retain the post ID and inspect its final state before expanding to other channels. Compare results on the outcome you chose. Do not combine a private upload, inbox handoff and public post into a single “published” success count. The failure-monitoring guide and example polling code provide a concrete way to preserve those distinctions. - Monitor social publishing failures: /blog/monitor-social-publishing-failures - Plan the file-size budget: /tools/video-file-size-calculator Source: Reeling developer reference: https://reeling.app/developers/api Source: Runnable source and test fixtures: https://github.com/yomariano/reeling-examples Source: Current publishing requirements: https://reeling.app/developers/social-publishing-api ### Monitor social publishing failures without duplicate posts https://reeling.app/blog/monitor-social-publishing-failures Published: 2026-10-20; modified: 2026-10-20; author: Reeling product team Build bounded status polling for social video publishing. Separate processing, partial failures and public delivery before retrying a post. #### Save the receipt before doing anything else A publishing request can create a post before the client receives its response. Store the post ID, selected channel, project, timestamp and a non-secret reference to the original media. Record the intended visibility too: a completed private upload is not a public campaign post. Do not put API keys or private response bodies in shared logs. If a POST times out before a post ID returns, the outcome is ambiguous. Check the account’s existing posts and request context before submitting the same file again. #### Read the destination results separately The Reeling status endpoint returns a top-level status and a publish_results array. Inspect each destination’s published flag, upload_status, public URL and error. A request can be accepted while the video is processing, and one destination can fail after another succeeds. A mixed result should become a mixed report. Preserve the successful destination and investigate the failed one. Do not retry the whole batch because one upload needs a corrected permission or caption. ``` const pendingFixture = { success: true, status: "processing", publish_results: [{ platform: "tiktok", success: true, published: false, upload_status: "PROCESSING" }] }; // Synthetic fixture: upload acceptance is not public publication. ``` #### Use a finite observation window The open-source example allows up to 12 status reads, five seconds apart. It stops early for a reported publication or failure and emits timedOut when the observation window ends. A scheduled post can remain pending beyond that window without being broken. Choose a window that fits the job and provider limits. Keep the last known state when network reads fail. Rate-limit errors should produce a wait or an explicit retry decision, not a tight loop. ``` node examples/poll-status.mjs node --env-file=.env examples/poll-status.mjs --live-read ``` - Executable polling example and tests: https://github.com/yomariano/reeling-examples/blob/main/test/examples.test.mjs #### Check the type of failure before retrying Authentication, project ownership, plan eligibility, channel permissions and media validation are different problems. A new subscription does not fix every 403, and a new upload does not fix a missing channel scope. Correct the cause using the platform’s actual response and account configuration. If the request reached a provider, check for the existing upload first. For TikTok inbox delivery, finish the post in the mobile app rather than treating the missing public URL as a failed API request. - Reeling API response and workflow reference: /developers/api - Platform publishing requirements: /developers/social-publishing-api #### Close the loop with a visible destination check A returned publication flag is the API’s report. For a real campaign, open the destination under the expected audience conditions and check the caption, media, account and visibility. Keep the public URL or the reason it cannot be verified. Track a practical outcome such as the proportion of reviewed posts with confirmed destination URLs. Keep “accepted,” “processing,” “published” and “unknown” distinct. The sample code does not establish delivery success rates or customer performance. Source: Reeling developer reference: https://reeling.app/developers/api Source: Runnable source and test fixtures: https://github.com/yomariano/reeling-examples Source: Current publishing requirements: https://reeling.app/developers/social-publishing-api ### Switch from Buffer to Reeling: a one-project pilot https://reeling.app/blog/switch-from-buffer-to-reeling Published: 2026-10-16; modified: 2026-10-16; author: Reeling Team A practical Buffer-to-Reeling switching guide: map accounts, reconnect channels, recreate a post and verify delivery before moving your queue. #### Start with your queue, not the channel count Write down the accounts you actually use, their queue times and timezone, and whether a post is sent automatically or needs a reminder on your phone. Treat those as separate workflows even when they belong to one social channel. Reeling project limits and Buffer channel limits describe different things; map the intended pilot explicitly. If Buffer’s free queue already covers your needs, there may be no reason to move. Reeling is worth evaluating when its project-based video preparation or API/MCP workflow solves a specific problem. Compare the same workload and billing period before making a purchase. - Dated Reeling vs Buffer comparison: https://reeling.app/vs/buffer #### Write a small acceptance test For a solo pilot, choose one project and one destination that Reeling currently supports for your account. Use one approved video, its caption, the intended publication time and the expected visibility. Record whether you need a first comment, a thread, a reminder or an approval; do not assume that a feature in your current queue exists in the new one. Success means the intended account has the expected post, at the intended visibility, and you can find its result afterward. A lower subscription total alone does not establish that the workflow is a suitable replacement. #### Reconnect one real project Create a Reeling account, open Projects and create the workspace for your pilot. Connect only the destinations in that pilot through their normal authorization flow. A connection in another scheduler does not transfer its credentials to Reeling. Confirm that the selected account, page or channel is the one you intend to publish to. Check the current platform requirements before paying for a larger rollout. Instagram currently requires tester access in Reeling. TikTok inbox delivery still requires you to finish the post in TikTok; it is not public Direct Post. The developer matrix describes publishing, metrics and inbox coverage separately. - Current account requirements and network coverage: https://reeling.app/developers#platform-rules #### Recreate one representative post Use media you own and a post whose destination requirements you understand. Copy the approved wording from your own source material, attach the final export, select the intended channel and check the schedule time and timezone. This guide describes a manual pilot: it does not promise an automatic import of queues, approvals, analytics history or social-account credentials. Keep the pilot entry in the old queue paused or removed before scheduling the same content in Reeling. Keep the rest of the old queue in place until you have agreed on a cutover time. A shared worksheet helps avoid a post being sent by both tools. - Download the migration worksheet (CSV): https://reeling.app/resources/scheduler-migration-worksheet.csv - Prepare a video from script to scheduled post: https://reeling.app/blog/prepare-and-verify-your-first-social-video #### Verify delivery before moving the queue At the agreed time, inspect the result for each destination and open the resulting post on the social platform. A queued or accepted request is not proof of a public post. For a TikTok inbox workflow, complete the post in TikTok and verify it there. Record the destination URL and the result in the worksheet. If delivery is unclear, inspect the existing post status before trying again. With the API, keep the returned post ID and read GET /api/v1/posts/:id. Do not repeat a publish request just because a response timed out: the first request may already have been accepted. If one destination succeeded and another failed, investigate that destination separately. - Post status and result interpretation: https://reeling.app/developers#endpoint-post-status #### Choose a cutover date and keep a fallback Move a small batch only after the pilot meets your acceptance criteria. Record the last post owned by the previous scheduler and the first post owned by Reeling. Recheck the timezone, account permissions and any manual completion steps. Keep an export or other permitted copy of the old schedule and reporting records before ending that subscription. If a required approval, inbox or reporting step fails the pilot, keep that workflow in the existing tool while you resolve it. This is a setup checklist based on the documented Reeling workflow, not a claim that we migrated a customer account or reproduced every competitor feature. Source: Buffer official plan details: https://buffer.com/pricing Source: Reeling current plans: https://reeling.app/pricing Source: Reeling publishing reference: https://reeling.app/developers ### Switch from Hootsuite to Reeling: a one-project pilot https://reeling.app/blog/switch-from-hootsuite-to-reeling Published: 2026-10-16; modified: 2026-10-16; author: Reeling Team A practical Hootsuite-to-Reeling switching guide: map accounts, reconnect channels, recreate a post and verify delivery before moving your queue. #### Separate publishing from your team operations List the jobs Hootsuite performs for your team: preparing posts, approvals, customer-care routing, reporting and any security or compliance requirements. Assign an owner to each requirement. Reeling’s publishing and developer workflow is not evidence that those other operations can move with it. Use the dated comparison for plan context, then decide which single publishing workflow is safe to evaluate separately. If a formal approval or enterprise control is mandatory, establish that it works before considering the wider migration. - Dated Reeling vs Hootsuite comparison: https://reeling.app/vs/hootsuite #### Preserve ownership and approval evidence Before moving a scheduled item, record its author, reviewer, approved copy, destination and planned time in your own approved system. Recreate the pilot only after the reviewer confirms the exact copy and media. An approval record in the previous scheduler is not automatically an approval record in Reeling. If you need different drafting, approval and publishing roles, test those roles with the intended accounts. Also decide where the team will keep historical reports and customer-care records. This publishing guide does not move message assignments, historical analytics or governance records. #### Reconnect one real project Create a Reeling account, open Projects and create the workspace for your pilot. Connect only the destinations in that pilot through their normal authorization flow. A connection in another scheduler does not transfer its credentials to Reeling. Confirm that the selected account, page or channel is the one you intend to publish to. Check the current platform requirements before paying for a larger rollout. Instagram currently requires tester access in Reeling. TikTok inbox delivery still requires you to finish the post in TikTok; it is not public Direct Post. The developer matrix describes publishing, metrics and inbox coverage separately. - Current account requirements and network coverage: https://reeling.app/developers#platform-rules #### Recreate one representative post Use media you own and a post whose destination requirements you understand. Copy the approved wording from your own source material, attach the final export, select the intended channel and check the schedule time and timezone. This guide describes a manual pilot: it does not promise an automatic import of queues, approvals, analytics history or social-account credentials. Keep the pilot entry in the old queue paused or removed before scheduling the same content in Reeling. Keep the rest of the old queue in place until you have agreed on a cutover time. A shared worksheet helps avoid a post being sent by both tools. - Download the migration worksheet (CSV): https://reeling.app/resources/scheduler-migration-worksheet.csv - Prepare a video from script to scheduled post: https://reeling.app/blog/prepare-and-verify-your-first-social-video #### Verify delivery before moving the queue At the agreed time, inspect the result for each destination and open the resulting post on the social platform. A queued or accepted request is not proof of a public post. For a TikTok inbox workflow, complete the post in TikTok and verify it there. Record the destination URL and the result in the worksheet. If delivery is unclear, inspect the existing post status before trying again. With the API, keep the returned post ID and read GET /api/v1/posts/:id. Do not repeat a publish request just because a response timed out: the first request may already have been accepted. If one destination succeeded and another failed, investigate that destination separately. - Post status and result interpretation: https://reeling.app/developers#endpoint-post-status #### Choose a cutover date and keep a fallback Move a small batch only after the pilot meets your acceptance criteria. Record the last post owned by the previous scheduler and the first post owned by Reeling. Recheck the timezone, account permissions and any manual completion steps. Keep an export or other permitted copy of the old schedule and reporting records before ending that subscription. If a required approval, inbox or reporting step fails the pilot, keep that workflow in the existing tool while you resolve it. This is a setup checklist based on the documented Reeling workflow, not a claim that we migrated a customer account or reproduced every competitor feature. Source: Hootsuite official plan details: https://www.hootsuite.com/plans Source: Reeling current plans: https://reeling.app/pricing Source: Reeling publishing reference: https://reeling.app/developers ### Switch from Metricool to Reeling: a one-project pilot https://reeling.app/blog/switch-from-metricool-to-reeling Published: 2026-10-16; modified: 2026-10-16; author: Reeling Team A practical Metricool-to-Reeling switching guide: map accounts, reconnect channels, recreate a post and verify delivery before moving your queue. #### Map brands to projects and destinations Create an inventory with one line for each brand and social account. Next to it, record the Reeling project that would own that destination. A brand allowance and a project allowance are not interchangeable; the number of accounts within each workspace also matters. For example, two brands each using YouTube and LinkedIn mean two projects and four connected channels in your planned Reeling setup. Check the live plan limits and account eligibility for those exact destinations. This is an illustrative inventory, not an imported customer account. - Dated Reeling vs Metricool comparison: https://reeling.app/vs/metricool #### Decide what happens to client reports If clients rely on your current reports, list their required fields, history range and delivery format before moving publishing. Export or retain records using the permissions available in your current account. Reeling’s metrics coverage differs by network; a successful publish does not establish equivalent reporting. Choose a pilot where you can compare the actual published post and the metrics Reeling returns. Keep report delivery in the current tool if the required fields are absent. Do the same review for any external automation: an API or MCP connection does not imply that its tools, data or limits match. #### Reconnect one real project Create a Reeling account, open Projects and create the workspace for your pilot. Connect only the destinations in that pilot through their normal authorization flow. A connection in another scheduler does not transfer its credentials to Reeling. Confirm that the selected account, page or channel is the one you intend to publish to. Check the current platform requirements before paying for a larger rollout. Instagram currently requires tester access in Reeling. TikTok inbox delivery still requires you to finish the post in TikTok; it is not public Direct Post. The developer matrix describes publishing, metrics and inbox coverage separately. - Current account requirements and network coverage: https://reeling.app/developers#platform-rules #### Recreate one representative post Use media you own and a post whose destination requirements you understand. Copy the approved wording from your own source material, attach the final export, select the intended channel and check the schedule time and timezone. This guide describes a manual pilot: it does not promise an automatic import of queues, approvals, analytics history or social-account credentials. Keep the pilot entry in the old queue paused or removed before scheduling the same content in Reeling. Keep the rest of the old queue in place until you have agreed on a cutover time. A shared worksheet helps avoid a post being sent by both tools. - Download the migration worksheet (CSV): https://reeling.app/resources/scheduler-migration-worksheet.csv - Prepare a video from script to scheduled post: https://reeling.app/blog/prepare-and-verify-your-first-social-video #### Verify delivery before moving the queue At the agreed time, inspect the result for each destination and open the resulting post on the social platform. A queued or accepted request is not proof of a public post. For a TikTok inbox workflow, complete the post in TikTok and verify it there. Record the destination URL and the result in the worksheet. If delivery is unclear, inspect the existing post status before trying again. With the API, keep the returned post ID and read GET /api/v1/posts/:id. Do not repeat a publish request just because a response timed out: the first request may already have been accepted. If one destination succeeded and another failed, investigate that destination separately. - Post status and result interpretation: https://reeling.app/developers#endpoint-post-status #### Choose a cutover date and keep a fallback Move a small batch only after the pilot meets your acceptance criteria. Record the last post owned by the previous scheduler and the first post owned by Reeling. Recheck the timezone, account permissions and any manual completion steps. Keep an export or other permitted copy of the old schedule and reporting records before ending that subscription. If a required approval, inbox or reporting step fails the pilot, keep that workflow in the existing tool while you resolve it. This is a setup checklist based on the documented Reeling workflow, not a claim that we migrated a customer account or reproduced every competitor feature. Source: Metricool official plan details: https://metricool.com/pricing/ Source: Reeling current plans: https://reeling.app/pricing Source: Reeling publishing reference: https://reeling.app/developers ### Switch from Later to Reeling: a one-project pilot https://reeling.app/blog/switch-from-later-to-reeling Published: 2026-10-16; modified: 2026-10-16; author: Reeling Team A practical Later-to-Reeling switching guide: map social sets to projects, reconnect channels, recreate a video post and verify delivery before moving. #### Map your Later social set to a Reeling project Write down the profiles inside your Later social set, your monthly post volume per profile, and whether your workflow depends on Later's visual Instagram grid preview or Link in Bio storefront. Reeling organizes work into projects and focuses on video storyboarding, scheduling and REST/MCP automation rather than Link in Bio hosting. If you rely on Later's Link in Bio page for profile traffic, keep that landing page or move it to an independent link tool before changing schedulers. Compare the same channel count and monthly video volume before deciding to move. - Dated Reeling vs Later comparison: https://reeling.app/vs/later #### Write a small acceptance test Choose one project and one destination that Reeling currently supports for your account. Use one approved vertical video, its caption, the intended schedule time and the expected visibility. Record whether you need auto-publishing or mobile notification completion. Success means the intended destination publishes the video at the scheduled time and you can verify the live platform URL afterward. A lower subscription price alone does not establish that the workflow fits your team. #### Reconnect one real project Create a Reeling account, open Projects and create the workspace for your pilot. Connect only the destinations in that pilot through their normal authorization flow. A connection in Later does not transfer its OAuth tokens or media library to Reeling. Check the current platform requirements before paying for a larger rollout. Instagram currently requires tester access in Reeling. TikTok inbox delivery requires you to finish the post in TikTok; it is not public Direct Post. The developer matrix describes publishing, metrics and inbox coverage separately. - Current account requirements and network coverage: https://reeling.app/developers#platform-rules #### Recreate one representative post Use media you own and a post whose destination requirements you understand. Copy the approved caption from your source material, attach the final video export, select the intended channel and verify the schedule time and timezone. This guide describes a manual pilot: it does not import Later media libraries, saved captions or analytics history. Pause or remove the pilot entry in Later before scheduling the same post in Reeling. Keep the rest of your Later calendar intact until you have verified delivery and agreed on a cutover date. - Download the migration worksheet (CSV): https://reeling.app/resources/scheduler-migration-worksheet.csv - Prepare a video from script to scheduled post: https://reeling.app/blog/prepare-and-verify-your-first-social-video #### Verify delivery before moving the calendar At the scheduled time, inspect the result for each destination and open the live post on the social network. A queued or accepted request is not proof of public publication. For a TikTok inbox workflow, complete the post in the TikTok app and verify it there. If delivery is unclear, inspect GET /api/v1/posts/:id or the workspace status before retrying. Do not send a duplicate publish request before checking whether the first request was already accepted. - Post status and result interpretation: https://reeling.app/developers#endpoint-post-status #### Choose a cutover date and keep a fallback Move your remaining scheduled posts only after the pilot meets your acceptance criteria. Record the final post published by Later and the first post owned by Reeling. Export any historical analytics or media assets you need from Later before closing that subscription. Source: Later official plan details: https://later.com/pricing/ Source: Reeling current plans: https://reeling.app/pricing Source: Reeling publishing reference: https://reeling.app/developers ### Switch from Publer to Reeling: a one-project pilot https://reeling.app/blog/switch-from-publer-to-reeling Published: 2026-10-16; modified: 2026-10-16; author: Reeling Team A practical Publer-to-Reeling switching guide: audit per-account queues, reconnect one project, test video or API publishing and verify delivery. #### Audit per-account queues and recurring automations List the social accounts you pay for in Publer, along with any RSS auto-posters, recurring evergreen queues or CSV bulk imports. Reeling bundles up to 10 channels on Creator and focuses on project-based video preparation and direct REST/MCP automation rather than RSS feed ingestion. If you want to trigger posts programmatically from your own scripts or an AI agent, Reeling's Creator plan includes REST API and MCP server access. Compare your actual channel list and automation method before switching. - Dated Reeling vs Publer comparison: https://reeling.app/vs/publer #### Write a small acceptance test Choose one project and one supported destination for your pilot. Select one approved video, its caption, the planned schedule time and the intended visibility. Write down how you will verify that the post went live on the destination network. Success means the post appears on the target account with the expected media and caption, and you can inspect its per-destination status record afterward. #### Reconnect one real project Create a Reeling account, open Projects and create the workspace for your pilot. Connect only the destinations in that pilot through their normal OAuth flow. Credentials and connected accounts in Publer do not transfer automatically. Check the current platform requirements before migrating additional accounts. Instagram currently requires tester access in Reeling. TikTok inbox delivery requires manual completion in the TikTok app; it is not public Direct Post. - Current account requirements and network coverage: https://reeling.app/developers#platform-rules #### Recreate one representative post Attach your owned video export, enter the approved caption, choose the target channel and confirm the schedule time and timezone. This manual pilot does not import Publer queues, CSV templates or historical analytics. Pause the matching item in Publer so the same video is not published twice. Keep the rest of your Publer schedule active until the pilot post is verified. - Download the migration worksheet (CSV): https://reeling.app/resources/scheduler-migration-worksheet.csv - Prepare a video from script to scheduled post: https://reeling.app/blog/prepare-and-verify-your-first-social-video #### Verify delivery before moving the queue At the scheduled time, check the destination result in Reeling and open the published post on the social platform. An accepted or queued status is not proof of public publication. If you use the API or MCP server, record the post ID and query GET /api/v1/posts/:id to inspect per-channel status before retrying. - Post status and result interpretation: https://reeling.app/developers#endpoint-post-status #### Choose a cutover date and keep a fallback Move additional accounts only after the pilot succeeds. Record the last post scheduled in Publer and the first post scheduled in Reeling, and export any required PDF or CSV reports from Publer before ending your subscription. Source: Publer official plan details: https://publer.com/plans Source: Reeling current plans: https://reeling.app/pricing Source: Reeling publishing reference: https://reeling.app/developers ### Switch from Sprout Social to Reeling: a one-project pilot https://reeling.app/blog/switch-from-sprout-social-to-reeling Published: 2026-10-16; modified: 2026-10-16; author: Reeling Team A practical Sprout Social-to-Reeling switching guide: separate enterprise care from video publishing, test one project and verify destination delivery. #### Separate publishing from enterprise customer care List every workflow currently handled in Sprout Social: video publishing, Smart Inbox routing, review management, CRM ticketing, social listening and multi-step approval governance. Reeling is a lightweight video publishing and REST/MCP workspace, not an enterprise customer-care or listening suite. Evaluate Reeling only when your actual need is project-based video preparation and scheduling without per-seat enterprise overhead. If SLA tracking, CRM tickets or formal compliance archives are mandatory, keep those operations in an enterprise system. - Dated Reeling vs Sprout Social comparison: https://reeling.app/vs/sprout-social #### Preserve approval and reporting records Before testing a post in Reeling, record the approved copy, video asset, owner and target schedule in your team's system of record. Approval history, message assignments and historical reports in Sprout Social do not transfer to Reeling. Verify whether Reeling's per-network metrics and inbox coverage satisfy your reporting needs before reducing seat counts on your current contract. #### Reconnect one real project Create a Reeling account, open Projects and create the workspace for your pilot. Connect only the pilot destinations through their standard authorization flow. Confirm that the connected profile or channel matches your intended brand account. Check the current platform requirements before planning a broader rollout. Instagram currently requires tester access in Reeling. TikTok inbox delivery requires manual completion in TikTok; it is not public Direct Post. - Current account requirements and network coverage: https://reeling.app/developers#platform-rules #### Recreate one representative post Use owned media and approved copy for a single destination. Attach the final video export, select the channel and verify the schedule time and timezone. Pause the corresponding draft in Sprout Social so the post is not sent by both platforms. Use the migration worksheet to track the pilot post ID, scheduled time and verification owner. - Download the migration worksheet (CSV): https://reeling.app/resources/scheduler-migration-worksheet.csv - Prepare a video from script to scheduled post: https://reeling.app/blog/prepare-and-verify-your-first-social-video #### Verify delivery before moving the queue At the scheduled time, inspect the per-destination result in Reeling and open the live post on the target platform. An accepted or queued status is not proof of public publication. With the REST API or MCP server, inspect GET /api/v1/posts/:id before retrying any uncertain request. - Post status and result interpretation: https://reeling.app/developers#endpoint-post-status #### Choose a cutover date and keep a fallback Export historical analytics, campaign tags and compliance records from Sprout Social before changing your renewal terms. Move publishing in small, verified batches and keep any required customer-care or listening workflows in place. Source: Sprout Social official plan details: https://sproutsocial.com/pricing/ Source: Reeling current plans: https://reeling.app/pricing Source: Reeling publishing reference: https://reeling.app/developers ### From script to scheduled video: a complete preparation checklist https://reeling.app/blog/prepare-and-verify-your-first-social-video Published: 2026-10-16; modified: 2026-10-16; author: Reeling Team Prepare a short social video with a timing budget, captions, export settings and a documented publishing check. Includes a free reusable checklist. #### Set a 30-second brief Our illustrative video answers one question: how do I choose between two export sizes? It has a spoken explanation, an on-screen comparison and a next step. At an assumed 150 words per minute, 30 seconds with 3 seconds reserved for pauses gives a budget of floor((30 − 3) × 150 / 60) = 67 spoken words. This is a planning estimate, not a measured delivery speed. Write the script, spell out numbers as you intend to say them, and rehearse it aloud. Put the rehearsal’s speaking pace into the timer. If the script runs long, shorten the explanation before changing the target duration. - Time the script: https://reeling.app/tools/video-script-timer - Draft an editable opening: https://reeling.app/tools/hook-generator #### Frame the actual demonstration For a 1080 × 1920 portrait canvas, inspect the source media with the aspect-ratio calculator. Compare cropping and fitting, then make the real edit in your video editor. Check that captions, faces and interface labels remain legible on a phone. The calculator models centered geometry; it does not crop or export your file. - Check the crop and fit geometry: https://reeling.app/tools/video-aspect-ratio-calculator #### Prepare captions and watch them in sync If your editor or destination needs SRT or WebVTT, convert the owned subtitle file and inspect the first, middle and last cues against the video. A uniform timing shift can fix a constant offset; it cannot fix captions that progressively drift. Re-export or retime those cues in your editor. The free converter prepares a caption file. It does not burn captions into a video, and this guide does not claim that Reeling uploads sidecar caption files to every platform. Render captions in your editor or use the destination’s supported caption workflow. - Convert or shift subtitle timings: https://reeling.app/tools/subtitle-converter #### Set an export budget, then inspect the file A 30-second video at 8 Mbps video plus 0.128 Mbps audio has an estimated payload of (8 + 0.128) × 30 ÷ 8 = 30.48 MB, using decimal megabytes. Container overhead and variable bitrate can change the actual file size. Use the calculator to explore a budget, then inspect the exported file and the destination’s current limit. Watch the export once from beginning to end. A file-size calculation cannot tell you whether a cut is clear, audio is intelligible or a platform will accept the codec. - Estimate file size and bitrate: https://reeling.app/tools/video-file-size-calculator #### Connect, schedule and verify the result Open a Reeling project, connect the intended account, attach the finished media and confirm the caption, destination, visibility and timezone. Review the current network requirements first. Schedule one controlled post and record the result for each destination. For TikTok inbox delivery, finish the post in TikTok before marking it published. With API automation, read the channel options before sending a write request. Save the returned post ID and inspect its status before retrying a timeout. A documented API example is not proof that a live post was published. - Account and platform requirements: https://reeling.app/developers#platform-rules - Read-only API connection check: https://reeling.app/developers#read-only-check #### Keep a reusable record Download the checklist and record the brief, rehearsal, frame, caption check, actual export size, scheduled time and destination result. Leave a field blank until you have checked it. The checklist is original preparation material, not a case study or a claim of increased reach. If the post contains a campaign link, use consistent UTM names and compare downstream visits with your own activation or sales data. Views and scheduling success do not prove revenue. - Download the video preparation checklist: https://reeling.app/resources/video-preparation-checklist.txt - Build a campaign link: https://reeling.app/tools/utm-builder Source: Reeling platform requirements: https://reeling.app/developers#platform-rules Source: Reeling creator tools and calculation limits: https://reeling.app/tools ### Convert SRT and VTT captions without losing sync https://reeling.app/blog/convert-srt-vtt-and-sync-captions Published: 2026-10-16; modified: 2026-10-16; author: Reeling Team Convert subtitle formats, apply a timing offset and check the exported captions against your video. A worked SRT-to-WebVTT example. #### Start with the exact video edit A subtitle file belongs to a particular timeline. If you remove a two-second introduction from the video, the old captions can become two seconds late even though every sentence is still correct. Keep the original subtitle file, identify the final video edit, and work on a copy. Format conversion alone will not discover that editing change. In this example, the first caption starts at 1.000 seconds and ends at 3.250 seconds. Open the subtitle converter and leave the timing shift at 0. Select WebVTT output. The text and cue interval should stay the same; the timestamp separator changes and the output gains a WEBVTT header. ``` 1 00:00:01,000 --> 00:00:03,250 One recording. Three useful clips. ``` #### Convert the file, then inspect the result Paste SRT text or choose a local UTF-8 file. Download the .vtt result and import it into the editor or player that needs WebVTT. The converter processes the text in your browser and does not upload a video. For the reverse direction, choose SRT and download the .srt file. Ordinary caption text and whole-cue timing are the supported workflow. WebVTT positioning and cue identifiers do not have equivalent handling in this SRT export; the tool reports their removal. Notes are omitted. Markup stays literal, so check whether your destination interprets it correctly. Files with styles, regions, timestamp maps or inline karaoke times need a subtitle editor. #### Use one offset only when the whole track is displaced Suppose an editor added a half-second title card before the footage. Enter 0.500 as the shift. The example cue now starts at 1.500 and ends at 3.750 seconds; its duration is unchanged. A negative shift moves every cue earlier. If any cue would cross before zero, the converter stops and asks you to reduce the shift. A single offset is appropriate only when the same displacement applies throughout the track. If the first caption matches but a later one drifts, inspect cuts, playback speed and the source export. Repeatedly changing the global offset will not repair a timeline that differs in several places. ``` WEBVTT 1 00:00:01.500 --> 00:00:03.750 One recording. Three useful clips. ``` #### Check three moments before publishing Preview the first spoken line, a line near the middle and the final spoken line. Listen for the start of each phrase and watch the caption disappear. Check a multiline cue on a small screen, especially around names, punctuation and numbers. Review the actual exported video if captions are burned in; previewing the subtitle file alone cannot establish that the render used it. Save the final subtitle file beside the final video with matching names. If you make another timeline edit, repeat the checks. The useful deliverable is a readable, synchronized track attached to the correct edit, not merely a file with the right extension. Source: MDN: Web Video Text Tracks Format: https://developer.mozilla.org/en-US/docs/Web/API/WebVTT_API/Web_Video_Text_Tracks_Format ### Write a video script that fits the time you have https://reeling.app/blog/write-a-script-that-fits-your-video Published: 2026-10-16; modified: 2026-10-16; author: Reeling Team Calculate a spoken-word budget, reserve time for pauses and revise a short video script using your own measured delivery pace. #### Budget the spoken seconds first Imagine a 30-second product tip with a three-second pause for a demonstration. That leaves 27 seconds for speech. At an illustrative pace of 150 words per minute, the word budget is 67 whole words: 27 × 150 ÷ 60, rounded down. This is a planning assumption, not a recommended speed for every speaker. Open the script timer, set the target to 30, pauses to 3 and pace to 150. Paste only the words you intend to say. A 60-word script takes an estimated 24 seconds of speech and three seconds of pauses, leaving about three seconds within the target. #### Measure your own pace with a short read Choose a passage similar to the video you are making. Read it naturally and time the spoken delivery. A 90-word passage delivered in 45 seconds gives 120 words per minute: 90 ÷ 45 × 60. Enter that pace in the tool. The same 60-word script now needs 30 seconds of speech, before the planned pauses. Decide whether your measurement includes deliberate gaps. If a timed read already includes a three-second demonstration, do not count the same gap again as a pause allowance. Use a short uninterrupted read to estimate speech pace, then budget demonstrations, breaths and on-screen reading separately. #### Cut an idea before you accelerate the delivery If the estimate exceeds the target, look for a second idea that belongs in another clip. Remove repeated setup, long introductions and instructions that the viewer can already see. Keep the evidence needed to support the main point. Speaking faster may make the number fit while making the explanation harder to follow. For example, “In today’s video I am going to show you a useful way to prepare your next recording” can become “Choose one question before you record.” The shorter line makes a concrete promise. Follow it with an example that delivers that promise rather than several unrelated tips. #### Write the words you will actually pronounce A script containing “€1,250”, “API” or a long URL can take more speaking time than a simple word count implies. Write out the intended pronunciation when estimating. Remove stage directions such as “[show dashboard]” from the spoken text and include their duration in the pause allowance instead. The timer counts letter-and-number word groups, keeps internal apostrophes and hyphens together, and ignores punctuation-only marks. That makes it useful for space-separated scripts, but it is not a language-aware speech model. For scripts without word spaces, or dense technical narration, rely more heavily on a real timed rehearsal. #### Rehearse the final cut, not just the draft Read the finished script aloud while performing the planned demonstration. Notice where you need another breath or where the viewer needs a moment to understand a visual. Adjust the script or the target length, then rehearse again. Leave enough time for the final instruction to be understood. Keep the measured pace as a starting point for similar videos. A quiet explanation, a fast montage and a detailed tutorial can need different delivery. The calculator helps expose the trade-off between words and time; your recorded rehearsal is the final check. Source: University of Melbourne: Speaking clearly: https://students.unimelb.edu.au/academic-skills/communication-skills-study-assessment/oral-assessments/speaking-clearly ### Work backward from a video file size budget https://reeling.app/blog/video-file-size-and-bitrate-budget Published: 2026-10-16; modified: 2026-10-16; author: Reeling Team Estimate video size in MB and MiB, include audio bitrate and calculate a practical export budget with room for container overhead. #### Separate duration, bitrate and file size Duration says how long the video plays. Bitrate describes how much encoded data is used per second. File size is the total stored data. Resolution affects the encoding problem, but resolution alone does not determine the file size. Two exports with the same dimensions can have very different bitrates. For a worked estimate, use a 60-second clip, 8 Mbps video and 128 kbps audio. Convert both rates to bits per second, add them, multiply by 60 and divide by eight to get bytes. The media payload is 60,960,000 bytes, or 60.96 decimal MB. ``` 60 × (8,000,000 + 128,000) ÷ 8 = 60,960,000 bytes = 60.96 MB ≈ 58.14 MiB ``` #### Check which size unit you are reading A decimal megabyte is 1,000,000 bytes. A binary mebibyte is 1,048,576 bytes. The same example can therefore appear as roughly 60.96 MB or 58.14 MiB without any data disappearing. Use the unit in the upload requirement and compare it with the exact exported byte count when a limit is close. Open the video size calculator in file-size mode to see both units. Remember that the result estimates audio and video payload. Container metadata and other tracks can add bytes to the finished file. An estimate just under a hard limit needs room for that difference. #### Work backward from a 50 MB budget Switch to video bitrate from file budget. Keep the duration at 60 seconds and audio at 128 kbps, enter 50 MB and reserve 5%. That leaves 47.5 MB for the media payload. Divide its bits by 60 seconds and subtract the audio rate. The video budget is approximately 6.2053 Mbps. The 5% reserve is an editable planning allowance, not a promise about every container or encoder. Round the encoder setting down and inspect the actual export. If audio alone uses the available payload budget, the tool asks for a larger file budget, shorter duration or lower audio bitrate. ``` Payload budget = 50 MB × 0.95 = 47.5 MB Total bitrate = 47.5 × 8 ÷ 60 ≈ 6.3333 Mbps Video budget = 6.3333 − 0.128 ≈ 6.2053 Mbps ``` #### Choose a rate that survives a real sample A file budget does not establish visual quality. Export a short representative section containing motion, faces, fine text or other detail that matters to your clip. Compare it with the source at the size your audience will watch. If the quality is unacceptable, shorten the edit, reconsider the dimensions or choose another delivery route instead of treating the number as an ideal preset. Use average bitrates for estimates when your encoder provides them. Variable bitrate and quality-based encoding can produce different sizes for different scenes. FFmpeg’s documentation distinguishes bitrate controls and encoding behavior; the calculator itself does not run an encoder. #### Verify the final file before scheduling After the full export, inspect its exact size, duration, sound and captions. Check the destination’s current requirements for format, dimensions and duration as well as file size. Passing one limit does not establish that every other requirement is met. Save the export settings with the final media so you can reproduce the result. The calculator is useful before a long render or upload; the finished file is the evidence you use for the publishing decision. Source: FFmpeg: encoding and bitrate options: https://ffmpeg.org/ffmpeg.html ### A practical UTM naming system for social campaigns https://reeling.app/blog/utm-links-for-social-campaigns Published: 2026-10-16; modified: 2026-10-16; author: Reeling Team Build consistent campaign links, distinguish placements and check your destination with a worked social campaign example and a free UTM builder. #### Start with the question you want the link to answer Suppose you are promoting an autumn workshop through an Instagram profile link, a LinkedIn post and an email. You want to compare website visits from those placements. Give the workshop one campaign name and each referring channel its own source. Keep the destination page the same while you compare placements; otherwise a change in page design or offer can confuse the comparison. A tagged link labels a visit. It cannot tell you how many people saw a post without clicking, or prove that a creative caused a purchase. #### Write a naming sheet before making links For this example, use autumn-workshop as the campaign, instagram as the source, social as the medium and profile-link as the content label. The LinkedIn version changes source to linkedin and content to founder-post. The email changes source to newsletter, medium to email and content to first-announcement. This is an example convention, not a universal list of channel names. Pick names your team understands and use the same spelling and capitalization each time. Keep customer names, email addresses and other personal details out of every field. ``` Placement source medium campaign content Instagram profile instagram social autumn-workshop profile-link LinkedIn post linkedin social autumn-workshop founder-post Newsletter newsletter email autumn-workshop first-announcement ``` #### Build the URL without losing its existing parameters Open the free builder and replace its example destination with your landing page. Source, medium and campaign are required in the tool. Content and keyword are optional. If your destination already selects a plan or jumps to a section, keep those parts. In the worked URL below, plan=starter still selects the plan and #dates still identifies the section. The builder replaces only the five UTM fields it exposes; it preserves other parameters. Empty optional fields remove their old values, so an old creative label cannot silently survive into a new link. ``` https://example.com/workshop?plan=starter&utm_source=instagram&utm_medium=social&utm_campaign=autumn-workshop&utm_content=profile-link#dates ``` - Open the free UTM campaign link builder: /tools/utm-builder #### Run a small check before sharing widely Copy the generated link into a new browser tab. Does it reach the intended page and section? Does the page behave correctly with its query string? If a redirect is involved, check that the campaign parameters survive it. Then make a controlled visit using an analytics setup you can inspect. In Google Analytics, campaign dimensions are available in the Traffic acquisition report. Consent, filtering and reporting delays can affect what appears, so one missing visit does not establish that the URL is broken. The builder itself does not install analytics or verify a visit. #### Keep a record beside your publishing calendar Save the final URL, placement, campaign name and intended publishing date in a shared sheet. When you schedule a post, copy from that record instead of rebuilding the link from memory. If you revise a placement, update the record too. Keep an untagged canonical destination in a separate column so someone checking the page can distinguish the base address from a campaign link. Reeling can help prepare and schedule supported posts; the link builder remains useful even if you publish manually. - Review Reeling publishing requirements: /developers#platform-rules - Explore publishing plans: /pricing #### Compare like with like, then decide what to try next Look at a comparable time window for each placement and record when the links actually went live. Check visits alongside the business action you care about, using the same definition for every placement. A small number of visits is a weak basis for ranking creative ideas. If two links differ in audience, placement, timing and wording, the report does not isolate which change mattered. Use the first campaign to find missing tags and confusing names; use the next to ask a narrower question. A tidy naming system makes that second campaign much easier to interpret. Source: Google Analytics: campaign URL parameters and reports: https://support.google.com/analytics/answer/10917952?hl=en Source: Reeling UTM campaign link builder: /tools/utm-builder ### Crop or fit? Prepare one video for three shapes https://reeling.app/blog/crop-or-fit-social-video Published: 2026-10-16; modified: 2026-10-16; author: Reeling Team Compare portrait, square and landscape framing with worked crop and padding calculations. Use the free video aspect ratio calculator before editing. #### Separate the canvas from the footage Your source dimensions describe the recorded frame. Your output canvas describes the shape you want to export. A 1920 × 1080 recording has a 16:9 ratio; a 1080 × 1920 canvas has a 9:16 ratio. Reversing those numbers does not rotate or recompose the subject. You have to decide what should happen to the image inside the new shape. This guide uses example canvases, not a statement of any platform’s current upload limits. Check the destination’s requirements when you export. #### Use crop when filling the frame matters most To fill a canvas without stretching the image, scale both source dimensions by the larger of the width and height scale factors. For a 1920 × 1080 source and a 1080 × 1920 output, the height determines the scale: 1920 / 1080 ≈ 1.778. The scaled image is about 3413.3 × 1920 pixels. A centered 1080-pixel-wide crop removes about 1166.7 pixels from each side of that scaled image. Only 31.6% of the original image area remains. A person centered in the recording might survive; a product sitting near an edge might not. ``` scale = max(output width / source width, output height / source height) scaled width = source width × scale scaled height = source height × scale trim per side = (scaled width − output width) / 2 ``` - Try this example in the video aspect ratio calculator: /tools/video-aspect-ratio-calculator #### Use fit when every edge needs to stay visible Fit uses the smaller scale factor so the entire source remains inside the canvas. In the same example, 1080 / 1920 = 0.5625, so the image becomes 1080 × 607.5 pixels. That leaves 1312.5 pixels vertically, or 656.25 above and below when centered. Those spaces can remain bars or become a deliberate layout in your editor. The calculator reports the geometry and illustrates black padding; it does not generate a blurred background or export a finished video. Editors round fractional pixel positions when they render. #### Compare the square version too A 1080 × 1080 square crop of the same source uses a scale of 1. The crop trims 420 pixels from each horizontal edge and keeps 56.25% of the source area. A square fit instead scales to 1080 × 607.5 and adds about 236.25 pixels above and below. The landscape 1920 × 1080 canvas needs neither crop nor padding. These calculations show why a single automatic center crop is not a complete repurposing strategy: the amount of surviving context changes substantially between shapes. ``` 1920 × 1080 source → centered crop Portrait 1080 × 1920: 31.64% of source area remains Square 1080 × 1080: 56.25% of source area remains Wide 1920 × 1080: 100% of source area remains ``` #### Inspect the opening, the widest gesture and the final frame Before exporting, scrub the footage rather than judging only its thumbnail. Check a moment where the subject moves sideways, a frame containing a product label and the point where any text changes. Reposition the crop when necessary. Keep captions and essential labels inside the visible area, then inspect the destination’s own preview for interface overlays. If the source is a screen recording with small text, fitting may preserve the content while making it too small to read. Re-recording a closer view or editing a separate composition can be a better decision than forcing the original into every shape. #### Export and review a short sample first The calculator can flag enlargement, but it cannot measure whether the result looks sharp. A 1.778× enlargement adds output pixels without adding captured detail. Export a short representative segment, play it at its intended display size and check the subject, text and motion. Once the framing works, export the whole piece and review the final file. Then pair it with an opening line that matches the actual video and a tagged destination link if you are asking people to visit your website. - Draft a video opening with the hook template builder: /tools/hook-generator - Build a tagged campaign link: /tools/utm-builder - Check supported publishing destinations: /developers#platform-rules Source: MDN: contain and cover fitting behavior: https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/object-fit Source: Reeling video aspect ratio calculator and worked geometry: /tools/video-aspect-ratio-calculator ### Connect Claude and Cursor to Reeling MCP https://reeling.app/blog/claude-cursor-mcp-social-media-automation Published: 2026-10-12; modified: 2026-10-20; author: Reeling product team Configure the Reeling MCP server, check projects and channels, and review publishing permissions before enabling write tools. #### Before you connect Use Creator or Agency for API/MCP access. Create the intended project and connect its channels in Reeling, then create a key in Settings > API & Automation. Install Node.js 20 or later for the reference check. Keep the key in a local secret environment; do not commit it, put it in a URL, paste it into a chat, or include it in screenshots. The current key is not a read-only credential: control tool approval in the MCP client. #### Configure the local server Use this command-and-args shape in your MCP client configuration. Replace YOUR_API_KEY locally. The GitHub package contains the Reeling tool definitions; check your client documentation for the configuration file location and restart or reload its MCP connection after saving. ``` { "mcpServers": { "reeling": { "command": "npx", "args": [ "-y", "github:yomariano/reeling-mcp#v1.0.1" ], "env": { "REELING_API_KEY": "YOUR_API_KEY", "REELING_API_URL": "https://api.reeling.app" } } } } ``` #### Run the offline reference first Download the read-only check below, inspect its source, and run it without credentials. It uses a synthetic one-project, one-channel fixture and makes no network requests. This is a reproducible example of the output shape, not proof that a live account is connected. The reference tests cover project selection, API errors, malformed responses and the absence of write requests. ``` node reeling-readonly-check.mjs --dry-run ``` - Download the Node.js read-only reference: /resources/reeling-readonly-check.mjs #### Understand the example result This abbreviated output is illustrative fixture data. publicUploads: false is deliberately included: a configured connection does not mean it can publish publicly. publicationChecked stays false even in live mode, because this check never uploads or schedules anything. ``` { "mode": "offline_fixture", "readAccessChecked": false, "projectCount": 1, "channelCount": 1, "channels": [{ "platform": "youtube", "configured": true, "publicUploads": false, "maxVideoBytes": 104857600 }], "publicationChecked": false } ``` #### Check your own account with two GET requests Only after setting REELING_API_KEY in your local environment, use --live. With one project you can omit --project. With multiple projects, copy the intended UUID from your account and pass it explicitly. The script requests /api/v1/projects and /api/v1/channels?projectId=...; it does not call publishing, analytics sync, AI generation or channel-option endpoints. Output omits names, IDs and credentials. ``` node reeling-readonly-check.mjs --live --project YOUR_PROJECT_UUID ``` #### Verify the same reads in your MCP client Reload the MCP connection after saving the configuration. Allow only the two read tools for this check: reeling_list_projects with {}, then reeling_list_channels with the chosen project_id. Compare the selected project and channel with your dashboard. Ask the client to show the proposed tool name and arguments before executing. Keep publishing, replies, metric sync and AI generation unapproved until you intentionally need them. ``` reeling_list_projects({}) reeling_list_channels({"project_id":"YOUR_PROJECT_UUID"}) ``` #### Recover from a failed connection If the local process cannot start, confirm Node and npx are on the MCP client’s PATH, then check the client’s server log without sharing credentials. HTTP 401 means authentication failed: check for a revoked or mistyped key. HTTP 400 on channels usually needs an explicit valid project UUID. For 403, check permissions and plan access; for 429, wait before retrying. A timeout or 503 does not prove a social account needs reconnecting. An empty channels list means this project has no returned connections; select the correct project before reconnecting anything. #### Set expectations before enabling writes The published MCP tool exposes content and scheduled_at, while REST publishing accepts caption and scheduled_for. MCP does not expose every REST destination option or channel_ids. If a project has two YouTube channels and you request platform youtube, both matching accounts can be selected. For exact channel selection and YouTube visibility, prepare a REST request with channel_ids and youtube options instead. Supported comment inbox networks and metric coverage are listed separately in the developer matrix. - Publishing, inbox, metrics and plan matrix: /developers#platform-rules - YouTube scheduling and result verification: /blog/schedule-youtube-shorts-claude-mcp #### Live REST check: October 15, 2026 At 19:37 UTC on October 15, 2026, we ran the downloadable reference with an existing authorized key. GET /api/v1/projects and GET /api/v1/channels each returned HTTP 200. The key returned one project and six channels: YouTube, Threads, Instagram, Bluesky, TikTok and Facebook. No explicit project choice was needed. The excerpt below is an actual sanitized result, separate from the offline fixture above. Reported capability flags describe the server’s configuration at that time; they do not verify channel permissions, a successful upload or public visibility. Claude, Cursor and MCP tool execution were not tested in this run. No content was uploaded, scheduled or published, and no AI generation was requested. ``` { "mode": "live_read_only", "readAccessChecked": true, "projectCount": 1, "channelCount": 6, "publicationChecked": false } ``` - Inspect the dated sanitized live result and request statuses (JSON): /resources/evidence/readonly-check-2026-10-15.json #### Continue with the tested examples The maintained example repository contains a dependency-free account reader, a local video-request draft, bounded polling and analytics retrieval. Its default mode uses fixtures. Review the source, select the exact account and use explicit live flags only for your own intended operation. - Runnable example guide: /developers/examples - MCP configuration builder: /tools/mcp-config-generator Source: Reeling MCP source and tool definitions: https://github.com/yomariano/reeling-mcp Source: Reeling API reference and platform requirements: https://reeling.app/developers Source: Cursor MCP configuration: https://cursor.com/docs/context/mcp Source: Read-only reference source (downloadable JavaScript): https://reeling.app/resources/reeling-readonly-check.mjs Source: MCP Inspector documentation: https://modelcontextprotocol.io/docs/tools/inspector ### Connect an agent workflow to the Reeling publishing API https://reeling.app/blog/elizaos-autonomous-ai-agent-tiktok-video-plugin Published: 2026-10-12; modified: 2026-10-14; author: Reeling product team A framework-neutral integration checklist for connecting an ElizaOS or other agent workflow to Reeling projects and publishing endpoints. #### Start with the supported API contract An agent framework needs an HTTP client, a secret store and a project mapping. Use the live OpenAPI definition to confirm supported fields. Do not assume that a package named in an older tutorial is installed, published or compatible with your framework version. #### Prove authentication with a read request Set REELING_API_KEY in your runtime secret store, then fetch projects. Use the selected project ID when requesting channels. This read request checks access without sending content to a social network. ``` curl --fail-with-body https://api.reeling.app/api/v1/projects \ -H "X-API-Key: $REELING_API_KEY" ``` #### Separate drafting from publication Have the agent prepare a proposal containing a video URL, caption, destinations and scheduled time. Review the proposal before POST /api/v1/publish. Store the returned post ID in the job record, and poll GET /api/v1/posts/{id} to inspect each destination. #### Handle permissions and failures explicitly TikTok inbox delivery requires finishing the post in TikTok. Public Direct Post availability depends on the app audit and account settings. A partial failure should update the job with the failed destination; do not automatically repeat every platform. Keep credentials and media URLs out of public logs. Source: Live Reeling OpenAPI definition: https://api.reeling.app/api/v1/openapi.json Source: Reeling API reference and platform requirements: https://reeling.app/developers ### Connect an assistant to Reeling with an API adapter https://reeling.app/blog/chatgpt-actions-grok-bot-social-media-publishing Published: 2026-10-12; modified: 2026-10-14; author: Reeling product team Map an assistant tool to Reeling authentication, project selection and publishing status, with a review step before sending posts. #### Choose an integration your client supports Different assistant products support different tool transports and authentication methods. Check your client version before importing a schema or assuming it can send custom headers. The stable Reeling contract is its HTTPS REST API; MCP is another option for compatible clients. #### Configure read operations first Map GET /api/v1/projects and GET /api/v1/channels?projectId=YOUR_PROJECT_ID. Store the Reeling key in the connector secret store and send it in X-API-Key. Return only the project and channel information needed for the task; never include credentials in tool output. #### Treat publishing as an explicit action Map POST /api/v1/publish only after read access works. Require the user to review the project, destination accounts, caption, media and timing. The API uses scheduled_for for scheduling. Do not promise that one natural-language request will automatically produce a compliant video and publish it everywhere. #### Return the real outcome Save the post ID, check GET /api/v1/posts/{id}, and report the destination statuses. Distinguish queued, scheduled, partially published, failed and inbox delivery. A connection to Reeling does not remove a platform’s account, consent or approval requirements. Source: Live Reeling OpenAPI definition: https://api.reeling.app/api/v1/openapi.json Source: Reeling API reference and platform requirements: https://reeling.app/developers Source: Reeling MCP source and tool definitions: https://github.com/yomariano/reeling-mcp ### Check TikTok account status when views drop https://reeling.app/blog/tiktok-shadowban-checklist-recovery Published: 2026-10-06; modified: 2026-10-14; author: Reeling product team Use TikTok account status, post notices and comparable analytics to investigate a drop in views without assuming a shadowban. #### Start with account status TikTok provides account-status checks through TikTok Studio and the Safety Center. Review any notices affecting posting, profile changes or other account features. A low view count by itself does not establish an account restriction. #### Inspect the affected post Check the post visibility, upload and processing status, any eligibility or policy notice, and the time since publication. Compare with similar posts after the same observation interval rather than treating a specific view count as a diagnostic threshold. #### Use the platform review process If TikTok shows an enforcement or eligibility notice, read the reason and use the review or appeal option it provides. Keep the original notice and relevant content details. There is no evidence in this guide for a fixed recovery deadline or a guaranteed reset protocol. #### Distinguish publishing from distribution In Reeling, TikTok inbox delivery still requires you to open TikTok and complete the post. Check that step before interpreting an absent public video as a reach problem. Once the video is public, its distribution is controlled by TikTok; scheduling software cannot guarantee or restore reach. Source: TikTok: check your account status: https://support.tiktok.com/en/safety-hc/account-and-user-safety/account-status Source: Reeling API reference and platform requirements: https://reeling.app/developers ### Write and test an opening for a short-form video https://reeling.app/blog/ai-video-hooks-first-3-seconds Published: 2026-10-05; modified: 2026-10-14; author: Reeling product team A practical way to draft an opening, match it to the video, and evaluate results without unsupported promises of virality. #### State the viewer’s task Write down who the video is for and what it will help them do. Open with a concrete example, question or demonstration that the rest of the video actually answers. A strong opening does not compensate for a missing payoff. #### Draft alternatives with the template builder Enter the topic and choose a niche in Reeling’s free video hook template builder. It offers editable structures for a process, question, comparison, detail or example. These are deterministic templates, not measured performance predictions. Replace generic wording with a detail you can demonstrate. #### Match the visual and the promise Show the relevant screen, object or action as the opening is spoken. Remove numbers, savings and outcome claims unless you can support them. For a product demonstration, show the actual workflow rather than presenting a mockup as a customer result. #### Compare like with like Track the opening version, audience, length, publication time and available retention measures. Compare similar videos and allow enough observation time before deciding. This guide does not claim a universal dropoff percentage or a guaranteed increase in watch time. Source: Reeling video hook templates: https://reeling.app/tools/hook-generator Source: Reeling API reference and platform requirements: https://reeling.app/developers ### Prepare a video for Threads and Bluesky in Reeling https://reeling.app/blog/cross-posting-to-threads-and-bluesky Published: 2026-10-04; modified: 2026-10-14; author: Reeling product team Adapt captions, check Reeling’s current destination limits, and verify delivery when posting a video to Threads and Bluesky. #### Connect both accounts to the same project Open Channels in your Reeling project. Complete Threads authorization and connect Bluesky with its dedicated app password. Confirm that both accounts appear under the intended project before preparing the post. #### Use the stricter supported video limit The current Reeling composer validates Bluesky videos up to sixty seconds and Threads videos up to five minutes. These are Reeling implementation limits, not a claim about every upload method supported by those services. For a shared video, use a file within both limits. #### Edit the caption for each destination The composer allows up to three hundred characters for Bluesky text and five hundred for Threads. Preview each version, check URLs and remove hashtags that do not serve the message. Cross-posting does not guarantee reach or bypass a network’s recommendation rules. #### Check results independently After publication, inspect each channel result. If only one fails, investigate its permissions or processing error before resubmitting. Keep a record of the destination link and publish time so you can compare results without treating duplicate submissions as new tests. Source: Reeling API reference and platform requirements: https://reeling.app/developers Source: Live Reeling OpenAPI definition: https://api.reeling.app/api/v1/openapi.json ### Plan a reviewed video publishing workflow in Reeling https://reeling.app/blog/how-to-automate-tiktok-reels-ai-2026 Published: 2026-10-03; modified: 2026-10-20; author: Reeling product team Move from a video draft to connected channels, a scheduled request and verified delivery across supported destinations. #### Prepare a reviewable draft Start with a script, media and caption that you have permission to publish. If you use generated media, inspect the output and apply the disclosures required by the destination. Keep the original media and a record of the approved caption. #### Confirm account availability Connect destinations in the correct Reeling project. Reeling’s current Instagram flow requires an eligible professional account with tester access. TikTok inbox mode hands the video back to TikTok for completion; public Direct Post is subject to the app audit. Review the documentation before promising unattended publication. #### Schedule with an explicit timezone In the API, supply project_id, video_url, caption and platforms; use scheduled_for for a future timestamp. In the UI, verify the displayed date and timezone in the calendar. Make the publishing request only after the intended destinations and content have been reviewed. #### Record results instead of assuming success Store the returned post ID. Check processing and each platform result, and verify public destination links where available. Investigate partial failures rather than blindly repeating the whole request. Monitor accepted requests separately from confirmed publication. #### Run a fixture before authorizing an agent Clone the Reeling examples and run the account and polling scripts without flags. They return labeled synthetic output and make no account requests even if credentials exist in the environment. Inspect the tests before adding a live key. Once the connection is understood, use --live-read to inspect the exact project and channels. Keep draft preparation separate from --publish and check the full payload before authorizing the write. ``` git clone https://github.com/yomariano/reeling-examples.git cd reeling-examples npm test node examples/read-account.mjs node examples/poll-status.mjs ``` - Open the runnable workflow guide: /developers/examples #### Keep a durable record between agent steps Save a draft identifier, the approved caption, target channel, intended timezone and returned post ID. If the assistant loses context or a tool times out, resume from that record rather than starting the upload again. Report the actual state of each destination. A paid generation result, upload receipt and public post are different artifacts. A useful automation should explain the remaining human action when inbox delivery or account review is required. - Monitor failures and ambiguous outcomes: /blog/monitor-social-publishing-failures Source: Live Reeling OpenAPI definition: https://api.reeling.app/api/v1/openapi.json Source: Reeling API reference and platform requirements: https://reeling.app/developers ### Schedule a YouTube Short with Reeling MCP https://reeling.app/blog/schedule-youtube-shorts-claude-mcp Published: 2026-10-02; modified: 2026-10-15; author: Reeling product team Choose the correct project, prepare a publishing request, and confirm delivery status when scheduling a YouTube Short through Reeling. #### Choose the exact channel first Run the read-only reference or MCP list tools from the setup guide. Confirm the project and YouTube destination in your dashboard. The API selects all matching platform accounts in a project unless channel_ids is supplied; the current MCP publish schema does not expose channel_ids. Use a project with one intended YouTube channel, or the REST API with an explicit channel_ids array. Reading a connected channel does not verify upload visibility. - Run the read-only connection check: /blog/claude-cursor-mcp-social-media-automation - Download the reference script: /resources/reeling-readonly-check.mjs #### Prepare a Short that meets the actual constraints YouTube classifies eligible square or vertical uploads up to three minutes as Shorts. Reeling’s v1 ingestion cap is 100 MiB; MP4, MOV and WebM are accepted for YouTube. Use a direct video URL that the server can download, not a private sharing page. Check copyright, the title and the made-for-kids setting. Shorts over one minute with an active Content ID claim can be blocked by YouTube; music permission is a separate check from technical upload success. #### Decide visibility before using the publish tool The current MCP publish schema does not expose youtube.privacy_status or made_for_kids. The REST route defaults to public and made_for_kids false, while public-upload capability can constrain the result. Do not use an omitted default as a visibility or audience decision. If you need explicit controls, review the REST draft below. This guide does not execute it. #### Inspect a REST request draft Replace every placeholder and choose a future ISO timestamp with an explicit timezone. This example intentionally uses private visibility and one channel ID. Set the audience flag for the actual video; false here is illustrative. The endpoint is POST /api/v1/publish. Sending it would schedule real work, so keep this payload as a local draft until you approve the exact media, channel and settings. ``` { "project_id": "YOUR_PROJECT_UUID", "channel_ids": [ "YOUR_YOUTUBE_CHANNEL_UUID" ], "platforms": [ "youtube" ], "video_url": "https://YOUR_MEDIA_HOST/reviewed-video.mp4", "title": "Your reviewed title", "caption": "Your reviewed description", "scheduled_for": "FUTURE_ISO_TIMESTAMP_WITH_TIMEZONE", "youtube": { "privacy_status": "private", "made_for_kids": false } } ``` #### If MCP has the controls your workflow needs The equivalent MCP tool is reeling_publish_post. It accepts content, title, platforms, video_url, project_id and scheduled_at; those names are not interchangeable with REST everywhere. For a single-channel project, ask the assistant to show a draft first. Approve the actual tool call separately. This is a field-mapping example, not a live scheduled post. ``` { "project_id": "YOUR_PROJECT_UUID", "content": "Your reviewed description", "title": "Your reviewed title", "platforms": ["youtube"], "video_url": "https://YOUR_MEDIA_HOST/reviewed-video.mp4", "scheduled_at": "FUTURE_ISO_TIMESTAMP_WITH_TIMEZONE" } ``` #### Keep acceptance, upload and publication separate Store the post ID returned by the write. Check GET /api/v1/posts/:id or reeling_get_post_status after the scheduled time. A scheduled response only confirms a queued job. Inspect publish_results for each destination, including published, upload_status and any error; do not treat a successful overall HTTP status as success on every channel. Finally check the actual video and its visibility in YouTube Studio. A private video or processing upload is not a public Short. - Download a publication verification worksheet: /resources/publishing-checklist.csv #### Handle an ambiguous timeout without duplicating the upload If submission times out, first look for the returned post ID or the matching scheduled item in Reeling. Inspect its existing status and YouTube Studio before sending anything again. This guide assumes no idempotency guarantee. For partial failure, inspect the failed destination rather than repeating the whole multi-channel request. Reconnect only when the error indicates expired or missing authorization; a processing delay needs observation, not another upload. #### Worked verification example Illustrative outcome: the scheduler accepted one item, the upload later reports processing, and YouTube Studio still shows a private video. Record accepted=yes, upload=processing, public verification=no. Only update public verification after the intended channel shows the intended visibility and the destination URL works as expected. This example is not a customer result or a live upload test. #### Review date and test scope Reviewed October 15, 2026 against the Reeling route and MCP implementations and official YouTube guidance. The companion client passes local fixture tests and was also run against the live REST API at 19:37 UTC. Both read endpoints returned HTTP 200; the single returned project had six channels, including YouTube. The YouTube entry reported configured: true, publicUploads: true and maxVideoBytes: 104857600. Those are returned capability values, not a tested upload or proof of a channel’s permission. The run did not execute an MCP client, upload a video, schedule work or verify publication. The request drafts and worked publication example above remain illustrative. - Read the sanitized live REST check (JSON): /resources/evidence/readonly-check-2026-10-15.json - See the connection-check interface and reproduction steps: /blog/claude-cursor-mcp-social-media-automation#section-3 Source: Reeling MCP source and tool definitions: https://github.com/yomariano/reeling-mcp Source: Reeling API reference and platform requirements: https://reeling.app/developers Source: Live Reeling OpenAPI definition: https://api.reeling.app/api/v1/openapi.json Source: YouTube: three-minute Shorts eligibility: https://support.google.com/youtube/answer/15424877?hl=en ### Find useful posting times from your own results https://reeling.app/blog/best-times-to-post-social-media-2026 Published: 2026-10-01; modified: 2026-10-14; author: Reeling product team Build a small scheduling experiment using your audience, comparable posts and destination-specific analytics. #### Use your audience as the starting point There is no posting time this guide can guarantee will work for every account. Choose candidate windows when your intended audience is likely to be available, using the analytics available for that account. Record the timezone and the reason for each window. #### Keep the comparison fair Group posts with similar formats, topics and length. Rotate candidate time windows across comparable posts rather than assigning all strong topics to one slot. Record any paid promotion, collaboration or unusually large external referral. #### Define the outcome before scheduling Choose a metric that matches the goal, such as qualified visits, signups or watch time. Compare results after the same observation interval. Small samples are noisy: a single successful post cannot establish a universal best time. #### Use Reeling to record the experiment Schedule the approved posts in the calendar and inspect destination-specific results after publication. Keep a simple table with topic, format, timezone, scheduled time, actual delivery time and outcome. Adjust one variable at a time and retain unsuccessful tests so the comparison is not selective. Source: Reeling API reference and platform requirements: https://reeling.app/developers