Fibery

Delete a webhook via DELETE /api/webhooks/v2/{webhook_id}. Delete one webhook subscription by its id. Deliveries to its URL stop and there is no undo -- recreating it needs the database name and the destination URL, which this call does not return, so list the webhooks and keep the values before deleting. It affects the whole workspace, not only this connection: whoever created that webhook loses it too. Changes shared workspace state: it takes effect for every member of the Fibery workspace, not only for this connection. UNKNOWN KEYS ARE SILENTLY DROPPED, so a misspelled option returns the UNFILTERED result and reports success -- measured: an invented query parameter or an invented key inside the request body gives a reply byte-identical to sending nothing at all. Use only the fields named above. A wrong VALUE for a field Fibery knows does fail loudly, and a wrong FIELD NAME comes back as an error that names the field you probably meant. Fibery rate-limits at 3 requests per second per token and 7 per second per workspace, both answered with HTTP 429.

Read a document via GET /api/documents/{secret}. Read one rich-text document by its secret. A Fibery rich-text field is a DOCUMENT, not a string: query the entity for the field's `Collaboration~Documents/secret` and pass that UUID here. `format` chooses the representation -- `md` (the default), `html`, `json` (Fibery's own document model) or `plain-text`; all four were measured and each returns a visibly different body, and a value outside the list answers HTTP 500 `UNKNOWN_FORMATTER` rather than quietly falling back. The reply is `{"secret", "content", "modificationDate"}`. A secret that does not exist is NOT an error: Fibery answers 200 with `content: ""` and a null modification date (measured 2026-09-16), so an empty document and a wrong secret look the same -- check the secret came from a real entity rather than inferring it from an empty reply. UNKNOWN KEYS ARE SILENTLY DROPPED, so a misspelled option returns the UNFILTERED result and reports success -- measured: an invented query parameter or an invented key inside the request body gives a reply byte-identical to sending nothing at all. Use only the fields named above. A wrong VALUE for a field Fibery knows does fail loudly, and a wrong FIELD NAME comes back as an error that names the field you probably meant. Fibery rate-limits at 3 requests per second per token and 7 per second per workspace, both answered with HTTP 429.

List webhooks via GET /api/webhooks/v2. List the webhooks registered on this workspace, each with its id, the database it is subscribed to and the URL it delivers to. A workspace with none answers `[]` (measured 2026-09-16). This is the call to make before creating or deleting one: the delete takes a webhook id, and this is where an id comes from. UNKNOWN KEYS ARE SILENTLY DROPPED, so a misspelled option returns the UNFILTERED result and reports success -- measured: an invented query parameter or an invented key inside the request body gives a reply byte-identical to sending nothing at all. Use only the fields named above. A wrong VALUE for a field Fibery knows does fail loudly, and a wrong FIELD NAME comes back as an error that names the field you probably meant. Fibery rate-limits at 3 requests per second per token and 7 per second per workspace, both answered with HTTP 429.

Query entities via POST /api/commands. Read entities out of a Fibery database with the `fibery.entity/query` command. `q/from` is the database in `space/name` form and CASE MATTERS (`Project Tracking/Task`, `fibery/user`); `q/select` is the list of fields to return, which may nest an entity field's own fields or aggregate a collection; `q/where` is a filter expression written as an array whose parameters are supplied separately in `args.params` as `{"$name": value}`; `q/limit` is required and a bounded value (1000 or less) is recommended over the supported-but-discouraged `q/no-limit`. Page with `q/offset`, or by filtering on the last id you saw. The reply is Fibery's envelope, `{"success": true, "result": [...]}` -- and READ `success`, NOT THE HTTP STATUS: a command that failed still answers HTTP 200, with `success: false` and an error object naming a stable `name` code (measured: a `q/select` naming a field the database does not have answers 200 / `entity.error/schema-field-not-found`, and helpfully names the field you probably meant). The filters really do filter -- measured on a 7-row database: an impossible `q/where` returned 0, `q/limit 2` returned 2, `q/offset 5` returned 2, `q/offset 999` returned 0, and `q/order-by` asc and desc returned opposite orders. Call this tool once to learn the schema is not possible: field and database names come from the workspace's own schema, so an unfamiliar workspace usually needs a `fibery.schema/query` first -- which this tool cannot send. `command` is always `fibery.entity/query`. PINNED TO ONE COMMAND. This endpoint is a single URL behind Fibery's whole command vocabulary, and this tool is the one command named above and nothing else -- Agentic Fabriq fills that field in when it is omitted and REFUSES a body naming a different command, so the tool cannot be steered into a write or a delete it was not catalogued as. UNKNOWN KEYS ARE SILENTLY DROPPED, so a misspelled option returns the UNFILTERED result and reports success -- measured: an invented query parameter or an invented key inside the request body gives a reply byte-identical to sending nothing at all. Use only the fields named above. A wrong VALUE for a field Fibery knows does fail loudly, and a wrong FIELD NAME comes back as an error that names the field you probably meant. Fibery rate-limits at 3 requests per second per token and 7 per second per workspace, both answered with HTTP 429.

