Skip to main content

Supported tools

The Tape MCP server exposes 23 tools for finding, reading and changing content in your Tape organization. An assistant combines them: it looks up an app, reads the records that match a condition, and writes a comment on the one that matters.

Every tool is advertised on connection with a description written for the model, so your client's tool list is always current. This page is the version for people: what each tool is for, what it will not do, and which capability its token needs.

Argument and result keys are snake_case, matching the developer API. Tools map onto API resources, so a tool does what the corresponding resource does, under the same capability and the same workspace and app selection. Renaming or removing a tool would be a breaking change for every connected client, so the names below are a stable contract.

At a glance​

ToolPurposeCapability
Finding your way around
tape-get-appsEvery app the token can see, with its workspaceapps:read
tape-list-shared-recordsRecords the token reaches individually, outside the apps it is grantedrecords:read
tape-searchFull-text search across apps and recordsapps:read or records:read
tape-fetchOne app, record, view, workspace, automation or automation run by idvaries by type
tape-get-workspacesThe workspaces you belong toworkspaces:read
tape-get-usersFind people in your organization by nameorganization:read
Records
tape-query-recordsList an app's records, or run a saved viewrecords:read (+ apps:read)
tape-create-recordsCreate one or more recordsapps:read + records:edit
tape-update-recordChange field values on one recordrecords:read + records:edit (+ apps:read)
tape-create-file-uploadMint an upload ticket for an attachmentrecords:edit
Comments
tape-get-commentsA record's comments and their repliesrecords.comments:read
tape-create-commentPost a comment, optionally with @mentionsrecords.comments:edit
Structure
tape-create-databaseCreate an app, optionally with its fieldsapps:edit
tape-update-databaseChange an app and its fieldsapps:read + apps:edit
tape-create-viewCreate a saved viewapps:edit
tape-update-viewChange a saved viewapps:edit
tape-create-workspaceCreate a workspaceworkspaces:edit
tape-update-workspaceRename a workspace or change its descriptionworkspaces:edit
Automations
tape-get-automationsAutomations you administrateautomations:read
tape-get-runsExecutions: what ran, when, and whether it workedautomations:read
tape-create-automationCreate an automation, pausedautomations:edit
tape-update-automationChange, activate or pause an automationautomations:edit
tape-run-automationRun one automation immediatelyautomations:run

A capability in parentheses is conditional — needed only on some calls, and the two behave differently. Without apps:read, tape-update-record fails on the calls that need it, while tape-query-records still answers in full and only its diagnostics degrade. Grant it alongside either way. See the capability table for the same information organised by what you want the assistant to do.

No tool deletes anything, and nothing grants people access. No record, comment, app, workspace or automation, and since 2026-08-23 no field or field option either — tape-update-database used to be the exception and no longer is. Removing a field or an option is something a person does in the Tape app. tape-update-database is still flagged destructive, for the reason given in its section. See Security best practices.

Finding your way around​

List apps​

tape-get-apps

Returns every app the token can see, with the workspace each one belongs to. Start here when you have no ids yet: Tape organizes data as workspaces, which hold apps, which hold records. This is not paginated, so it returns the complete picture in one response.

Note: "Every app the token can see" is not "everything the token can reach". A record can be shared with you individually inside an app you cannot open, and no app is listed here for it. tape-list-shared-records is the other half of the picture.

Note: Not every app holds records. An app is a database, a dashboard or a form, and only database apps have records and fields. Filter on type before passing an app_id to a tool that reads records. Two apps in different workspaces can share a name.

Example prompts:

  • "What apps do we have in Tape?"
  • "Which apps are in the Sales workspace?"
  • "Find the app where we track candidates"

List records shared with you​

tape-list-shared-records

Lists the records the token can reach individually — granted on the record itself, or matched by a permission rule — where it holds no app-level access to the app they live in. It is the only tool that enumerates them: tape-get-apps lists apps and tape-query-records needs an app id, so no app-based listing reliably reaches past the app boundary. Rows are previews — ids, app name, title, link, author and creation time, with no field values. Newest first, paginated, with a maximum of 100 records per page.

