MCP App Store
by KeenEthics
Productivity
Simplified icon

Simplified

by Tldr Technologies

Overview

Simplified brings your marketing workspace into ChatGPT. Generate AI images and video, create speech from text, draft and publish social posts across 13 connected channels, manage brand kits, projects and tasks, plan content calendars and campaigns, and analyze social performance — all without leaving the conversation.

Tools

api_addComment

ChatGPT
Add a comment to a commentable resource. Set object_pk to the resource UUID and content_type to the resource family (currently task). For threaded replies, set parent to the parent comment ID.

api_assignAgentToItem

ChatGPT
Assign or reassign an AI agent (Chatbot) to a project item. The agent will be responsible for processing or executing the item. Path Parameters: - resourcetype: Project type selector - parent_lookup_project_id: Parent project ID - id: Item ID (UUID)

api_buildBrandKit

ChatGPT
Submit a canonical BrandKitDocument body to populate a brand kit. The body has four top-level sections — all optional, allowing incremental calls: - brand — name, description, website URL - social_links — array of {type, url} objects - content_pillars — 1–5 grounded themes, merged by normalized name - style — full visual-identity JSON (colors, typography, logos, imagery, logo_lockup, on_image_copy, ai_guardrails, prose, inferred_fields) The body shape is identical to the GET response (without id). Empty body {} is a valid no-op. Server-controlled fields (id, version) in the body are ignored. Runs synchronously and returns 200 with the result. Calling this endpoint multiple times is safe — sections sent overwrite their own fields; omitted sections are left unchanged. Content pillars omitted from a supplied list are preserved. Do NOT call `getTaskResult` after this — there is no async task; the operation is complete by the time the response returns. Path Parameters: - brand_id: Brand kit UUID

api_createAsset

