Feishu Docs

Feishu Docs is the block-based document editor in Feishu, ByteDance's workplace suite. Agents create documents, read them as plain text or blocks, write generated reports with headings and lists intact, and convert Markdown or HTML into native Feishu documents.

14 actions OAuth available

Feishu Docs website Platform Documentation Capability data verified 2026-08-13

A change lands upstream that makes part of a standing runbook wrong

Get Document Text reads the whole runbook as plain text so the agent can reason about it

List Blocks finds the block that carries the outdated wording, with its ID, type and position

Agent drafts the replacement and confirms it changes only the section it was asked to change

Replace Block Text updates that block, leaving its type and everything around it untouched

Agent posts the before and after wording into the team's chat with a link to the document

When the fix means removing paragraphs rather than rewriting one, a person confirms exactly which blocks go before Delete Blocks runs

What This Integration Enables

Feishu Docs is the block editor inside Feishu, the workplace suite ByteDance operates for mainland China. If your team runs on Feishu, its documents are where policies, runbooks and weekly reports actually live, which makes them the natural target for an agent rather than a place to dump a summary. This connector treats the document as a structured object rather than a text box. Agents create a document, read it whole as plain text, walk it block by block, convert generated Markdown or HTML into native blocks, insert nested structures like a table with its cells already filled, replace the wording of one block without disturbing its type, and apply a set of changes as a single edit.

Two facts shape how flows should be built here. The app is a member of the workspace, not an administrator, so it only touches documents that have been shared with it, and a permission error on a document that plainly exists usually means exactly that. And there is no delete-document operation at all in this surface, deliberately, because a Feishu document is deleted through Drive as a file. What this connector can destroy is content inside a document people are reading, which is precisely where FlowRunner's human-in-the-loop design earns its place.

Without FlowRunner

Documents rot quietly The runbook says one thing, production does another, and nobody notices until an incident

Updating means opening the doc Every correction is a person finding the paragraph, editing it, and telling everyone

Generated output arrives as a wall of text Analysis pasted in loses its headings and lists, so people stop reading it

With FlowRunner

Documents track their source An upstream change starts the update instead of waiting for someone to remember

Edits are surgical The agent changes the block that is wrong and leaves the rest of the document alone

Generated content arrives structured Markdown becomes native blocks, so headings stay headings and tables stay tables

Use Case Scenarios

The runbook that updates itself when the system changes

A deployment or a configuration change closes in Jira. The agent calls Get Document Text on the operations runbook, works out which procedure the change invalidates, then calls List Blocks to locate the exact block carrying the stale step. It rewrites that block with Replace Block Text, so a numbered step stays a numbered step and the surrounding procedure is untouched. A short note goes to the team through Feishu Group Robot naming the section that changed and why. Nobody had to remember that the runbook existed.
A weekly report assembled where people already read

On a schedule, the agent gathers the week's numbers and writes its analysis as Markdown. Convert To Blocks turns that Markdown into Feishu blocks without writing anything anywhere, and Add Blocks inserts the result at the top of the standing report document, headings and lists intact. Where the report needs a table, Add Nested Blocks sends the table and its cells together, because a container and its contents have to arrive in one call. The document grows week by week and reads like somebody wrote it, which is the point.
The document as a source an agent can answer from

A question arrives in Zendesk about a policy the company documented months ago. The agent calls Get Document Text on the policy document, answers from what it actually says rather than from a stale copy of the text, and cites the section. When the answer reveals that the policy itself is ambiguous, the agent does not silently rewrite it. It drafts the clarification, posts it for review, and applies it with Update Blocks In Bulk once approved, so the whole clarification lands as one edit rather than as a series of half states colleagues can catch mid-change.

Human-in-Loop Highlight

Delete Blocks is the operation that makes this connector worth gating, because of how it addresses what it removes. It does not take block IDs. It removes a run of children from inside a parent by position, counting from zero, with the end position not itself removed. The connector refuses a range that would delete nothing or run backwards, but it cannot know whether positions 4 through 9 are the six obsolete steps you meant or the six paragraphs that follow them, and this surface has no undo and no delete-document call to fall back on. So when a cleanup pass decides that paragraphs should go rather than change, the agent stops. It lists what it read at each of those positions and asks: "Removing 4 blocks from the Escalation section: positions 3 to 6, currently reading 'Page the on-call SRE', 'Wait 15 minutes', 'Escalate to the platform lead', 'Open a Sev2'. Confirm this is the run to remove?" A person reads back the actual text and answers. The agent handles finding, drafting and rewriting at machine speed. Deciding which paragraphs stop existing is somebody's job.

Agent processes routinely

Detects exception requiring judgment

Clear match Continues automatically

Ambiguous Routes to human via preferred channel

Human decides

Agent resumes with decision

Agent Capabilities

14 actions

Documents

Create Document Creates an empty document, optionally titled and placed in a folder, and returns the document ID every other operation here takes. It starts with nothing in it, so content follows with Add Text or Add Blocks.
Get Document Reads a document's title and its current revision number. The revision is what the block operations use to confirm they are editing the version they think they are.
Get Document Text Reads the whole document as plain text with formatting stripped. This is the operation to use when an agent needs to read a document rather than change it.

Reading Structure

List Blocks Lists every block in a document, flat, in reading order, each with its ID, type and content. This is how a flow finds the block it wants to change.
Get Block Reads one block with its type and its content.
List Child Blocks Lists the blocks nested directly inside another block, such as the rows of a table or the items under a heading, and can optionally return everything beneath it rather than only the immediate children.

Writing Content

Convert To Blocks Turns Markdown or HTML into Feishu blocks without writing them anywhere. Feeding the result to Add Blocks is how generated content lands in a document with its headings, lists and formatting intact.
Add Text Adds lines of text to a document, each as its own block, so headings stay headings and list items stay list items. The straightforward way to write without building block objects by hand.
Add Blocks Adds ready-made block objects. Used with the output of Convert To Blocks, or for block types Add Text does not cover such as a table, an image or a callout.
Add Nested Blocks Adds blocks that contain other blocks in one call, such as a table with its cells filled in. Adding these one at a time does not work, because a container and its contents have to arrive together.

Editing and Removal

Replace Block Text Replaces the text of one block while leaving the block itself in place, so a heading stays a heading. The safest edit in this surface.
Update Block Applies a raw block update for the changes Replace Block Text does not cover: styling, table rows and columns, replacing an image or an attachment. Takes Feishu's own update request object.
Update Blocks In Bulk Applies several block updates in one call, which Feishu treats as a single edit. Used when a set of changes should land together rather than be visible half applied.
Delete Blocks Removes a run of blocks from inside a parent block by position rather than by ID, counting from zero, with the end position not removed. This is the operation the human gate on this page exists for.

Frequently Asked Questions

What can FlowRunner do with Feishu Docs?

FlowRunner agents can run Create Document, Get Document, and Get Document Text in Feishu Docs, plus 11 more actions.

Does connecting Feishu Docs to FlowRunner require OAuth?

Yes. Feishu Docs connects to FlowRunner with OAuth 2.0, so agents authenticate without handling raw credentials.

Can Feishu Docs trigger a FlowRunner workflow automatically?

Feishu Docs doesn't currently expose triggers in FlowRunner. It connects as an action step inside workflows started by another trigger.

Start building with Feishu Docs

Free plan, no card required. Connect in minutes.

Start Building Free Talk to us