Note: Pair it with tape-get-apps: that one lists what the assistant can browse, this one lists what reaches it from outside. Without it, an assistant asked what it can see enumerates everything it can browse and reports that as the complete answer.

Note: "Shared with you" is not exact, in both directions. A permission rule can place a record here because you created it or because a field names you, with no share involved — so these are records you can reach, not necessarily records someone shared with you. And a record shared with you inside an app you hold access to — through workspace membership or a grant on the app itself — is deliberately absent; read that one with tape-query-records on its app.

Note: The app_id on a row is usually an app the token cannot read, so tape-fetch with type: "app" on it, or tape-query-records with that id, will often be refused. That is expected rather than a fault. Read a row in full with tape-fetch and type: "record", which checks permission on the record itself.

Note: There is no total, and an empty list is not proof that an account reaches nothing: a token restricted to selected workspaces or apps has this listing silently narrowed to them as well. The date a record was shared with you is not recorded and is not returned.

Example prompts:

  • "What is shared with me?"
  • "Take stock of everything this account can reach"
  • "Are there records I can see outside my own apps?"
  • "List what is shared with me and summarise the newest one"

tape-search

Searches across every app and record the token can reach, best match first — including records shared with it individually, in apps it cannot otherwise open. Use it when you have words rather than ids: a record someone described in prose, or an app named approximately. Results are previews — ids, names, titles, a link and creation times — enough to identify something and then read it. Paginated, with a maximum of 100 results per page.

Note: Search returns no field values and no total count. Use has_more to decide whether more results exist. It cannot express "all records where status is open", which is tape-query-records with filters. Because it needs words that match and reports no total, it can confirm that a record exists but can never answer "what do I have access to" — that is tape-list-shared-records. A token holding only apps:read searches successfully and returns no records at all, because search narrows rather than refuses.

Example prompts:

  • "Find the record for the Meyer project"
  • "Is there already a record for this customer?"
  • "Which apps mention onboarding?"
  • "Show me everything created in the CRM workspace last week"

Fetch one thing by id​

tape-fetch

Reads one app, record, saved view, workspace, automation or automation run by its id. With type: "self" it returns the user and organization the token acts as, which is the fastest way to confirm a connection. It also serves the five static specifications that are otherwise MCP resources: field_value_spec, filter_spec, view_spec, app_field_spec and automation_schema.

Note: Each arm needs a different capability, so one token reads some and not others. The automation and automation_run arms need automations:read, which is not part of a normal read-only token, and reading a run needs workspace admin rights on top of it. self and the five documents need no capability at all.

Note: One arm is not addressed by id. type: "automation_run" takes run_id instead — a string, produced only by tape-get-runs, which should be passed back exactly as it was received rather than parsed into a number. See Read one run.