ChatGPT
Create a persistent workspace asset. Pass exactly one of: - url — a remote file URL the server downloads, OR - path — a local file path; the toolkit uploads it via a signed URL and registers the asset (only works when running smp / smp serve locally — a remote MCP host can't read your filesystem). Processing is async (S3 upload + thumbnail generation via Celery). The returned asset UUID is usable immediately — e.g. in createProjectItem data.assets[] — but poll getAsset until status=4 (DONE) before relying on the stored URLs. Common use: persist a transient AI-generated image (from generateImage) so it can be saved to a project, published, or opened in the editor.

api_createBrandKit

ChatGPT
Create a new brand kit in the workspace. Only title is required — this makes an empty V2 kit. Populate it afterwards with buildBrandKit (canonical brand/style document) and/or context documents (createContextDocument). Typical onboarding flow: 1. createBrandKit with the brand name as title → returns the kit id (UUID) 2. buildBrandKit with the canonical BrandKitDocument to fill brand + style 3. getBrandKit?expand=extra to read it back

api_createContextDocument

ChatGPT
Create a new context document and link it to the brand kit. Two creation modes: 1. Link existing: Provide document_id to link an existing KnowledgeDoc. 2. Inline creation: Provide doc_type and name (plus optional description, data, content) to create a new KnowledgeDoc and link it automatically. Singleton constraint: For predefined types (brand_voice, icps, usps, etc.), only one document per type per brandkit is allowed. Attempting to create a duplicate will return a 400 error. The canonical_key is auto-set from doc_type if it matches a predefined type. Path Parameters: - brand_id: Brand kit UUID

api_createDocument

ChatGPT
Create a new long-form document rendered in the Quill editor. Content is stored as Quill Delta JSON (ops array). Used by AI-writer skills (Essay Writer, Article Writer) to persist generated markdown content into an editable document. The returned document is immediately openable at /ai-writer/document/{space_or_organization}/{id} in the Simplified web app. To convert markdown content into the required Quill Delta shape, call markdown_to_quill_delta from the writers toolkit before passing to this endpoint.

api_createProject

ChatGPT
Create a project of the given resourcetype. title is the common field; type-specific fields go under data (varies by resourcetype — inspect a getProject response for the target type to see its shape). Returns the new project's UUID, used for createProjectItem, listProjectItems, etc. Path Parameters: - resourcetype: Project type selector (the model name). The API is polymorphic — the same URL structure serves different project types based on this value. Valid values: - Project — generic projects (the default for most content). - AdCreativeProject — ad-creative projects (specialized fields). Use the same value on create, get, list, and delete for a given project.

api_createProjectItem

ChatGPT
Create a new item within the project. The accepted fields vary by resourcetype — inspect a GET response to see available fields for the target type. Path Parameters: - resourcetype: Project type selector - parent_lookup_project_id: Parent project ID

api_deleteContextDocument

ChatGPT
Delete the link between a brand kit and a context document. If the underlying KnowledgeDoc is not linked to any other brandkit, it is automatically deleted (orphan cleanup). Path Parameters: - brand_id: Brand kit UUID - document_link_id: Either the context-document link UUID (BrandKitContextDocument ID) OR the underlying KnowledgeDoc UUID — the endpoint resolves both.

api_deleteProject

ChatGPT
Soft-delete a project — sets is_deleted=true. The project and its items stop appearing in listProjects/getProject but are not purged from the database, so this is recoverable server-side. resourcetype must match the project's type (Project or AdCreativeProject) — the same value used to create it. Path Parameters: - resourcetype: Project type selector - id: Project ID (UUID or integer depending on type)

api_deleteProjectItem

ChatGPT
Soft-delete a single item within a project — sets is_deleted=true. The item stops appearing in listProjectItems/getProjectItem but is not purged, so it is recoverable server-side. Requires the parent project ID and matching resourcetype. To remove the whole project, use deleteProject. Path Parameters: - resourcetype: Project type selector - parent_lookup_project_id: Parent project ID - id: Item ID (UUID)

api_exportProjectItems

ChatGPT
Export specified ProjectItems to a partner integration (e.g. WordPress, social media). Provide the partner account ID and the list of item UUIDs to export. Path Parameters: - resourcetype: Project type selector - id: Project ID

api_generateAudio

ChatGPT
Convert text to spoken audio using the voice referenced by voice_id (get voices from listVoices). storage controls whether the audio is saved. Set use_ssml: true ONLY when text contains SSML markup like <speak> / <break> / <emphasis>. For plain prose leave it false — providers handle punctuation pacing well and SSML support varies. Storage modes: - default — returns the audio URL only (can expire) - asset — also saves it to your asset library for reuse Path Parameters: - voice_id: Voice UUID from listVoices voices[].id

api_generateImage

ChatGPT
Generate an AI image from a prompt, optionally guided by reference images. One call: POST {model, parameters} (capability is optional). It blocks and returns the final result — do not call getTaskResult. Use the field names below as-is for every model; the server adapts the payload to the model you chose. If something does not fit that model (a ratio it lacks, too many references for the mode), the error says exactly what to change. storage controls where the result is kept: - "asset" — saved to your asset library for reuse (recommended) - "transient" — temporary, not saved - "default" — kept in the image gallery

api_generateVideo

ChatGPT
Generate an AI video from a prompt, an image, two frames, several images, or a source video. One call: POST {model, parameters} (capability is optional — derived from which inputs you send). It blocks and returns the final result — do not poll. Use the input slot names below as-is for every model; the server adapts the payload to the model you chose. If something does not fit that model (a ratio, duration or resolution it lacks, too many images for the mode), the error says exactly what to change. getModelFields (type=video) is optional — call it only when you want the model's duration/resolution options before choosing. Why task_id is misleading here The endpoint also returns a task_id, but it tracks the submission Celery task that hands the request off to FAL/Kie — it flips to SUCCESS almost immediately, well before the actual video is rendered. Do not call `getTaskResult` on this `task_id` — it tells you nothing useful about generation completion. Always poll getVideoVariation instead. The apikit middleware strips task_id from this response automatically to avoid confusion. Storage modes - default — persists into the AiImageArt gallery (recommended). - transient — generated without surfacing in the gallery; useful for one-shot agent runs. - asset — saves the rendered video as a standalone reusable TldrAsset (no gallery entry).

api_getAsset

ChatGPT
Retrieve a workspace asset by UUID. Use this to resolve the final stored URLs and to check processing status after an async create (createAsset from a URL, or a signed upload) — the asset UUID is returned immediately but the file download / S3 upload / thumbnail generation completes in the background. Key response fields: - status — processing state: 0 NOT_STARTED, 1 IN_PROGRESS, 2 PROCESSING_FAILED, 3 THUMBNAIL_FAILED, 4 DONE, 10 NOT_PROCESSED. Poll until 4 before relying on the URLs. - file_url / thumbnail — signed URLs to the stored file (expire, ~12h; re-fetch to refresh). - asset_url — non-signed stored URL. - asset_type — image / video / audio / pdf / etc. - payload — extracted media metadata (width, height, duration, format, ...). Path Parameters: - id: Asset UUID (e.g. the id returned by createAsset).

api_getBrandKit

ChatGPT
Retrieve a brand kit by ID. Default response is {id, title} only. Use ?expand=extra to include the full brand envelope (brand, social_links, style). Use ?expand=website for the resolved company website URL. Combine with ?expand=extra,website. Sparse fieldsets via ?fields= and ?omit= are honored on the top-level keys. Path Parameters: - brand_id: Brand kit UUID

api_getContextDocument

ChatGPT
Retrieve one linked context document, including its full content. The document_link_id may be EITHER the junction (BrandKitContextDocument) UUID returned by listContextDocuments, OR the underlying KnowledgeDoc UUID — the server resolves either form. Use this when you already have a document ID and want its content. To find a document by its canonical type (e.g. brand_voice) instead, use getContextDocumentByType. To list all documents on a kit, use listContextDocuments. Path Parameters: - brand_id: Brand kit UUID - document_link_id: Either the context-document link UUID (BrandKitContextDocument ID) OR the underlying KnowledgeDoc UUID — the endpoint resolves both.

api_getContextDocumentByType

ChatGPT
Retrieve a single context document by its canonical type key. Most types return the full KnowledgeDoc directly (not the junction wrapper). For content_pillars, the backend reads the Brand Kit's existing structured ContentPillar records, renders cached Markdown on demand, and returns {doc_type: "content_pillars", content: "..."}. It does not create or synchronize a KnowledgeDoc. If no structured pillars exist, the endpoint returns 404 even when a legacy active context document exists. Path Parameters: - brand_id: Brand kit UUID - context_type: Canonical type key to retrieve

api_getCreditBalance

ChatGPT
Returns how many Simplified credits the current workspace has left. Credits are the shared currency spent by AI actions — image generation, video generation, and other AI tools all draw down the same balance. Call this tool when: - the user asks about their credits / balance / quota / "how much is left"; - before an AI generation, to confirm there's enough balance and avoid a mid-run failure; - after a generation fails with an out-of-credits / quota error, to report the remaining balance back to the user. No inputs. The response is a credits object: - credits.remaining — credits still available to spend - credits.used — credits consumed in the current period - credits.total — total credits allotted for the period - credits.trial — extra trial allowance (only present when on trial)

api_getImageModel

ChatGPT
Fetch a single image model by id, including the capabilities it supports. Public — no credential required. Path Parameters: - model_id: Model id, e.g. google.gemini-3.1-flash-image or flux.flux-realism.

api_getImageModelFields

ChatGPT
Return the parameters this model accepts, and the valid values for each, for a given capability. Public — no credential required. This is the authoritative answer to "what can I pass to this model". Build the parameters object of generateImage from what this returns rather than reusing settings from a different model.

api_getModelFields

ChatGPT
Step 1 — discover the dynamic per-(model, capability) parameter schema before calling generateVideo. Not needed for generateImage, which takes one fixed contract for every model. A single unified endpoint serves both image and video engines, selected by the required type query param. Response modes (driven by which query params you pass): - type only → {models: [...]} — list every registered engine of that type, its capabilities, and metadata (incl. credits_per_image / estimated_time). Use this to pick a model_id. - type + model_id → single-model detail with capabilities map. - type + model_id + capability → the full FieldDescriptor schema for that (model, capability) pair (labels, field_type, required flags, enum_values, defaults). This is the contract that generateImage / generateVideo's parameters must match. Use this before generating — it eliminates 400 errors on invalid / missing parameter keys.

api_getProject

ChatGPT
Retrieve a single project by its ID. Returns the full project object with all fields for the given resourcetype. Path Parameters: - resourcetype: Project type selector - id: Project ID (UUID or integer depending on type)

api_getProjectItem

ChatGPT
Retrieve a single project item by its ID. Returns the full item object including status, assignees, and metadata. Path Parameters: - resourcetype: Project type selector - parent_lookup_project_id: Parent project ID - id: Item ID (UUID)

api_getTaskResult

ChatGPT
Retrieve the status and result of an async task by its task_id. Status values: PENDING, STARTED, SUCCESS, FAILURE, RETRY, REVOKED. Note: for most async tools (generateImage, media/ operations) the toolkit middleware already polls this for you and returns the final result — you rarely need to call it directly. Use it manually only when a long job (e.g. video generation) exceeds the auto-poll window and you got a `task_id` back. Path Parameters: - task_id*: Celery task ID

api_getVideoModel

ChatGPT
Fetch a single video model by id, with its capabilities and the durations and resolutions it supports. Public — no credential required. Path Parameters: - model_id: Model id, e.g. veo-3.1, sora-2, kling-v2.5-turbo-pro.

api_getVideoModelFields

ChatGPT
Return the parameters a video model accepts for a given capability, and the valid values for each. Public — no credential required. capability is required, because a video model's fields differ substantially between capabilities — a first_last_frame call takes asset ids where a prompt call takes text.

api_getVideoVariation

ChatGPT
Step 3 — poll this endpoint after generateVideo. Read job_status: - Non-terminal: CREATED, PENDING, PROCESSING, RENDERING, UPDATED — keep polling. 10s is a reasonable interval. - Terminal: DONE (success — payload.output and asset_references are now populated with the rendered video URL) or FAILED (error — inspect payload.errors). Generation is webhook-driven (FAL / Kie call back into djapp when rendering finishes), so the row updates asynchronously — there is no task_id to short-circuit polling. Path Parameters: - art_id: AiImageArt UUID returned as id from generateVideo. - variation_id: AIArtVariation UUID returned as art_variation_id from generateVideo.

api_getVoice

ChatGPT
Retrieve a single voice by its UUID. Use this to resolve a bare voice_id — one the user picked in a voice picker, or a saved preference — back to its attributes without re-listing the whole catalog: gender (0=Male, 1=Female, 3=Neutral), voice_name, is_premium, description, and supports_instructions (whether the voice honors the instructions hint on generateAudio). The response is a single voice object — the same shape as one entry of listVoices's voices[]. Resolution is workspace-scoped: a voice owned by another workspace (and not globally published) returns 404. Path Parameters: - voice_id: Voice UUID (the id from a listVoices voices[] entry).

api_getWorkspace

ChatGPT
Fetch a single workspace (organization) by its integer ID — name, plan, settings, and metadata. The API token is bound to one workspace; pass that workspace's ID here to read its details. Path Parameters: - id: Workspace/Organization ID

api_getWorkspaceInfo

ChatGPT
Returns the authenticated caller's workspace context in a single call — no workspace ID required. Everything is derived from the auth token or Organization header. Response includes: - user — id, first_name, last_name, email of the requesting user - workspace — id, name, slug, is_active, and settings (timezone, language, start_of_week) - teamspaces — active spaces visible in workspace context (id, name, slug, is_active) Do not use this response as the membership authority for space_id. Call listTeamspaces to resolve IDs the current user can scope into.

api_listAssets

ChatGPT
The assets in the authenticated workspace/teamspace. Omit search to list them, newest first; pass it to narrow by asset name or tag. search is text matching, not visual or semantic. A search term includes matching assets stored inside folders; it does not search folder names or return every asset in a named folder. asset_type narrows either form, so listing only videos needs no search term. Results contain asset UUIDs (id), asset_name, asset_type, status, and thumbnail metadata. Use the UUIDs directly as social post media. Call getAsset for full asset details and fresh stored URLs. Follow pagination by incrementing page with the same search and filters when the response indicates another page. Do not stop after the first page when the user asks for all matching assets.

api_listBrandKits

ChatGPT
List all brand kits in the current workspace. Returns brand kit UUIDs and titles needed for getBrandKit, buildBrandKit, and the context-document operations. Use ?search=<title> to filter by name when the user refers to a kit by title. Paginated — pass page_size to widen results.

api_listComments

ChatGPT
Fetch all top-level comments for a commentable resource. Filter by object_pk (resource UUID) and content_type (resource family, e.g. task).

api_listContextDocuments

ChatGPT
List all context documents linked to a brand kit. Supports filtering by canonical_key, searching by document name or type, and ordering by created/modified timestamps. Path Parameters: - brand_id: Brand kit UUID

api_listImageModels

ChatGPT
List every image model available for generateImage, with the capabilities each one supports. Public — no credential required. Call this before generating when you do not already know a model id. Passing a setting a model does not support is silently ignored rather than rejected, so discovering the model first is how you avoid an image that comes back subtly wrong (an aspect ratio that never applied, for example).

api_listProjectItems

ChatGPT
List all items within a project. Items represent individual tasks, content pieces, or entries within the parent project. Path Parameters: - resourcetype: Project type selector - parent_lookup_project_id: Parent project ID

api_listProjects

ChatGPT
List projects of the given resourcetype in the workspace, paginated and newest-first. Returns project objects with their UUIDs — needed for getProject, listProjectItems, and deleteProject. Filter with ?search=<title>. Pass the same resourcetype you created the projects with. Path Parameters: - resourcetype: Project type selector (the model name). The API is polymorphic — the same URL structure serves different project types based on this value. Valid values: - Project — generic projects (the default for most content). - AdCreativeProject — ad-creative projects (specialized fields). Use the same value on create, get, list, and delete for a given project.

api_listTeamspaces

ChatGPT
List the teamspaces (Spaces) the current user is a member of, within the token's workspace. Use this to resolve a teamspace before scoping other calls: each returned id (integer) is the value you pass as the Space header (or --space / space_id) to narrow a request to that teamspace. The token stays bound to its one workspace — this does not switch workspaces, it only lists the sub-spaces you can scope into. Supports ?search=<name> to filter by teamspace name and ?expand=settings. Each item: {id (int), name, slug}.

api_listVideoModels

ChatGPT
List every video model available for generateVideo, with supported capabilities, durations, resolutions and aspect ratios. Public — no credential required. Video models vary far more than image models — duration and resolution options are per-model — so call this before generating.

api_listVoices

ChatGPT
List voices available to the current workspace, filtered by language. language_code is the ONLY required parameter — use an exact BCP-47 locale (en-US, en-GB, fr-FR, hi-IN, ja-JP). Combine with is_premium=true for a short, high-quality shortlist. The optional filters (gender, provider, engine, is_premium, language_name, search) all default to an empty string "", which means "no filter — return everything". Leave them at "" unless the user explicitly asked to filter. Do NOT substitute 0/false for "no filter": 0 is a REAL value (gender 0 = Male, provider 0 = Google, engine 0 = Neural), so sending it silently narrows the list. The empty-string default is the ONLY correct "unset" value. Response: - voices[]: id (uuid), voice_name, language_code, avatar, voice_sample, gender (0=Male, 1=Female, 3=Neutral), is_premium, description, supports_instructions (bool — true if the voice honors the instructions style/pace hint on generateAudio). Use id as voice_id in generateAudio. To re-resolve a single known voice_id (e.g. from a saved preference) without re-listing, use getVoice. - languages[]: distinct {language_code, language_name} pairs. To resolve a known voice_name (e.g. from an avatar roster) to its id, pass voice_name + language_code — that pair is unique, and the id differs per locale, so the name must be re-resolved whenever the language changes. Always check the entry you use actually has that voice_name rather than trusting voices[0] — see the voice_name parameter.

api_registerAsset

ChatGPT
Register an asset after the client successfully PUTs its bytes to the signed storage URL returned by signAssetUpload. Carry every registration field from that response unchanged and use the original filename for asset_name. Returns the permanent asset UUID used by social media.

api_reorderProjectItem

ChatGPT
Move a ProjectItem to a new position within the project. Updates the ordering of items accordingly. Path Parameters: - resourcetype: Project type selector - parent_lookup_project_id: Parent project ID - id: Item ID (UUID)

api_signAssetUpload

ChatGPT
Start the same direct-to-storage upload flow used by Simplified's UI. The client creates a UUID, calls this tool, then PUTs the local file bytes directly to the returned signed URL using the declared MIME type and no Simplified Authorization header. After the PUT succeeds, call registerAsset with the returned metadata.

api_updateContextDocument

ChatGPT
Update the content of a linked context document. Changes are applied to the underlying KnowledgeDoc, and its version is automatically incremented. Path Parameters: - brand_id: Brand kit UUID - document_link_id: Either the context-document link UUID (BrandKitContextDocument ID) OR the underlying KnowledgeDoc UUID — the endpoint resolves both.

api_updateProject

ChatGPT
Partially update a project. Use this to persist campaign lifecycle, configuration, research, approvals, and rolling outlook state. When changing data, first read the project and send the complete merged data object so unrelated state is retained. Path Parameters: - resourcetype: Project type selector - id: Project ID (UUID or integer depending on type)

api_updateProjectItem

ChatGPT
Partially update a project item as a campaign deliverable moves from planned through generation, review, scheduling, and publication. When changing data, first read the item and send the complete merged data. Path Parameters: - resourcetype: Project type selector - parent_lookup_project_id: Parent project ID - id: Item ID (UUID)

media_addBRollsVideo

ChatGPT
Analyzes the video or script and automatically inserts relevant B-roll clips. Provide either media_url (existing video) or asset (asset ID). Returns a task_id.

media_blurBackground

ChatGPT
Detects the subject and blurs the background. Synchronous — returns image_url directly.

media_convertImageFormat

ChatGPT
Convert an image from one container format to another (jpg, jpeg, png, webp, gif, bmp, tiff). Pass the source image_url and the target output_format. This changes the file format ONLY — for pixel-level edits (background removal, upscale, inpaint) use the other image tools in this module. Async — returns a task_id (auto-polled).

media_convertVideoFormat

ChatGPT
Convert a video to a different container/format via output_format (e.g. mp4, mov, webm, gif). Changes format only — not resolution or content. Async — returns a task_id (auto-polled).

media_downloadTranscriptionFile

ChatGPT
Step 3 — fetch the transcription as a subtitle file. Only call this after getTranscription returns job_status="DONE"; otherwise the file body will be empty. Response is the raw subtitle text. Path Parameters: - id: Transcription UUID.

media_generativeFill

ChatGPT
Fill a masked region of an image with AI-generated content described by prompt. Requires a mask (mask_url or mask_base64) marking WHERE to fill. Use this when you have a specific region to replace; for removing an object by description (no mask) use magicInpaint; to extend the image past its edges use imageOutpainting. Async — returns a task_id (auto-polled).

media_getTranscription

ChatGPT
Step 2 — poll this endpoint with the id returned by transcribeVideo. Read job_status: - Non-terminal (CREATED, PENDING, PROCESSING, RENDERING, UPDATED): keep polling. A 10s interval is reasonable. - Terminal: DONE (success — payload.phrases is now populated with word-level timing) or FAILED (error — stop polling). Once job_status="DONE" you can either read payload.phrases directly, or call downloadTranscriptionFile for a VTT/SRT file. Path Parameters: - id: Transcription UUID returned from transcribeVideo.

media_imageOutpainting

ChatGPT
Extend an image BEYOND its original borders (uncrop), generating new surrounding content from prompt. Requires mask_url marking the new area. Different from generativeFill (fills a region inside the image) and magicInpaint (edits existing content). Async — returns a task_id (auto-polled).

media_magicInpaint

ChatGPT
Remove or replace objects in an image, guided by prompt, with no mask needed (the model locates the target). Use for "remove the person" / "replace the car with a bike". With an explicit mask region use generativeFill; to extend beyond the borders use imageOutpainting. Async — returns a task_id (auto-polled).

media_mergeVideos

ChatGPT
Concatenate videos end-to-end in the order given by video_urls (needs 2+ URLs). The result is a single clip. Async — returns a task_id (auto-polled).

media_removeAudio

ChatGPT
Strip the audio track from a video, returning a silent clip. Async — returns a task_id (auto-polled).

media_removeBackground

ChatGPT
Removes the background from an image. Returns a task_id — poll for result.

media_replaceImageBackground

ChatGPT
Replace ONLY the background behind the detected subject — with a solid color, another image, or transparency. Set replace_type to color (needs replace_color), image (needs replace_image), or transparent. To blur rather than replace use blurBackground; to cut the subject out entirely use removeBackground. Async — returns a task_id (auto-polled).

media_restoreImage

ChatGPT
Restores and enhances image quality (denoising, artifact removal). Returns a task_id.

media_reverseVideo

ChatGPT
Reverse a video clip end-to-end so it plays backwards. Async — returns a task_id; poll getTaskResult (the toolkit auto-polls) for the output URL. Audio is reversed along with the video. For trimming or speed changes use speedupVideo; this only reverses direction.

media_scriptToVideo

ChatGPT
Creates a full video from a text script with voiceover, visuals, and captions. Returns a task_id.

media_sdScribble

ChatGPT
Turn a rough sketch/scribble into a finished image via Stable Diffusion ControlNet, steered by prompt (and negative_prompt). Pass the scribble as image_url or base64 image. Generates a NEW image from line art; to edit an existing photo use magicInpaint / generativeFill. Async — returns a task_id (auto-polled).

media_speedupVideo

ChatGPT
Change playback speed by playbackrate: >1 speeds up (2 = 2× faster), <1 slows down (0.5 = half speed). Async — returns a task_id (auto-polled).

media_textToVideo

ChatGPT
Creates a video from a short text prompt — similar to script-to-video but optimized for brief prompts rather than full scripts. Returns a task_id.

media_transcribeVideo

ChatGPT
Step 1 — submit a media URL for speech-to-text transcription. The response is only `{id}`. It does not contain the transcript and it does not contain any status flag. The STT pipeline runs asynchronously and updates the row later via provider webhooks. Next steps: - Step 2: poll getTranscription with the returned id until job_status="DONE" (or "FAILED"). - Step 3: optionally call downloadTranscriptionFile to get VTT/SRT.

media_upscaleImage

ChatGPT
Increases image resolution using AI. Returns a task_id — poll for result.

notify_sendAgentNotification

ChatGPT
Sends a single notification. It is routed through the notification registry, which determines delivery channels (in-app, websocket, email, Slack) based on the category.

pm_addTaskDependency

ChatGPT
Create a dependency relationship between two tasks. Required fields: target_task_id (UUID of the other task), relation_type (must be UPPERCASE): BLOCKS, RELATES_TO, or DUPLICATES. Use getTaskDependencies to read the current dependency graph before adding, to avoid duplicates. Returns the created relationship object.

pm_cloneBoard

ChatGPT
Deep-clone a board (statuses + top-level tasks) into the target workspace or space. Inherits PROTECTED access.

pm_cloneTask

ChatGPT
Clone a task, copying the fields listed in the fields array. Common fields to copy: title, description, rich_description, assignees, tags, attachments, subtasks, priority, start_date, due_date, checklist. Optionally redirect the clone to a different status (column) via status. Returns {detail_url, task} — the cloned task object with expand=tags,attachments,subtasks.

pm_createBoard

ChatGPT
Create a new PM board in the workspace. Optionally seed it with an initial set of statuses (columns) in one call via the statuses field. primary_type is pm (default) or blogger — lowercase, no other values. access controls visibility: 0=PRIVATE, 1=PROTECTED, 2=PUBLIC.

pm_createStatus

ChatGPT
Add a new column to a board. Required field: title. Optional: color (hex string e.g. #008CD3), order (integer position; appended at end if omitted). The new status id is returned and should be cached — it is required for createTask and searchTasks.

pm_createTask

ChatGPT
Create a task in a status column. The status UUID is required and determines which board the task belongs to. Composite fields (assignees, tags) are handled by the toolkit's middleware — pass them inline and the correct sub-resource calls are made automatically after creation. Note: assignees are NOT reflected in the create response; use getTask?expand=assignees to verify.

pm_deleteBoard

ChatGPT
Soft-delete a board. All tasks and statuses are cleaned up asynchronously. Use cloneBoard first if you want a backup. This action is not reversible via the API. Path Parameters: - board_id: Board UUID or slug.

pm_deleteStatus

ChatGPT
Delete a status column from the board. All tasks currently in this status must be moved first — the server rejects deletion if tasks remain. Use moveStatus to bulk-migrate tasks to another column before deleting.

pm_deleteTask

ChatGPT
Soft-delete a task. The task is marked deleted and excluded from normal queries but not immediately purged. Subtasks, attachments, and dependencies are cleaned up asynchronously. This action is not reversible via the API. Path Parameters: - task_id: Task UUID or slug.

pm_getBoard

ChatGPT
Retrieve a single board by UUID or slug. Use ?expand=statuses to include the status columns inline; use ?expand=creator,modifier for user details. Path Parameters: - board_id: Board UUID or slug.

pm_getStatus

ChatGPT
Retrieve a single status (board column) by board + status UUID. Use ?expand=creator for user details. Useful to confirm a status exists or to read its current order before repositioning.

pm_getTask

ChatGPT
Retrieve a single task by UUID or slug. Default response is lean — use ?expand= to pull nested data inline: assignees (user objects), tags (name list), subtasks, attachments, time_tracking, status_details, board. Multiple fields: ?expand=assignees,tags,time_tracking. Path Parameters: - task_id: Task UUID or slug.

pm_getTaskActivity

ChatGPT
Paginated audit trail for a task — status changes, assignee changes, comments, attachments, dependency changes, and field edits. Each entry includes verb, actor, timestamp, and a diff of what changed. Useful for feeding AI context about recent task history.

pm_getTaskDependencies

ChatGPT
Returns {blocks, blocked_by, related, is_blocked} — each list contains the counterpart task's {relationship_id, id, slug, title, complete, status}.

pm_listBoards

ChatGPT
List all PM boards the current user can access. Returns board UUIDs and slugs needed for listStatuses, searchTasks, and cloneBoard. Use this first when the user mentions a board by name — match on title from the response. Filter tips: search=<term> for server-side full-text match on board title/description (DB-backed — prefer this over fetching every board and filtering client-side); primary_type=pm (default) for task boards; is_public=true for public boards only; creator=<user_id> to scope to a creator; modified_after/modified_before for date-range filtering on last modification time (ISO 8601 date, e.g. 2026-01-01). Use page_size=50 to avoid missing boards on paginated workspaces. Always prefer this over searchBoards (removed) — ES index was unreliable.

pm_listStatuses

ChatGPT
Return all status columns for a board in display order. Each status is the container for a column of tasks on the Kanban board. The id values here are required by createTask, searchTasks, and moveStatus. Use ?expand=creator for user details.

pm_listSubtasks

ChatGPT
Return all direct children (subtasks) of a task. Subtasks are tasks whose parent field points to this task. They follow the same schema as regular tasks. Use getTask?expand=subtasks for an inline alternative.

pm_listWorkspaceMembers

ChatGPT
Returns all users in the workspace as a choices list. Use this to look up user IDs before calling updateTaskAssignees. Response: {"options": [{"value": <user_id>, "label": "Name (email)", "image": "..."}]} The value field is the integer user ID needed for updateTaskAssignees. Supports ?search=<name_or_email> for filtering.

pm_moveStatus

ChatGPT
Bulk-reassign all tasks currently in this status to a different status. Use this to drain a column before deleting it, or to migrate tasks between boards. Required body field: status_id (UUID of the destination status).

pm_removeTaskDependency

ChatGPT
Remove a dependency relationship by its relationship_id. Get the relationship_id from getTaskDependencies — it is the UUID on each entry in the blocks, blocked_by, or related arrays.

pm_searchRecentTasks

ChatGPT
Return recently modified tasks sorted by -modified (newest first). Use this when you need "what changed recently" without knowing a specific board/status. For targeted search within a board column, use searchTasks instead — it supports richer filters (assignees, tags, priority, complete) and is what the UI uses for all board-view loading.

pm_searchTasks

ChatGPT
The primary task query endpoint — used by the UI for ALL task loading, including the board view (no search) and board search box. IMPORTANT — always scope with board + status: The UI always passes board=<board_id> and status=<status_id> together, fetching one column at a time (page_size=10). Without scoping, results span the entire workspace (800+ tasks) with no relevance ranking. Correct agent pattern: 1. Call listStatuses to get status IDs for the board. 2. Call searchTasks?board=<id>&status=<sid>&search=<term> per column. Supports nested filters on assignees/tags, date ranges, and full-text search across title/description/tags/comments. SUBTASKS ARE EXCLUDED BY DEFAULT — pass include_subtasks=true to search them. A subtask that is absent from every result is not missing or unindexed; it is filtered out. Confirm with getTask by slug before concluding a ticket does not exist.

pm_updateBoard

ChatGPT
Partial update (PATCH) for a board. All fields optional — send only what you want to change. Updatable fields: title, description, access, extra (arbitrary JSON config merged into the board's _config). Path Parameters: - board_id: Board UUID or slug.

pm_updateStatus

ChatGPT
Partial update for a status column. All fields optional. Pass order (integer) to reposition the column in the board view — other columns shift automatically. Updatable fields: title, description, color, order.

pm_updateTask

ChatGPT
Partial update for a task. All fields optional. To move the task to a different status (column), pass status with the destination status UUID. Composite fields assignees_add/assignees_remove and tags_add/tags_remove are handled by the middleware — they trigger sub-resource calls automatically. description is converted to a Quill Delta (rich_description) by the toolkit. Path Parameters: - task_id: Task UUID or slug.

pm_updateTaskAssignees

ChatGPT
Add or remove users assigned to a task using integer user IDs. Use listWorkspaceMembers to look up user IDs before calling this. Body: {"add": [<user_id>, ...], "remove": [<user_id>, ...]} Either key may be omitted. Returns {} on success (no body — by design). To verify or read current assignees: getTask?expand=assignees. Note: ES index updates async (~5s lag) — searchTasks?assignees=<id> may not reflect a new assignment immediately.

pm_updateTaskAttachments

ChatGPT
Add or remove file attachments on a task. Attachments are addressed by attachment UUID (get IDs from getTask?expand=attachments). Body: {"add": ["<attachment_id>", ...], "remove": ["<attachment_id>", ...]}. Either key may be omitted. Returns the updated attachment list.

pm_updateTaskCustomFields

ChatGPT
Bulk-update custom field values on a task. Keys are custom field UUIDs, values are validated server-side against each field's type configuration. Path Parameters: - task_id: Task UUID or slug.

pm_updateTaskTags

ChatGPT
Tags are addressed by name. Unknown names are auto-created in the workspace.

social_addDraftsToSocialMediaReviewBundle

ChatGPT
Append additional drafts to a review bundle previously created via createSocialMediaReviewBundle, without recreating it. The operation is idempotent — a draft already present in the bundle is silently skipped, not duplicated. Draft IDs come from getSocialMediaDrafts. Returns the updated bundle, including the full list of drafts and the shareable review URL.

social_createSocialMediaPost

ChatGPT
Schedule, queue, or draft a social media post. Publishing actions ('schedule', 'add_to_queue') require at least one account in account_ids; 'draft' can be saved without any account. Optionally attach auto-comments via comments: a list of { "message": string, "delay": seconds } objects published after the post goes live, in array order. For a LinkedIn document (carousel) post, pass the PDF as additional.linkedin.document (see LinkedinDocument) with media: [].

social_createSocialMediaReviewBundle

ChatGPT
Create a review bundle, optionally seeding it with drafts. A review bundle groups social media drafts under a single shareable review URL so collaborators or clients can approve content before it is scheduled or published. Pass draft_ids to seed the bundle on creation, or create an empty bundle and append drafts later via addDraftsToSocialMediaReviewBundle. Draft IDs come from getSocialMediaDrafts. The response includes a linkToReview URL to share with reviewers.

social_createSocialMediaTag

ChatGPT
Creates a new tag for social-media posts. Tag names are NOT enforced unique by the backend — call listSocialMediaTags first and reuse an existing tag if a tag with the same name already exists, to avoid creating duplicates.

social_deleteSocialMediaDraft

ChatGPT
Delete a draft post by its group ID or an array of draft IDs. Provide at least one identifier.

social_deleteSocialMediaPost

ChatGPT
Delete a published post by its group ID or post schedule ID. Provide at least one identifier.

social_getSocialMediaAccounts

ChatGPT
Returns every connected social media account across every platform. DEFAULT USAGE — call exactly once with NO arguments: getSocialMediaAccounts() The single response already contains accounts from every connected platform combined. There is no per-platform endpoint; the same endpoint returns them all. ONLY pass network when the user explicitly named exactly ONE platform (e.g. "show me my Instagram accounts" → network="instagram"). FORBIDDEN PATTERN — do not call this tool multiple times with different network values to "collect all platforms". That is always wrong: the unfiltered call already returned them.

social_getSocialMediaAnalyticsAggregated

ChatGPT
Retrieve aggregated analytics metrics (totals and averages) for one or more social media accounts within a date range. At least one of account_id or account_ids must be provided.

social_getSocialMediaAnalyticsAudience

ChatGPT
Retrieve audience analytics data (followers, demographics, growth) for a specific social media account within a date range.

social_getSocialMediaAnalyticsPosts

ChatGPT
Retrieve analytics data for individual posts of a specific social media account within a date range.

social_getSocialMediaAnalyticsRange

ChatGPT
Retrieve time-series data for selected metrics of a social media account within a date range. Available metrics depend on the social network: - Instagram: impressions (deprecated), views, reach, profile_views, follower_count, text_message_clicks, website_clicks, email_contacts, posts_count, accounts_engaged, profile_links_taps, replies, shares, saves, total_interactions - Facebook: engaged_users, post_impression, post_impression_total, post_reach_total, post_impression_paid, post_reach_paid, post_reach, page_post_engagements, new_fan, reactions, total_fans, total_follows, link_clicks, video_play, other_clicks, photo_view, posts_count, post_reach_viral, page_reach - LinkedIn (Company): posts_count, impressions, unique_impressions, comments, likes, clicks, engagement, shares, allFollowers, organicFollowers, paidFollowers - LinkedIn (Personal): memberFollowers, impressions, comments, reactions, shares - Twitter/X: posts_count, retweetCount, replyCount, likeCount, quoteCount - YouTube: views, comments, likes, dislikes, estimatedMinutesWatched, averageViewDuration, posts_count - Pinterest: engagement_rate, save, pin_click_rate, outbound_click, video_mrc_view, video_avg_watch_time, impression, engagement, video_v50_watch_time, outbound_click_rate, save_rate, quartile_95_percent_view, video_start, video_10s_view, pin_click, posts_count - TikTok (Personal): posts_count, follower_count, likes_count - TikTok Business: posts_count, audience_genders, audience_countries, comments, shares, audience_activity, profile_views, followers_count, video_views - Threads: views, followers_count, likes, replies, reposts, quotes, clicks, posts_count - Google My Business: posts_count, queries_indirect, queries_direct, queries_chain, views_maps, views_search, actions_website, actions_phone, actions_driving_directions, business_impressions_desktop_maps, business_impressions_mobile_maps, business_impressions_mobile_search, business_impressions_desktop_search Unknown metrics are ignored by the API.

social_getSocialMediaDrafts

ChatGPT
Retrieve unpublished draft posts for the given accounts. Supports pagination, search, and sorting.

social_getSocialMediaPosts

ChatGPT
Retrieve published posts for the given accounts. Supports pagination, search, and category filtering. Returns post content, media, scheduling info, and per-post metrics.

social_listSocialMediaTags

ChatGPT
Returns all tags (a.k.a. "labels") available for filtering and assigning to social-media posts/drafts. Tags are workspace-wide and shared by all users in the workspace. Always pass product=social_media so PM tags are not returned. Pagination is disabled.

social_updateSocialMediaDraft

ChatGPT
Update the content, schedule, or media of a draft post. Only provided fields are changed.

social_updateSocialMediaPost

ChatGPT
Update the content, schedule, or media of a published post. Only provided fields are changed.

Capabilities

Writes

Example Prompts

Click any prompt to copy it.

App Stats

116

Tools

3

Prompts

ChatGPT

Platforms

Works with

ChatGPT

Data refreshed daily