Read several documents via POST /api/documents/commands. Read several rich-text documents in one call with the `get-documents` command. `args` is an array of `{"secret": "<uuid>"}` entries and `format` chooses the representation for all of them (`md` by default, or `html`, `json`, `plain-text`). The reply is an array of the same document objects the single-document read returns, in the order asked for; an empty `args` gives `[]` (measured 2026-09-16). Prefer this over reading documents one at a time: Fibery rate-limits at 3 requests per second per token. `command` is always `get-documents`. PINNED TO ONE COMMAND. This endpoint is a single URL behind Fibery's whole command vocabulary, and this tool is the one command named above and nothing else -- Agentic Fabriq fills that field in when it is omitted and REFUSES a body naming a different command, so the tool cannot be steered into a write or a delete it was not catalogued as. UNKNOWN KEYS ARE SILENTLY DROPPED, so a misspelled option returns the UNFILTERED result and reports success -- measured: an invented query parameter or an invented key inside the request body gives a reply byte-identical to sending nothing at all. Use only the fields named above. A wrong VALUE for a field Fibery knows does fail loudly, and a wrong FIELD NAME comes back as an error that names the field you probably meant. Fibery rate-limits at 3 requests per second per token and 7 per second per workspace, both answered with HTTP 429.

Upload a file from a URL via POST /api/files/from-url. Have Fibery fetch a file from a URL you supply and store it as a Fibery file. `url` is required and is the source Fibery downloads from; `name` sets the stored file name, `method` the HTTP verb Fibery uses (GET by default), `headers` any headers the source needs, and `id` lets you choose the new file's UUID. The reply carries the file's secret, which is what every later reference to the file uses. FIBERY MAKES THIS REQUEST, NOT YOU, AND YOU CHOOSE ALL OF IT: the URL, the HTTP method and the headers are yours, and the request leaves FIBERY'S network rather than Agentic Fabriq's. So `method` can drive a verb other than GET at a host of your choosing -- use it only to fetch a file you mean to store, never to reach a host that is only reachable from inside somebody's network and never to cause a side effect somewhere else. Treat anything in `headers` as credential material: it is sent to that third party and it is recorded in this call's arguments in Agentic Fabriq's audit trail. Uploading bytes directly is not available through this integration -- Fibery's multipart upload and its file download are both withheld, because unbounded bytes cannot ride inside a tool argument or result. UNKNOWN KEYS ARE SILENTLY DROPPED, so a misspelled option returns the UNFILTERED result and reports success -- measured: an invented query parameter or an invented key inside the request body gives a reply byte-identical to sending nothing at all. Use only the fields named above. A wrong VALUE for a field Fibery knows does fail loudly, and a wrong FIELD NAME comes back as an error that names the field you probably meant. Fibery rate-limits at 3 requests per second per token and 7 per second per workspace, both answered with HTTP 429.

Sign file download URLs via POST /api/files/sign-urls. Turn file secrets into signed, time-limited download URLs. `secrets` is the required array of file secrets -- the values a file operation or an entity's file field gives you. The reply is `{"items": [...]}`, one entry per secret; an empty array in gives an empty array back (measured 2026-09-16). This is how a file leaves Fibery through this integration: the direct download endpoint is withheld because it returns raw bytes, so ask for a signed URL and hand that to whatever needs the file. UNKNOWN KEYS ARE SILENTLY DROPPED, so a misspelled option returns the UNFILTERED result and reports success -- measured: an invented query parameter or an invented key inside the request body gives a reply byte-identical to sending nothing at all. Use only the fields named above. A wrong VALUE for a field Fibery knows does fail loudly, and a wrong FIELD NAME comes back as an error that names the field you probably meant. Fibery rate-limits at 3 requests per second per token and 7 per second per workspace, both answered with HTTP 429.

Run a GraphQL query on a space via POST /api/graphql/space/{space}. Run a GraphQL query or mutation against ONE space's generated schema. `space` is the space name exactly as the workspace spells it, including spaces and `~` (`Project Tracking`, `Collaboration~Documents`); Agentic Fabriq URL-encodes it. `query` is the GraphQL document and `variables` its variables. Each space has its own endpoint and its own schema, generated from that space's databases, so a field that exists in one space does not exist in another -- run an introspection query first if you do not know the shape. THIS TOOL CAN WRITE: GraphQL mutations go through the same endpoint as queries and Agentic Fabriq cannot tell them apart, which is why it is catalogued as a write. UNKNOWN KEYS ARE SILENTLY DROPPED, so a misspelled option returns the UNFILTERED result and reports success -- measured: an invented query parameter or an invented key inside the request body gives a reply byte-identical to sending nothing at all. Use only the fields named above. A wrong VALUE for a field Fibery knows does fail loudly, and a wrong FIELD NAME comes back as an error that names the field you probably meant. Fibery rate-limits at 3 requests per second per token and 7 per second per workspace, both answered with HTTP 429.

