Your YouTube library (transcripts, breakdowns, followed channels), accessible programmatically and wired into Claude or Cursor through the built-in MCP server.
Every request carries a personal API key in the
X-Api-Key header. Keys are created and revoked in the app,
under Settings > API and MCP (Pro plan and above).
Each key is displayed in plain text only once, when it is created:
store it in a secrets manager.
curl https://app.feedtomind.com/api/videos \
-H "X-Api-Key: ytr_your_key"https://app.feedtomind.com. Responses are
JSON (UTF-8). An invalid or revoked key returns 401.
Paid actions consume the account's credits, just like in the app
(insufficient balance: 402).
| Endpoint | Description |
|---|---|
GET/api/videos |
Lists the videos in your library (id, title, author, status, whether a breakdown has been generated). |
GET/api/videos/{id} |
Details for one video: metadata, transcript, restitution, summary, action_plan. |
POST/api/videos |
Archives a video. JSON body: {"url": "https://www.youtube.com/watch?v=..."}.
With "mode": "transcript", only the transcript is fetched (1 credit), which is what the app does when you paste a link;
without it, the breakdown is generated right away and streamed as plain text
(response header X-Video-Id). Option "language": one of the language codes returned by GET /api/credits (languages), for example "en", "fr", "ja", "pt-br"; overrides the account preference (English unless changed in Settings) for this request.
|
POST/api/videos/{id}/restitution |
Generates (or regenerates) the breakdown of an archived video. Optional body {"language": "fr"}. Response streamed as plain text. |
POST/api/videos/{id}/summary |
Generates the video's summary (the first generation is included in the video's credit, each regeneration costs 1 credit). Optional body {"language": "fr"}. Streamed response. |
POST/api/videos/{id}/action-plan |
Generates the video's summary + action plan (the first generation is included in the video's credit). Streamed response. |
DELETE/api/videos/{id} |
Removes a video from your library. |
| Endpoint | Description |
|---|---|
GET/api/content/sources |
Videos sent to the Idea Generator back office (id, title, thumbnail, whether a breakdown or summary exists, number of creation channels using them). |
POST/api/content/sources |
Sends videos from your library. Body: {"video_ids": [12, 13]}. Only videos with a transcript are accepted; already sent videos are ignored. |
DELETE/api/content/sources/{videoId} |
Removes a video from the back office and from every creation channel. The video stays in your library. |
GET/api/content/channels |
Lists your creation channels (name, kind, brief, source and idea counts). |
POST/api/content/channels |
Creates a creation channel. Body: {"name": "Business shorts", "network": "youtube", "length": "long", "brief": {...}}. Networks: youtube (length short or long), tiktok, instagram, linkedin, x. The response carries kind: short, long or post. |
GET/api/content/channels/{id} |
One creation channel with its brief and attached sources. |
PATCH/api/content/channels/{id} |
Renames the channel or replaces its brief. Brief fields (all optional strings): description, audience, promise, direction, tone, voice, language, duration, format, hook_style, cta, hashtags, examples, avoid, brand_name, brand_color, logo_url. |
DELETE/api/content/channels/{id} |
Deletes the channel, its ideas and scripts. Sources stay in the back office. |
POST/api/content/channels/{id}/sources |
Attaches videos to the channel (body {"video_ids": [...]}); videos not yet in the back office are added there too. |
DELETE/api/content/channels/{id}/sources/{videoId} |
Detaches a video from the channel. |
POST/api/content/channels/{id}/ideas/generate |
Generates content ideas from one attached source, following the channel's network. Body: {"video_id": 12, "count": 5} (count 1 to 10, default 5). 1 credit per call (0 with your own AI key), refunded if nothing usable comes back. Returns the saved ideas; extra carries the network-specific fields (YouTube long-form: thumbnail_text, thumbnail_visual, plan; LinkedIn and X: structure, outline). |
GET/api/content/channels/{id}/ideas |
Ideas of a channel, newest first. Optional ?status=new|kept|rejected|produced. |
PATCH/api/content/ideas/{id} |
Updates an idea: {"status": "kept", "notes": "..."}. |
DELETE/api/content/ideas/{id} |
Deletes an idea and its scripts. |
POST/api/content/ideas/{id}/script |
Writes the deliverable of an idea following the channel's network: reel script (hook, timed lines, call to action, caption, hashtags), long-form video script (title options, hook, script per plan part, outro, description, tags), LinkedIn post (post, visual, first comment) or X thread (numbered posts, visual). Streamed as plain text, saved as a new version (format: reel, video, post or thread), the idea becomes produced. 1 credit (0 with your own AI key), refunded if the stream fails. |
GET/api/content/ideas/{id}/scripts |
Script versions of an idea, newest first. |
POST/api/content/ideas/{id}/thumbnail |
YouTube channels only. Generates a real thumbnail from the idea: art direction by the AI, background image, massive text composited in a self-contained SVG (1280x720) with the brand accent color from the brief. 3 credits, refunded on failure. Returns the asset (data is the SVG, meta the layout used for PNG export). |
POST/api/content/ideas/{id}/support |
Long-form YouTube channels only. Composes the Excalidraw mind map to keep on screen while recording (hook in the center, numbered branches following the plan, proof captures, do / avoid, call to action), published as a share link on excalidraw.com (encrypted, the key only lives in the URL fragment). 2 credits (0 with your own AI key), refunded on failure. Returns the asset with meta.url. |
GET/api/content/ideas/{id}/support.excalidraw |
Downloads the board source file (latest, or ?asset= a given asset id) to drop on excalidraw.com. |
GET/api/content/ideas/{id}/assets |
Generated files of an idea, newest first. Optional ?kind=thumbnail|support|storyboard|video_assets|render. Board scenes are not inlined (use the download endpoint); video assets carry the media URLs. |
GET/api/content/video/options |
Video module capabilities of this instance: video (media storage configured), render (render container configured), configured voice providers and their voices, music moods, camera moves, caption styles, credit costs. |
POST/api/content/ideas/{id}/storyboard |
Short-form channels only (YouTube Shorts, TikTok, Instagram), after the script. Cuts the script into a storyboard: 6 to 14 shots with the narration text, an image prompt, a camera move and an estimated duration, plus a shared visual style, narrator instructions, music mood and caption settings. 1 credit (0 with your own AI key), refunded if the model returns nothing usable. Returns the asset (data is the storyboard JSON). |
PATCH/api/content/assets/{id} |
Edits a storyboard in place ({ storyboard: { shots, voice, music, captions, style_suffix } }, unknown fields ignored, at least 3 shots). No credit. |
POST/api/content/ideas/{id}/video-assets |
Generates the assets of the latest storyboard (or { storyboard_id }): one image per shot, the voice-over, the word-level timing and the shot windows, a music track from the library. Streamed as server-sent events (start, image, voice, done or error). Images and voice whose prompt or words did not change since the previous run are reused and not charged. 1 credit per generated image, 2 for the voice, refunded on failure. 503 when media storage is not configured. |
POST/api/content/video-assets/{id}/shots/{shot} |
Generates one shot image again from the current storyboard. 1 credit, refunded on failure. |
POST/api/content/ideas/{id}/render |
Renders the MP4 (1080x1920, H.264, AAC, burned-in captions) from the latest complete assets (or { assets_id }) in the render container. One render at a time per idea. 1 credit, refunded if the container fails; 409 when the assets no longer cover the storyboard. Returns the render asset with url and download_url. 503 when the render container is not configured. |
GET/api/content/renders/{id} |
Status of a render (running, done, failed with the error). |
GET/api/content/media/{key} |
Serves a media object of the account (shot images, voice-over, MP4) or of the shared music library. ?download=1 on an MP4 sends it as an attachment. |
| Endpoint | Description |
|---|---|
GET/api/channels |
Lists followed channels (id, title, video count, number already fetched). |
POST/api/channels |
Follows a channel. Body: {"input": "@handle | URL | UC... ID"}. Idempotent. |
GET/api/channels/{id}/candidates |
Candidate videos from the channel, with those already archived flagged.
Parameters: sort=recent|oldest|popular, limit (max 100),
exclude_shorts=0|1.
|
GET/api/channels/{id}/transcripts |
All archived transcripts for the channel (warning: can be large).
Optional: ids=12,34,56 restricts the result to those videos (ids from the channel only).
|
GET/api/folders/{id}/transcripts |
All transcripts of a folder, same shape and ids filter as the channel endpoint. |
POST/api/videos/move |
Body {"ids": [12, 34], "folder_id": 5} moves several videos into a folder (null = out of any folder). |
| Endpoint | Description |
|---|---|
GET/api/credits |
Plan, credit balance, channel limits, and account capabilities. |
GET/api/credits/history |
Credit transaction history (last 200 entries). |
Posts, threads, carousels, articles and newsletter issues written from your library, one generator per network. Models are pieces you paste (a post, a thread, a carousel, an article, an issue that worked); their strategy is extracted once and reused with your own material. Publishing is manual: copy, paste, post (or paste into your email tool). Every route below exists under /api/x/ (kinds post, thread, article), under /api/linkedin/ (kinds post, carousel, article) and under /api/newsletter/ (kinds issue, a full issue; short, a short issue or one section; sequence, a welcome or nurture sequence of 3 to 5 emails); profiles, models and drafts are separate per network.
| Endpoint | Description |
|---|---|
GET/api/x/playbook | The network playbook (ranking facts and writing rules), the limits used by the checks, the kinds and their costs. |
GET/api/x/profile | Your profile on this network (handle, positioning, audience, offer, tone, language, cta, links, avoid, premium for X), plus voice_samples (your own posts, one per paragraph, up to 8000 characters) and voice (the analysis: description, rhythm, sentence_length, vocabulary, punctuation, never, signature_patterns). |
PUT/api/x/profile | Replaces the profile. Body: the same fields, all optional; premium is yes or no. The voice analysis is kept when the body omits it (send "voice": null to clear it). |
POST/api/x/profile/voice | Analyzes your voice from voice_samples (2 credits, 0 with BYOK; refunded if the model returns nothing usable). Body: optional {"voice_samples": "..."}, saved to the profile first. Returns {profile, charged}; the writer follows the voice on every draft, before the model strategies. |
GET/api/x/videos | Videos of your library with a transcript (id, title, author, thumbnail, has_breakdown, has_summary), for the picker. |
GET/api/x/templates | Your models with their analysis (name, hook_type, hook_pattern, structure, devices, cta_type, cta_pattern, tone, length, why_it_works, skeleton). |
POST/api/x/templates | Adds a model and analyzes it (1 credit, 0 with BYOK). Body: {"kind": "...", "body": "...", "title": "...", "source_url": "..."} (kinds of the network). If the analysis fails the model is kept without analysis (HTTP 502 with template). |
POST/api/x/templates/{id}/analyze | Runs the analysis again (1 credit). |
GET/api/x/library | The starter library of the network: pre-analyzed strategies (id, kind, name, tags, summary, example, analysis) so you can write a first draft without pasting a model. Each entry carries adopted and template_id when you already added it to your models. |
POST/api/x/library/{id}/adopt | Copies a library strategy into your models with its analysis already filled: no credit, no AI call. Returns the template (HTTP 201); HTTP 409 with the existing template if it was already adopted. |
PATCH/api/x/templates/{id}, DELETE | Renames or retypes a model; deletes it (drafts written from it are kept). |
GET/api/x/posts | Your drafts, newest first, each with its checks (level ok, warn or fail, and a text). |
POST/api/x/posts | Writes a new draft. Body: {"kind": "...", "template_ids": [1], "video_ids": [12, 13], "instructions": "..."} (up to 3 models and 5 videos; at least one video or instructions). 1 credit for a post, 2 for a thread, a carousel or an article, 0 with BYOK; on the newsletter, 1 for a short, 2 for an issue, 3 for a sequence. Returns the draft: body is {post, reply, visual, notes} (reply = first reply on X, first comment on LinkedIn), {tweets: [...], reply, visual, notes}, {title, slides: [{heading, body}], caption, reply, visual, notes}, {title, body, announce, visual, notes}; on the newsletter {title, subject, preview, body, cta, notes} for an issue or a short issue (body in Markdown, one call to action) and {title, emails: [{subject, preview, body}], notes} for a sequence. Newsletter checks: subject line under 50 characters (fails over 70), preview text under 90, 600 to 2000 words per issue (300 to 700 for a short one), at most one link per section, exactly one call to action, 3 to 5 emails under 500 words each in a sequence. |
GET/api/x/posts/{id} | One draft with its checks. |
PATCH/api/x/posts/{id} | Edits a draft: title, body (same shape as above), status (draft or published), notes, and its results: published_url (http or https, 500 characters), published_at (date or ISO 8601; set automatically the first time the status becomes published), metrics ({impressions, likes, comments, reposts, saves, followers, leads, clicks}, integers, all optional; replaces the previous metrics). Returns the draft with fresh checks, metrics, metrics_at and score (comments x8 + reposts x4 + saves x3 + likes + leads x20 + followers x10; null without metrics). |
DELETE/api/x/posts/{id} | Deletes a draft. Nothing is changed on the network. |
GET/api/x/insights | What worked on this network: published and scored counts, top (up to 10 published drafts by score: id, title, kind, template_ids, published_url, published_at, metrics, score), templates (per model: template_id, name, deleted, published, scored, avg_score, best_score), kinds (the same per format) and learning (the 3 best pieces the writer uses as examples: id, title, kind, score, text). |
Turns one or more videos of your library (breakdowns, or transcripts when there is no breakdown) into a reusable skill for Claude (an Agent Skill folder: SKILL.md with a name and description frontmatter, plus references/<video>.md with timestamped key points and YouTube links) and for ChatGPT (a custom GPT: gpt/instructions.md, gpt/conversation-starters.md, gpt/knowledge.md), with a README.md that explains how to install both. The files are written by the server from the model's answer, so they always have the same shape; you can edit each file and download the package as a zip. The web app serves the module on /skills.
| Endpoint | Description |
|---|---|
GET/api/skills | Your skills, newest first, without the files: id, title, slug (the folder name), target (claude, chatgpt or both), brief, video_ids, language, summary, status (ready, or draft when the last generation failed), file_count, dates. |
POST/api/skills | Generates a skill (2 credits, 0 with BYOK; refunded if the model returns nothing usable). Body: {"brief": "what the skill must be able to do (600 characters)", "target": "claude" | "chatgpt" | "both", "video_ids": [12, 13], "title": "optional"}, 1 to 8 videos with a transcript. Returns the skill with files (path to text: SKILL.md, references/..., gpt/..., README.md, according to the target) and charged (HTTP 201). On failure the skill is kept as a draft (HTTP 502 with skill) and can be regenerated. |
GET/api/skills/videos | Videos of your library with a transcript (id, title, author, thumbnail, has_breakdown, has_summary), for the picker. |
GET/api/skills/{id} | One skill with its files. |
PATCH/api/skills/{id} | Edits title, brief, and the content of existing files: {"files": {"SKILL.md": "..."}} (unknown paths are refused, HTTP 400). The slug does not change. |
POST/api/skills/{id}/regenerate | Writes the files again from the same videos and brief (same credits). Title and slug are kept. |
GET/api/skills/{id}/download.zip | The package as a zip (Content-Disposition: attachment), every file under the folder <slug>/. For Claude, unzip and copy the folder into ~/.claude/skills/ or the project's .claude/skills/. HTTP 409 for a draft without files. |
GET/api/skills/{id}/files/{path} | One file as plain text (text/markdown), for example /api/skills/3/files/gpt/instructions.md. |
DELETE/api/skills/{id} | Deletes the skill. Copies you installed elsewhere are not affected. |
Every week, the new videos of your library (transcript added in the last 7 days; otherwise the 3 latest videos) become ready-to-publish drafts in the Content Generators, on X and/or LinkedIn, and you receive an email with one link per draft. Drafts are written exactly like POST /api/x/posts (same credits: 1 per post, 2 per thread, carousel or article, 0 with BYOK) with your 2 latest analyzed models for the network. The run stops for the week when your balance runs out and the email says so. Hours are UTC.
| Endpoint | Description |
|---|---|
GET/api/pipeline/settings | Your settings: enabled, networks (["x", "linkedin"]), kinds ({"x": "post", "linkedin": "post"}), count (drafts per network, 1 to 5), weekday (0 = Sunday to 6), hour (0 to 23, UTC), last_run_at. |
PUT/api/pipeline/settings | Updates the settings; fields left out are kept. Kinds allowed: post, thread, article on X; post, carousel, article on LinkedIn; issue, short on the newsletter (networks accepts "newsletter", drafts open on /newsletter). HTTP 400 on an invalid value. |
POST/api/pipeline/run | Runs the pipeline now for your account (same code as the weekly run) and returns {run, drafts, skippedForCredits, email}: each draft has id, network, kind, title, excerpt, video_id, url. The next scheduled run waits at least 6 days. |
GET/api/pipeline/runs | Your last 10 runs: status (done, skipped, error, running), video_ids, post_ids, charged, detail, created_at. |
A book written from your library, ready for Amazon KDP. A book starts with a kick-off questionnaire (kind of book, subject, readers, narration, tone, writing type, author styles as references, characters or cases, length, language) and 1 to 30 videos; the model proposes an outline, you validate it, the chapters are written one by one in your voice, then the book is exported as Markdown, DOCX (paperback) and EPUB (e-book). Publishing on KDP stays manual: there is no publishing API. 0 credit with BYOK; credits are refunded when the model returns nothing usable.
| Endpoint | Description |
|---|---|
GET/api/books/options | The questionnaire options (kinds, audiences, narrations, tenses, tones, writings, lengths with word counts, author styles with notes, languages) and the costs. |
GET/api/books/videos | Videos of your library with a transcript (id, title, author, thumbnail, has_breakdown, has_summary), for the picker. |
GET/api/books | Your books, latest first, with status (kickoff, outline, writing, done), words, chapter_count and written_count. |
POST/api/books | Creates a book and writes its outline (2 credits). Body: {"kickoff": {...}, "video_ids": [12, 13]}. Kick-off fields: kind (business, memoir, fiction, essay, guide, other + kind_other), about (required), audience (founders, marketers, creators, general, professionals + audience_field), audience_other, takeaway, narration (first, third_limited, omniscient, second), tense (past, present), tone (direct, warm, humorous, contrarian, academic, lyrical) + tone_other, writing (narrative, didactic, essay, dialogue, mixed), styles (ids from the options) + styles_other, characters ([{name, role, wants, blocked, arc}]), length (short, standard, long), chapters, language, notes ({kind, audience, narration, writing, styles, characters, structure}), use_voice and voice_network. 6000 characters at most in total. Returns the book with its outline (title, subtitle, pitch, thread, characters, chapters) and chapters; HTTP 502 with book (kept at the kick-off stage) when the outline is unusable. |
GET/api/books/{id} | One book with its kick-off, outline, voice, KDP listing and chapters (position, title, summary, video_ids, target_words, body in Markdown, words, status planned or written). |
PATCH/api/books/{id} | Edits the title, subtitle, kickoff (merged with the current one) or outline ({title, subtitle, pitch, thread, characters, chapters: [{id, title, summary, video_ids, target_words}]}: chapters are reordered, renamed, added or removed in the order given; a written chapter keeps its text and cannot be removed). |
DELETE/api/books/{id} | Deletes the book and its chapters. |
POST/api/books/{id}/outline/regenerate | Proposes a new outline from the same kick-off and sources (2 credits). HTTP 409 once a chapter is written. |
POST/api/books/{id}/chapters/{position}/write | Writes (or rewrites) one chapter in Markdown from the outline, the chapter summary, the previous chapters (two lines each, for continuity), the chapter sources, the kick-off and the voice. 2 credits, 3 when the chapter targets more than 4000 words. Returns the chapter with book_status and charged. |
PATCH/api/books/{id}/chapters/{position}, DELETE | Edits a chapter by hand (title, summary, body; an empty body sets it back to planned); deletes a chapter that is not written. |
POST/api/books/{id}/kdp | Writes the Amazon KDP listing (1 credit): title, subtitle, description (up to 4000 characters, light HTML allowed by KDP), 7 keywords, 3 categories, back_cover, cover_brief. Returns {listing, checklist, charged}. |
GET/api/books/{id}/kdp.json | The stored listing (or null), the KDP checklist (manuscripts, cover sizes, free ISBN, rights, listing, pricing, publish) and the export links. |
GET/api/books/{id}/export.md, export.docx, export.epub | The whole book as a download: Markdown (title page, table of contents, chapters, sources), DOCX for the paperback (6 x 9 inches, Word styles) or EPUB 3 for the e-book. Chapters not written yet appear with their summary. |
The MCP server gives your AI assistant access to your whole library: transcripts, summaries, breakdowns and action plans, plus the ideas, posts, skills and books you made from them. Streamable HTTP transport, stateless, one URL for every client:
https://app.feedtomind.com/mcpClaude and ChatGPT connect with OAuth: you add the URL, sign in to FeedToMind and click Allow. No key to copy. Pro plan and above. You can disconnect an app at any time in Settings > API and MCP.
FeedToMind and paste https://app.feedtomind.com/mcp.On Team and Enterprise plans, an owner adds the connector once for the organization.
FeedToMind, paste https://app.feedtomind.com/mcp, choose OAuth authentication and confirm.claude mcp add --transport http feedtomind https://app.feedtomind.com/mcpThen run /mcp in Claude Code and choose Authenticate. The API key setup below also works.
URL : https://app.feedtomind.com/mcp
Header : X-Api-Key: ytr_your_keyclaude mcp add --transport http feedtomind \
https://app.feedtomind.com/mcp \
--header "X-Api-Key: ytr_your_key"In ~/.cursor/mcp.json (or the project's .cursor/mcp.json):
{
"mcpServers": {
"feedtomind": {
"url": "https://app.feedtomind.com/mcp",
"headers": {
"X-Api-Key": "ytr_your_key"
}
}
}
}search: full-text search across transcripts, summaries, breakdowns, ideas, posts, skills, books and chapters. Returns ids for fetch.fetch: the full content of an item: video:ID, idea:ID, post:ID, skill:ID, book:ID, chapter:ID, folder:ID, channel:ID.list_folders, list_ideas, list_posts, list_skills, list_books: browse what you made in the app.get_transcript: fetches and archives a video's transcript (idempotent).list_videos / get_video: browse your library (transcript, breakdown, action plan).follow_channel / list_channels: manage followed channels.list_channel_videos: a channel's videos, sorted (recent, oldest, popular).pull_channel_transcripts: archives the transcripts of N videos from a channel (deduplicated).get_channel_transcripts: all archived transcripts for a channel.