Note: No documentation arm takes a per-type narrowing, so each serves its whole document. That matters most for automation_schema, which is around 75 KB — roughly as large as the other four put together. The resource form can be narrowed to one block type (tape://docs/automation-schema/{block_type}), so prefer it if your client reads resources; the arm exists for clients that cannot.

Note: A Tape id is only unique within its own kind and the sequences overlap, so a wrong type does not reliably fail: reading a record id with type: "app" can return a real, unrelated app. Take type from wherever you got the id.

Example prompts:

  • "Which Tape account am I connected as?"
  • "Show me the field structure of the Deals app"
  • "What does this view filter on?"
  • "Read record 4711"

List workspaces​

tape-get-workspaces

Returns the workspaces the token can reach, each with its visibility type: open, default, closed or private. Read the type before creating anything inside one, because it decides who else sees what you put there.

Note: This answers the workspaces the account is a member of, not an inventory of the organization. Other workspaces may exist that this token cannot see.

Example prompts:

  • "Which workspaces do I have access to?"
  • "Is the Finance workspace private?"
  • "Where should I put a new app for the recruiting team?"

Find people​

tape-get-users

Looks up people in the organization by name and returns their user_id, which is what an @mention needs. For assigning someone to a user field you often do not need it at all: Tape resolves an unambiguous plain name on write. Look the id up when a wrong guess would matter.

Note: Returns only ids and names, never email addresses or phone numbers, and it cannot enumerate the organization: a query is required. Deactivated users are excluded, so someone who has left will not be found. To find out who you are, use tape-fetch with type: "self" instead.

Example prompts:

  • "What is Jana's user id?"
  • "Are there two people called Müller in our organization?"
  • "Who should I assign this to, find me Stefan"

Records​

Query records​

tape-query-records

Lists the records of one app, or executes one of its saved views. Each record comes back with its field values, so you rarely need a follow-up read per row. Supports filtering by field value, selecting only the fields you need, and paging up to 500 records per page.

Note: Read the filter specification (tape://docs/filter-spec) before writing filters. The accepted shape depends on the field's field_type, and field_type is not type: a status field reads back as category, attachment and image both as file.

Note: A field with no value is omitted from the response rather than returned empty, so a misspelled entry in select_fields looks exactly like an empty field. Check unresolved_fields, which lists every selection that matched nothing.

Note: apps:read is conditional here and, unlike on tape-update-record, it never makes the call fail. It is reached for only to explain an entry in unresolved_fields; without it the records still come back in full and that entry's reason degrades to unknown. Filters do not touch the app schema at all.

Example prompts:

  • "List all open deals over 10,000 euro"
  • "Run the 'Overdue tasks' view and summarise it"
  • "Which records in this app have no owner set?"
  • "Export the contacts app as a table"

Create records​

tape-create-records

Creates one or more records in an app, up to 10 per call. Records are created published and immediately visible to everyone who can see the app. There is no draft state on this surface.

Note: This is not idempotent and there is no undo — no tool on this surface removes a record. Calling it twice creates two sets of records. After a failure or timeout, check with tape-search or tape-query-records before retrying.

Note: By default a created record notifies followers, fires webhooks and triggers automations, exactly as one created by hand does. silent, no_webhook and no_workflow suppress each of those and all three default to false. The same three flags exist on tape-update-record and tape-create-comment, and nowhere else on this surface. See Security best practices.

Note: Field keys are validated before anything is created. An unknown key, a read-only field, or a whole field object copied from a read are each refused, because Tape would accept all three without error and write nothing. A refusal means no records were created, not some of them.

Example prompts:

  • "Add a record for the call I just had with Meyer GmbH"
  • "Create three tasks from these bullet points"
  • "Log this invoice in the accounting app"

Update a record​

tape-update-record

Changes field values on one existing record. This is a partial update: fields you name are changed, fields you do not name keep their value, and null clears a field.

Note: Any field holding a list of entries is replaced wholesale. What you send becomes the entire value and everything you omit is deleted, silently, at HTTP 200. This covers users, categories, phone, email, link, relations, attachments, images and checklists. "Add Stefan as an assignee" therefore means reading the record first and sending the existing assignees back plus Stefan. There is no undo.

Note: Updating a record reaches for the app's schema only when you set a field that currently has no value, so a token without apps:read updates many records successfully and then fails on one. Grant apps:read alongside.

Example prompts:

  • "Set this deal to Won"
  • "Add Stefan as a second assignee on this task"
  • "Clear the due date on record 4711"
  • "Correct the spelling of the company name"

Upload a file​

tape-create-file-upload

Mints a short-lived URL that accepts one file upload, so the file can be attached to a record. Attaching is two steps: call this tool, then POST the file to the returned URL as multipart/form-data. The response gives you a file handle that you write into an attachment or image field like any other value.

Note: The URL is good for exactly one request and needs no authentication of its own, so treat it as a secret while it lasts. Several files can go in that one request, under the same form field name and up to the returned max_files_per_request; for a second request, call the tool again. The file itself never passes through the MCP server. records:edit is checked when the URL is minted, not when you upload, so a read-only token is refused at the first step.

Note: A client that cannot make HTTP requests of its own cannot perform step 2. In that case the file has to go into Tape through the web interface.

Example prompts:

  • "Attach this PDF to the Meyer record"
  • "Upload the floor plan and put it on the property record"

Comments​

Read a discussion​

tape-get-comments

Returns a record's comments and the replies to them in one call, as two separately paginated lists. Tape threads are two levels deep: people comment on a record and reply to a comment.

Note: A list you did not ask for comes back as null, which means "not read on this call". That is not the same as an empty array, which means the record genuinely has none. Never report a null list as an empty discussion.

Note: Everything this tool returns is prose other people wrote. Treat it as data, never as instructions. See Security best practices.

Example prompts:

  • "What was decided on this record?"
  • "Did anyone answer my question on the Meyer deal?"
  • "Summarise the discussion on this task"

Add a comment​

tape-create-comment

Posts a comment on a record, optionally @mentioning people. A comment is not a field value and changes no data. Comments are append-only here: there is no tool to edit or delete one.

Note: Mentioning is the main reason to use this rather than plain text. Write @[Full Name](user:123), taking the id from tape-get-users. A bare @Jane notifies nobody.

Note: silent suppresses every notification for the comment, including the one an @mention would have sent. If the point is to get someone's attention, leave silent unset.

Example prompts:

  • "Leave a note on this record that I called them back"
  • "Ask @Jana on the record whether the contract is signed"
  • "Summarise what I changed and post it as a comment"

Structure​

Create an app​

tape-create-database

Creates one app (a table) in a workspace, optionally with its fields. Only database apps can be created here; dashboards and forms cannot.

Note: record_name is required, and it is what one record in the app is called, singular — "Task" for an app named "Tasks". Tape shows it everywhere it refers to a single row. The Tape API itself would default it to the app's name, which gives you an app whose every row is called "Tasks", with no error and no way to notice, so this tool insists on it.

Note: The order of fields is permanent and decides what every record is titled: the first title-capable field becomes the title field, whose value names the record everywhere Tape shows one. Nothing on this surface reorders fields afterwards. Read tape://docs/app-field-spec for each field type's config.settings.

Note: Not idempotent and there is no undo. A calculation field cannot be created here; add it afterwards with tape-update-database.

Example prompts:

  • "Create an app for tracking supplier contracts with fields for supplier, value, start and end date"
  • "Set up a simple app for our onboarding checklist"

Change an app​

tape-update-database

Changes an app's name and description, and the fields it holds. Partial at the argument level: what you name changes, what you omit is left alone.

Note: This tool cannot delete, as of 2026-08-23. It removes no field and no field option, and nothing else on this surface does either — that is now a job for a person in the Tape app. If you built against the old shape, the two removed arguments now behave differently from each other: fields_to_delete and allow_deleting_field_values are simply gone from the schema, so a call still sending them succeeds with everything else applied and nothing deleted, no error. options_to_delete, which rides inside a fields entry, is instead refused, and the whole call is rejected — nothing changes, not the options and not the rest of it. Tape refuses both again behind the tool, so this is a property of the surface, not of one client's arguments.

Note: A new field is always appended last. config.position is ignored when it is a string and rejected when it is a number, and no tool here reorders fields — so an app's first field, which supplies every record's title, cannot be changed through MCP at all.

Note: The tool is still flagged destructive, because not deleting is not the same as not losing data. A field entry is a replace, not a patch. config.label is required on every entry, and every top-level config key you leave out is reset — with one exception: what you omit inside config.settings survives, so a label-only change keeps a number field's unit and decimals and a category field's options. Do not echo settings back to protect it. An options entry carrying an existing id renames that option everywhere, so every record holding it reads differently afterwards. The whole call is all or nothing.

Example prompts:

  • "Add a priority field to the tasks app"
  • "Rename the 'Owner' column to 'Account manager'"
  • "Make the due date field required"

Create a view​

tape-create-view

Creates a saved view on an app: a stored query with its own filters, sort, grouping and layout. A view is the human-visible way to save a query; to filter records without storing anything, use tape-query-records.

Note: Some arguments succeed without doing what you asked. A sort_by naming a field that exists nowhere is dropped in silence and the view is created unsorted, and sort_desc without sort_by is discarded. Read the returned view rather than assuming. Note also that no tool on this surface makes a view the default or makes it private — there is no argument for either, so asking for one has no effect.

Note: A view created here is public. Everyone who can see the app sees it.

Example prompts:

  • "Create a board view grouped by status in the deals app"
  • "Add a view showing only tasks due this week, sorted by priority"
  • "Make a view of contacts without an email address"

Change a view​

tape-update-view

Changes a saved view's name, layout, filters, sort, grouping or display settings.

Note: An argument you omit is left as it is, but an argument you send replaces what is stored. filters, fields, split_by, table and board are replaced as whole collections and never merged: send one filter and the view has one filter. Read the view first with tape-fetch and type: "view".

Note: The same silent outcomes as tape-create-view apply. name: null preserves the current name rather than clearing it, and table and board read back null for the layout the view is not in — a reporting artefact, since those settings return unchanged when you switch back.

Example prompts:

  • "Rename this view to 'Sprint board'"
  • "Filter this view to open items only"
  • "Group the view by owner instead of by status"

Create a workspace​

tape-create-workspace

Creates a workspace, the top-level container that holds apps. type is required and accepts private, open or closed — default is deliberately not offered here, because making a workspace the organization's default is a decision for a person in Tape.

Note: Requires a token whose content selection is All, plus an organization role permitting workspace creation. A token restricted to selected workspaces and apps is refused outright, and that refusal names no capability, so a broader capability set will not fix it. See Content selection.

Note: Not idempotent, and nothing on this surface deletes a workspace. Ask which type is wanted before creating; private is the only one that cannot over-share.

Example prompts:

  • "Create a private workspace called Recruiting 2026"

Change a workspace​

tape-update-workspace

Changes a workspace's name, description or icon. Nothing else about a workspace can be changed here, and the route additionally requires workspace-admin rights that no capability expresses.

Note: The workspace type, which decides who reaches what is inside, cannot be changed on this surface. Tape ignores an attempt silently and answers success with the old type. Members cannot be added or removed either. Both are decisions for a person in Tape.

Note: Neither null nor an empty string is accepted, so a description or icon cannot be cleared here. This differs from tape-update-record, where null clears a field.

Example prompts:

  • "Rename the Sales workspace to Revenue"
  • "Give the Recruiting workspace a proper description"

Automations​

An automation is a saved program belonging to one app: a trigger, an optional filter, and an ordered list of actions. These tools need their own capabilities, which a normal read-only token does not carry — and the three are independent of one another, so a token can hold one and not the others. See the capability table.

Every automation route additionally requires admin rights on the workspace the app is in. That is a role rather than a capability, so no broader token fixes it, and no automation tool reports it as a capability problem. tape-get-automations and tape-get-runs return an empty page and no error, so an account that administrates nothing sees exactly what an organization with no automations sees. Everything else — including tape-fetch with type: "automation" or type: "automation_run" — answers 404, the same answer as an automation that does not exist.

List automations​

tape-get-automations

Lists the automations the account administrates, one page at a time. It is the usual way to obtain an automation id; tape-get-runs also carries automation_id on every row it returns.

Note: An empty list is not proof that the organization has no automations. Automations live in apps, and this shows only those in workspaces where the account is an admin. Say "I cannot see any", not "there are none".

Note: trigger, filter and actions come back in Tape's own automation grammar. Read tape://docs/automation-schema for what the shapes mean, and send them back to tape-update-automation unchanged unless you mean to change them.

Example prompts:

  • "What automations run on the deals app?"
  • "Is there an automation that sends the welcome email?"
  • "Which automations are currently paused?"

List runs​

tape-get-runs

Lists executions of automations: what ran, when, and whether it worked. Every filter is optional.

Note: Only about 30 days of runs are kept. An automation showing no runs may simply not have run this month, which is not evidence that it never runs. Simulation runs performed in the Tape interface never appear here.

Note: type is manual for a run somebody or tape-run-automation started by hand, and regular for one a trigger fired.

Example prompts:

  • "Did the invoice automation run last night?"
  • "Show me everything that failed today"
  • "How often did this automation run this week?"

Read one run​

tape-fetch with type: "automation_run"

Reads one execution including the log of every step: the trigger, the filter, and one entry per action, with one entry per iteration for actions inside a loop. This is the arm for "why did that fail".

Note: It is addressed by run_id, never by id. A run_id is a string and comes only from a tape-get-runs row — pass it back exactly as you received it. Sending an automation_id instead does not reliably fail: runs and automations are counted by separate sequences, so the same number is routinely valid for both, and an unrelated run's log can come back with no error at all.

Note: To diagnose a failure, find the log entry whose status is failure and read its messages. That names the step that broke, which the run's own error_message usually does not.

Note: The action_id on a log entry points at a node in the automation's stored actions list, and those ids are re-minted whenever tape-update-automation replaces that list. An action_id from an older run may no longer match anything in the current definition, so check the entry's label as well before telling somebody which action failed.

Note: A refusal tells you nothing about the run. A run that never existed, one past the retention window, one deleted, one belonging to somebody else, and one in a workspace you do not administrate are all refused identically, so that run ids cannot be probed.

Example prompts:

  • "Why did this automation run fail?"
  • "What exactly did the automation do on this record?"

Create an automation​

tape-create-automation

Creates an automation in an app. It is created paused and does not run until somebody activates it with tape-update-automation.

Note: Read tape://docs/automation-schema before composing trigger, filter or actions.

Note: broken is always false in the response and is not a verdict on what you just wrote. Tape computes validity when you activate, and refuses activation if the definition is invalid. That refusal is the real check.

Note: Nothing on this surface deletes an automation. A wrong create leaves a paused automation for a person to remove in Tape, so prefer correcting one over creating a second.

Example prompts:

  • "Create an automation that sets the status to Overdue when the due date passes"
  • "Draft an automation that posts a comment whenever a deal is won"

Change, activate or pause an automation​

tape-update-automation

Changes an automation's name, description, trigger, filter or actions, and activates or pauses it. Send only what you mean to change.

Note: Activating is a real-world event. is_paused: false makes the automation run against live data from that moment, sending email, calling external systems, and changing or deleting records according to its actions. Show a person what it does before activating it.

Note: null clears description, trigger and filter, unlike some other update tools — but not name, which rejects it. null on a filter is the dangerous one: an automation with no filter acts on every trigger event, which is wider than before, not narrower. actions replaces and does not merge, and sending [] leaves the automation broken.

Example prompts:

  • "Pause the invoice reminder automation"
  • "Activate the automation I just created"
  • "Change this automation to fire on Won instead of Qualified"

Run an automation once​

tape-run-automation

Runs one automation immediately, with real effects. This is the only tool whose effects leave Tape, and it is annotated openWorldHint: true for exactly that reason.

Note: This executes a program somebody else wrote, and its effects are not limited to Tape. Its actions can send email to real people, call external systems, and create, change or delete records. None of that is visible from this tool's arguments. Read the automation first with tape-fetch and type: "automation" and say what it does. There is no undo.

Note: Success means "accepted", never "it ran". There is no run id in the response, deliberately, and the automation's own filter still applies: a record that does not match produces no run at all and this call still succeeds. Poll tape-get-runs for what actually happened.

Note: A paused automation can still be run this way. Pausing stops its trigger; it does not disable manual runs.

Example prompts:

  • "Run the monthly report automation now"
  • "Trigger the welcome sequence for this new contact"

Rate limits​

MCP tool calls draw on the same per-user budget as the rest of the Tape API: 2,000 credits per minute, shared across your user API key and every personal access token you own. Connecting another client does not buy extra throughput. See Request limits.

The base request cost is 10 credits, which would be 200 calls per minute — but several routes charge a multiple of it, so treat 200 as a ceiling rather than an expectation. A search costs 50 credits (5× base), and so does each further page of results, which works out to roughly 40 searches per minute. Reading one view with tape-fetch costs 20. A single tool call can also bill more than one route: tape-fetch with type: "app" or type: "workspace" makes two. Where an endpoint charges above base, its API resource page says so. Every response carries X-Retry-Remaining and X-Retry-Reset.

A refused call still costs credits, because capability checks run after rate limiting. Retrying a call your token cannot make will exhaust the budget without ever succeeding.

If you are rate limited: ask the assistant to work in smaller batches and to stop searching in parallel. Prefer one tape-query-records call with a filter over many tape-fetch calls in a loop, and prefer tape-get-apps (with tape-list-shared-records) over repeated searches when you need the complete picture.

Next steps​