Morpha

{
  "id": "aix_dba7478781",
  "name": "Morpha",
  "operator": "(unclaimed - source: registry-official · publisher: ai.morphareels)",
  "description": "AI editor to build, animate & export layered short-form video projects via one tool catalog.",
  "depth": 1,
  "status": "unclaimed",
  "last_crawled": "2026-09-07",
  "missing_fields": [
    "pricing",
    "reputation",
    "aix_score",
    "operator.identity"
  ],
  "skills": [
    "browser-automation",
    "media-catalog",
    "ocr-extraction",
    "sql-database",
    "subtitle-sync",
    "translation-qa",
    "voicemail-transcribe"
  ],
  "protocols": {
    "mcp": "https://morphareels.ai/mcp",
    "a2a": null
  },
  "pricing": null,
  "regions": [
    "global"
  ],
  "languages": [
    "en"
  ],
  "reputation": null,
  "aix_score": null,
  "verification": {
    "identity": "none",
    "health": "liveness-only",
    "pricing": "unknown",
    "last_check": "2026-09-07T16:01:31.185Z"
  },
  "pricing_model": "unknown",
  "unreachable": false,
  "profile": {
    "mcp_server": "morpha",
    "mcp_version": "0.1.0",
    "tool_count": 95,
    "tools": [
      {
        "name": "create_account",
        "description": "Create a fresh Morpha account and get an API key back, with no browser, no email and no human involved. Call this FIRST when you have no key, then send the returned `token` as `Authorization: Bearer <token>` on every later call. Takes an optional `name` that labels the key. The account can build, edit and render, and it has NO AI credit envelope — drive the tool catalog with your own model, which is free and unmetered. Nobody can sign into this account, so when you are done, share the project to the human's email address (PUT /api/project/<id>/share, or ask them to sign in and use their own ac"
      },
      {
        "name": "list_projects",
        "description": "List projects as { id, name, editorUrl } entries. The id is what every other tool's `projectId` argument takes. `name` is the human-readable label shown in the editor's project picker (\"Untitled\" when no name has been set — ids are opaque and never shown to the user, so always refer to a project by its name). `editorUrl` is a tappable link that opens that project in the editor — offer it to the user (by name) when they want to look at one. By default lists the user's OWN personal projects (those not in any workspace). Pass `workspaceId` (from list_workspaces) to instead list the projects that "
      },
      {
        "name": "list_workspaces",
        "description": "List the workspaces (shared team spaces) the account belongs to, as { id, name, role, memberCount } entries. `role` is the caller's role in that workspace (owner / admin / editor / viewer) — only owner/admin/editor can add projects. Use the `id` as the `workspaceId` argument to create_project, move_project_to_workspace, and list_projects; refer to the workspace by its `name` when talking to the user (never paste the id). Returns an empty list when the account has no email (workspace membership is email-based, so a keyless/dev identity sees none). Call this to discover a workspace before placin"
      },
      {
        "name": "open_project",
        "description": "Get a tappable link that opens a project directly in the editor (the editor loads exactly this project from the URL). Returns { name, editorUrl }. Use this whenever the user wants to view their work — after you make a change, or when they say \"show me\" / \"open it\" — then give them the editorUrl and invite them to tap it. Refer to the project by its name in your reply; the link is the tap target."
      },
      {
        "name": "create_project",
        "description": "Create a new project and return its server-minted id. The id is an opaque v4 UUID assigned automatically — you never choose or name it; refer to the project by its `name`. By default this mints a fresh BLANK project (empty canvas, no layers) — creation is independent from cloning. Pass `fromProjectId` ONLY when you want to clone: the new project then copies that project's JSON, uploaded assets, and uploaded clips, and — like duplicate_project — FOLLOWS THE SOURCE'S workspace by default (cloning a team project stays in that team; a blank project is personal). Pass `workspaceId` (from list_works"
      },
      {
        "name": "move_project_to_workspace",
        "description": "Move a project into a workspace, or back to the caller's personal space. Pass `workspaceId` (from list_workspaces) to place the project in that workspace — every member then sees it, with their workspace role deciding edit vs view. Pass `workspaceId: null` to detach it back to personal. Requires an edit-capable role (owner/admin/editor) in the TARGET workspace and write access to the project. Switching a project from one workspace to another cleanly drops the old membership."
      },
      {
        "name": "list_collection",
        "description": "List the user's reusable Collection — layers they added with add_to_collection (lower-thirds, logo stings, brand intros, or any single layer). Returns { items: [{ scope, workspaceId, sourceProjectId, sourceProjectName, ownerEmail, elementId, name, kind, childCount }] }. `scope` is \"personal\" (from the user's own solo projects) or \"team\" (from a workspace they belong to). Show the user each item's `name` (and its `sourceProjectName`); `sourceProjectId` + `elementId` feed add_from_collection to drop a self-contained COPY into another project. Works on a solo account (personal items always includ"
      },
      {
        "name": "add_from_collection",
        "description": "Add an item from the user's Collection into a project as a self-contained COPY. Pass the destination `projectId`, plus the `sourceProjectId` + `elementId` of an item from list_collection. Copies that layer (a whole group brings its children) plus its image/clip/font bytes into the destination at fresh ids and its original canvas position — fully detached, so it is immediately yours to edit and nothing links back to the source (deleting or changing the source never affects this copy). The element must actually be in the source project's collection and you must be able to read that project. An o"
      },
      {
        "name": "duplicate_project",
        "description": "Duplicate an existing project into a brand-new one — a full copy of its layers, animations, styles, uploaded assets, and clips. Pass the SOURCE project's `projectId`; the copy gets a fresh id automatically (ids are opaque — never shown to the user). Defaults the copy's name to \"<source name> copy\" unless you pass `name`. WORKSPACE: the copy FOLLOWS THE SOURCE by default — a project in a workspace is copied into that SAME workspace, and a personal project stays personal. Pass `workspaceId` to override: a workspace id (from list_workspaces) to place the copy in a specific workspace (you need an "
      },
      {
        "name": "rename_project",
        "description": "Update a project's human-readable name (shown in the editor's project picker). Pass an empty string to clear the name and fall back to the id. Doesn't touch any layers, animations, or styles — only the picker label."
      },
      {
        "name": "reid_project",
        "description": "Change a project's id LOSSLESSLY — re-keys its JSON, every saved version, and all assets + clips, then deletes the old id. Unlike create_project (clone), version history is preserved. Enforces the id policy: the new id is always a v4 UUID — pass `newId` to choose one, or omit to mint a fresh UUID. A project's `name` (the only user-facing label) is untouched, so the picker/editor are unchanged. The editor won't auto-refresh — reload to see the new id in URLs."
      },
      {
        "name": "delete_project",
        "description": "Permanently delete a project: its JSON, shortlist, versions, uploaded assets, and uploaded clips. Requires edit access — the owner, a workspace editor/admin/owner, or a direct-share editor; anyone else gets the opaque not-found. Deleting the last remaining project is allowed. The user's editor session won't auto-refresh — if they were viewing the deleted project they'll need to reload."
      },
      {
        "name": "save_version",
        "description": "Save a version of the current project state. ALWAYS call this once after each meaningful set of changes you make on the user's behalf — the user flicks between versions to compare or roll back, so an unsaved edit is one they can't easily revisit. Use a short descriptive `name` (e.g. \"add slide-in animation\"); the user sees this verbatim in the picker. One version per logical change-set, not one per individual tool call."
      },
      {
        "name": "list_versions",
        "description": "List every saved version of a project, newest-first. Returns summaries (id, name, timestamp, source, kind, version_number, cp) — not the inner project JSON. `kind` is `\"bookmark\"` (deliberate save, gets a v<N> label, partner-pinnable in the <morpha-video> embed) or `\"auto\"` (editor auto-snapshot every ~10 mutations, restore-only). `version_number` is bookmark-only and stable for the lifetime of that version — deletes leave gaps, numbers never re-shuffle. `cp` names which pages the version changed (comma-joined 8-char page-id prefixes; `\"*\"` = page order only; absent = unknown, treat as all pag"
      },
      {
        "name": "restore_version",
        "description": "Load a saved version over the live project. Accepts either the version's UUID `id` or the `v<N>` shorthand (e.g. `\"v6\"` finds the bookmark with version_number=6); auto-snapshots are addressable by UUID only. Without `page_index` this replaces the ENTIRE project (every page) — an auto checkpoint named `before restore: …` is saved first whenever the current state has unsaved changes, so the overwritten state stays recoverable. With `page_index` it restores ONLY that page: the page is matched across versions by its stable id and replaced verbatim (canvas size and name included); other pages are u"
      },
      {
        "name": "rename_version",
        "description": "Rename a saved version's human-readable label (what the user sees in the picker). The `v<N>` partner-facing identifier is unaffected — only the display name changes. Accepts the version's UUID `id` or the `v<N>` shorthand. Empty / whitespace-only names are rejected."
      },
      {
        "name": "delete_version",
        "description": "Permanently delete one saved version (bookmark or auto-snapshot). Accepts the version's UUID `id` or the `v<N>` shorthand. The bookmark v<N> sequence keeps gaps — numbers never re-shuffle — so any external snippet referencing the deleted `v<N>` will fail to resolve afterwards. Idempotent: deleting a non-existent version is a no-op."
      },
      {
        "name": "upload_image",
        "description": "Upload an image into a project by fetching a public http(s) URL server-side (the still-image counterpart of upload_clip). The worker downloads the .png/.jpg/.jpeg/.gif/.webp/.svg, stores it in the project's asset bucket, and returns { filename, sizeBytes, contentType } — pass the returned `filename` to add_image_layer. Use this when you already have a direct image URL; to search an openly-licensed image pool instead, use find_public_image. The url must be a direct, publicly-fetchable http(s) link (not an auth-walled page). SVGs are rejected if they carry a <script>, an inline event handler, a "
      },
      {
        "name": "upload_audio",
        "description": "Upload an audio track into a project by fetching a public http(s) URL server-side — the ONLY way to get an audio file's bytes into a project over MCP/HTTP (add_audio_overlay / update_audio_overlay only reference a filename that must already be uploaded). The worker downloads the .mp3/.m4a/.wav/.ogg/.aac, stores it in the project's asset bucket, and returns { filename, sizeBytes, contentType }. Then pass the returned `filename` to add_audio_overlay (add a second track) or update_audio_overlay { id, filename } (replace an existing track's file — find the id via describe_video's audio_overlays). "
      },
      {
        "name": "find_public_image",
        "description": "Search a PUBLIC, Creative-Commons + public-domain image pool (Openverse) for the query, download the top suitable result, store it in the project's asset bucket, and return the filename ready for add_image_layer. This finds someone else's openly-licensed image — it is NOT for uploading your own image (use upload_image for that). Use it for any \"get me a parasol\" / \"find a beach photo\" / \"add a coffee cup\" request — saves the upload-then-add_image_layer dance. Free; no model spend. Falls back to 404 when no suitable downloadable image is found. Always returns attribution { creator, creator_url,"
      },
      {
        "name": "detect_text_regions",
        "description": "Return the OCR text regions detected in a clip's video frames OR a still image asset. Pass either `clip` (a video.<id>.clip filename) or `image` (an image layer's filename) — not both. Video clips are sampled every 0.3s at upload time; images are OCR'd once. Results are cached in R2 next to the source. Returns { status: 'ready' | 'not-ready', frames: [{ frame, time, words: [{ text, x0, y0, x1, y1, confidence }] }], videoWidth, videoHeight }. For an image there's a single frame (frame 0); videoWidth/videoHeight are the image's pixel dimensions. Each `words` entry is one detected text line — `te"
      },
      {
        "name": "safe_zones",
        "description": "Return horizontal 'safe band' y-ranges of the canvas where a clip's burned-in video text (subtitles, lower thirds, titles) does NOT appear, plus the inverse 'text bands' (where it does). Reads the OCR cache built at clip-upload time (see detect_text_regions). Coordinates returned in BOTH source pixels and CANVAS pixels — canvas coords already account for the video layer's fit/anchor/position. Use to lay out captions, titles, callouts so they never collide with the video's own text. Returns { ok: true, status: 'ready' | 'not-ready', data: { bands, safeBands, textBands } }."
      },
      {
        "name": "transcribe_clip",
        "description": "Return the cached transcript of a clip's audio. Generated client-side in the Morpha editor (transformers.js Whisper) and cached in R2 next to the clip; if absent, it is produced when the clip is opened in the editor. Independent of the clip's video codec — runs on the audio track only, so it works on HEVC/AV1 clips that the OCR pipeline can't decode. Returns { ok: true, status: 'ready' | 'not-ready', data: { text, word_count, words: [{ word, start, end }], vtt? } }."
      },
      {
        "name": "clip_processing_status",
        "description": "Report whether a clip — or every video clip in the project, if `clip` is omitted — has been through the browser-side video-processing pipeline: proxy build, audio split, transcription, OCR (text regions). Processing never runs on the server. The preview proxy is mandatory: every processing run builds it (client.addVideo / client.processClip / client.processProject in the morphareels-sdk npm client, which drive local Chrome), and the Morpha editor builds any missing proxy for every page's clip when the project is opened. The other steps run through the same npm client or in the editor. Returns "
      },
      {
        "name": "describe_video",
        "description": "Structural OVERVIEW of the composition (the table of contents) — canvas size, duration, the backdrop summary, and a z-ordered tree (top of stack first) of every layer with its elementId, type, name, type label (filename/clip/text/kind), geometry (x/y/width/height), and which properties are animated. Does NOT include keyframe values or styles — those are unbounded. On a multi-page project the tree describes the ACTIVE page and the data carries a `pages` block ({ page_count, active_index, pages: [{ index, name, has_video }] }) — content tools target that active page; use select_page to switch wh"
      }
    ],
    "profiled_at": "2026-09-07T16:01:31.185Z"
  }
}