Search entity history via POST /api/history/v2/search. Search the workspace's change history: who changed what, when. `limit` is required and is the page size; page on by passing the previous page's last item id as `sinceItem`. `timeframe` takes ISO-8601 UTC `start`/`end` and spans at most one year, defaulting to the last 30 days when omitted. `where` is an array of `{field, operator, value}` filters combined with AND -- `field` is one of id, action, entityPublicId, entityState, author, typeId, entityTypeId, entityName, entityId, field and `operator` one of =, in, empty, not-empty, contains, not-in; pass `[]` for no filters. `excludeAutomaticChanges` drops changes made by integrations, automations, auto-linking or formulas, which is usually what you want when looking for what a PERSON did. The reply is `{"items": [...]}`, each item carrying the action, the date, the entity and its database. UNKNOWN KEYS ARE SILENTLY DROPPED, so a misspelled option returns the UNFILTERED result and reports success -- measured: an invented query parameter or an invented key inside the request body gives a reply byte-identical to sending nothing at all. Use only the fields named above. A wrong VALUE for a field Fibery knows does fail loudly, and a wrong FIELD NAME comes back as an error that names the field you probably meant. Fibery rate-limits at 3 requests per second per token and 7 per second per workspace, both answered with HTTP 429.

Query views via POST /api/views/json-rpc. List the workspace's views with the `query-views` JSON-RPC method. `params.filter` narrows the result: `ids` and `publicIds` match views directly, `isPrivate` selects only views in My space (true) or only views outside it (false), and `container` returns the views attached to named entities of one database (`typeId` plus that database's entity `publicIds`). Omit the filter to get every view the token can see. This is JSON-RPC, so the reply is `{"jsonrpc", "result"}` -- and a bad method name comes back as a JSON-RPC error object with HTTP 400 rather than as a transport failure. `method` is always `query-views`. PINNED TO ONE COMMAND. This endpoint is a single URL behind Fibery's whole command vocabulary, and this tool is the one command named above and nothing else -- Agentic Fabriq fills that field in when it is omitted and REFUSES a body naming a different command, so the tool cannot be steered into a write or a delete it was not catalogued as. UNKNOWN KEYS ARE SILENTLY DROPPED, so a misspelled option returns the UNFILTERED result and reports success -- measured: an invented query parameter or an invented key inside the request body gives a reply byte-identical to sending nothing at all. Use only the fields named above. A wrong VALUE for a field Fibery knows does fail loudly, and a wrong FIELD NAME comes back as an error that names the field you probably meant. Fibery rate-limits at 3 requests per second per token and 7 per second per workspace, both answered with HTTP 429.

Create a webhook via POST /api/webhooks/v2. Subscribe a URL to changes in one Fibery database. `type` is the database in `space/name` form (`Cricket/Player`) and `url` is the destination Fibery POSTs the effect payload to. THE URL IS A WORKSPACE-WIDE SIDE CHANNEL: every change to that database is sent to it from then on, for every user of the workspace and not just this connection, until the webhook is deleted. Point it only at an endpoint you control and expect to keep; list the webhooks first to avoid creating a duplicate delivery. Changes shared workspace state: it takes effect for every member of the Fibery workspace, not only for this connection. UNKNOWN KEYS ARE SILENTLY DROPPED, so a misspelled option returns the UNFILTERED result and reports success -- measured: an invented query parameter or an invented key inside the request body gives a reply byte-identical to sending nothing at all. Use only the fields named above. A wrong VALUE for a field Fibery knows does fail loudly, and a wrong FIELD NAME comes back as an error that names the field you probably meant. Fibery rate-limits at 3 requests per second per token and 7 per second per workspace, both answered with HTTP 429.

Replace a document's content via PUT /api/documents/{secret}. REPLACE the whole content of one rich-text document. `secret` names the document, `content` is the new body in the format `format` names (`md` by default, or `html`/`json`), and the write is a replacement rather than an append -- whatever the document held is gone, including anything a person wrote between your read and your write. Read the document first, edit the text you got back, and send the whole result. Fibery gives this call no conditional-write or version check, so concurrent editors silently lose their changes. Changes shared workspace state: it takes effect for every member of the Fibery workspace, not only for this connection. UNKNOWN KEYS ARE SILENTLY DROPPED, so a misspelled option returns the UNFILTERED result and reports success -- measured: an invented query parameter or an invented key inside the request body gives a reply byte-identical to sending nothing at all. Use only the fields named above. A wrong VALUE for a field Fibery knows does fail loudly, and a wrong FIELD NAME comes back as an error that names the field you probably meant. Fibery rate-limits at 3 requests per second per token and 7 per second per workspace, both answered with HTTP 429.