The Complete Guide to OpenClaw Official Feishu Plugin: Integrate AI Seamlessly into Your Workflow

Core question this section answers: Why do you need the official Feishu plugin, and how is it different from the previous community version?
One‑sentence answer: The official Feishu plugin operates as you—it can directly read and write Feishu documents, messages, and calendars on your behalf, eliminating endless copy‑pasting and making your AI a true “digital colleague” inside Feishu.

You may have already connected OpenClaw (nicknamed “crayfish”) to Feishu. It helps you draft reports, research information, and propose solutions. But soon you hit an awkward bottleneck: it always replies, “I don’t have access to Feishu documents/messages/calendars—please send me the content.” You end up copying documents, pasting chat logs—the tool meant to save time actually adds extra steps.

On March 6, 2026, Feishu officially launched the OpenClaw Official Plugin. This upgrade fundamentally changes the interaction model: once you authorize it, OpenClaw can directly access your documents, search for information, check your calendar availability, and understand group chat context—all with your identity. You say one sentence, and it reaches out with its “claw” to get the job done right inside Feishu.

The image below highlights the key differences between the official plugin and the community edition:

---

1. Core Capabilities: What Can You Do with a Single Sentence?

Core question this section answers: After installing the plugin, what Feishu tasks can OpenClaw actually handle for me?

The official plugin grants OpenClaw full “user‑perspective” operational abilities, summarized in the table below:

Capability Area	Specific Tasks	One‑Sentence Example
Message Handling	Read group/private chats, forward merged messages, react with emojis	“Summarize the key points from today’s unread messages in the product group.”
Document Operations	Read/write documents, download attachments, copy/create docs	“Find last week’s requirements document and extract the user stories.”
Calendar Management	View schedules, create/update events, check free/busy time	“See if I’m free tomorrow at 3 PM and schedule a meeting.”
Multidimensional Tables	Query/create/update records	“Add a new record to the product requirements table.”
Task Collaboration	Read/create tasks, manage task lists	“Remind me to finish the performance test report by next Wednesday.”

Beyond these operations, the plugin supports more natural interactions: streaming card replies, recognising merged forward messages, sending emojis, etc. These details make the conversation experience feel closer to human collaboration.

---

2. Preparation: What You Need Before You Start

Core question this section answers: What prerequisites must be met to install the official Feishu plugin?

Before diving into configuration, ensure you have the following:

• OpenClaw already installed, with a version that meets the requirements:

  • Linux/macOS: openclaw 2026.2.26 or higher
  • Windows: openclaw 2026.3.2 or higher (some Windows versions still have compatibility issues; Linux/macOS is recommended)
  • Check your version: openclaw -v
  • Upgrade command: npm install -g openclaw

• Permission to access the Feishu admin console (to create a custom app).

• A computer where you can run command‑line tools (for executing installation and pairing commands).

Author’s reflection: The first time I installed, I skipped the version check and spent hours troubleshooting until I realised the version was too low for event subscriptions. Version matching is the first line of defence for a smooth installation—always run openclaw -v before you begin.

---

3. Step‑by‑Step Installation (with Screenshots)

Core question this section answers: How do I install and configure the Feishu official plugin from scratch?

The whole installation process is divided into four phases:
Create a Feishu bot → Install the plugin → Subscribe to events → Pair and authorise.

Each step below includes key screenshots and important notes.

3.1 Create a Feishu Bot and Import Permissions

3.1.1 Create an enterprise self‑built app

Log in to the Feishu Developer Console and click “Create Enterprise Self‑built App”.

Enter the app name, description, and icon (you can use the default), then click “Create”.

3.1.2 Enable the bot capability

In the left menu, go to “App Capabilities → Add App Capabilities”. Switch to the “Add by Capability” tab and click “Add” on the Bot card.

3.1.3 Bulk‑import permissions

This is the most critical step. The permission list determines what OpenClaw can do with your identity. If permissions are incomplete, you may be repeatedly prompted for authorisation later, or some features may simply not work.

Navigate to “Development Config → Permission Management” and click “Bulk Import/Export Permissions”.

Copy the complete permission JSON below, replace the existing example, and click “Next, Confirm New Permissions”.

{
  "scopes": {
    "tenant": [
      "contact:contact.base:readonly",
      "docx:document:readonly",
      "im:chat:read",
      "im:chat:update",
      "im:message.group_at_msg:readonly",
      "im:message.p2p_msg:readonly",
      "im:message.pins:read",
      "im:message.pins:write_only",
      "im:message.reactions:read",
      "im:message.reactions:write_only",
      "im:message:readonly",
      "im:message:recall",
      "im:message:send_as_bot",
      "im:message:send_multi_users",
      "im:message:send_sys_msg",
      "im:message:update",
      "im:resource",
      "application:application:self_manage",
      "cardkit:card:write",
      "cardkit:card:read"
    ],
    "user": [
      "contact:user.employee_id:readonly",
      "offline_access",
      "base:app:copy",
      "base:field:create",
      "base:field:delete",
      "base:field:read",
      "base:field:update",
      "base:record:create",
      "base:record:delete",
      "base:record:retrieve",
      "base:record:update",
      "base:table:create",
      "base:table:delete",
      "base:table:read",
      "base:table:update",
      "base:view:read",
      "base:view:write_only",
      "base:app:create",
      "base:app:update",
      "base:app:read",
      "board:whiteboard:node:create",
      "board:whiteboard:node:read",
      "calendar:calendar:read",
      "calendar:calendar.event:create",
      "calendar:calendar.event:delete",
      "calendar:calendar.event:read",
      "calendar:calendar.event:reply",
      "calendar:calendar.event:update",
      "calendar:calendar.free_busy:read",
      "contact:contact.base:readonly",
      "contact:user.base:readonly",
      "contact:user:search",
      "docs:document.comment:create",
      "docs:document.comment:read",
      "docs:document.comment:update",
      "docs:document.media:download",
      "docs:document:copy",
      "docx:document:create",
      "docx:document:readonly",
      "docx:document:write_only",
      "drive:drive.metadata:readonly",
      "drive:file:download",
      "drive:file:upload",
      "im:chat.members:read",
      "im:chat:read",
      "im:message",
      "im:message.group_msg:get_as_user",
      "im:message.p2p_msg:get_as_user",
      "im:message:readonly",
      "search:docs:read",
      "search:message",
      "space:document:delete",
      "space:document:move",
      "space:document:retrieve",
      "task:comment:read",
      "task:comment:write",
      "task:task:read",
      "task:task:write",
      "task:task:writeonly",
      "task:tasklist:read",
      "task:tasklist:write",
      "wiki:node:copy",
      "wiki:node:create",
      "wiki:node:move",
      "wiki:node:read",
      "wiki:node:retrieve",
      "wiki:space:read",
      "wiki:space:retrieve",
      "wiki:space:write_only"
    ]
  }
}

After confirming the permissions are correct, click “Apply for Activation”.

3.1.4 Publish an app version

Return to the app management page and click the “Create Version” button at the top.

Fill in the version number, update description, etc. (you can use something simple like “v1.0.0”).

After saving, click “Confirm Publish” in the top‑right corner. Wait for Feishu’s review (usually auto‑approved within minutes).

3.1.5 Obtain App ID and App Secret

After publishing, go to “Basic Info → Credentials & Basic Info” on the left. In the “App Credentials” section, note down the App ID and App Secret. You will need them shortly when installing the plugin.

3.2 Install the Feishu Plugin into OpenClaw

If you have previously installed another Feishu plugin, installing the new one will automatically disable the old plugin—no manual intervention is needed.

Open a terminal (on Mac/Linux, use the built‑in Terminal; on Windows, PowerShell or WSL is recommended) and run the following commands:

# Set npm registry (optional, can speed up downloads in some regions)
npm config set registry https://registry.npmjs.org

# Install the official Feishu plugin
npm install -g @openclaw/plugin-feishu

During installation, the script will ask whether you want to keep an existing Feishu app or create/associate a new one. Since this is a fresh setup, choose “Create or associate a new app” and enter the App ID and App Secret you saved earlier.

After installation, start the OpenClaw gateway so the plugin can begin listening for Feishu events:

openclaw gateway run

If you see log output similar to the image below, the listener has started successfully:

Verify plugin status: Open another terminal window and run:

openclaw plugins list

Check that feishu-openclaw-plugin appears with status loaded, and the old feishu plugin (if present) shows disabled. This confirms the new plugin is active.

3.3 Configure Event Subscription and Card Callbacks

For OpenClaw to receive your messages and react to card button clicks in Feishu, you must set the event subscription method to long‑connection.

3.3.1 Set up event subscription

Back in the Feishu Developer Console, go to your app’s details and select “Event Subscription” on the left. Change the “Subscription Method” to Long Connection.

Then add the following events (it’s best to add all of them):

• Message received (im.message.receive_v1)
• Message reaction added (im.message.reaction.created_v1)
• Message reaction removed (im.message.reaction.deleted_v1)

3.3.2 Configure card callbacks

To enable OpenClaw to respond when you click buttons on cards, go to “Callback Configuration” on the left, change the method to Long Connection, and add the callback (simply click “Add”).

After configuration, publish the app version again (repeat step 3.1.4) to make the changes take effect.

3.4 Pair and Authorise: Let OpenClaw Act as You

The final step is to bind OpenClaw to your Feishu account and grant it permission to act on your behalf.

1. In Feishu, send any message (e.g., “Hello”) to the bot you just created.
2. The bot will reply with a message containing a pairing code (a combination of letters and numbers, valid for 5 minutes).
3. In your server terminal, execute the following command (replace <pairing_code> with the actual code):

openclaw pairing approve feishu <pairing_code> --notify

If successful, the bot will send you a confirmation message along with an authorisation link.

4. Click the link (or open it in a browser) to complete the user authorisation. This step is crucial—only after authorisation can OpenClaw read your private documents, calendar, etc.

If you prefer to postpone authorisation, you can start a conversation now and later trigger bulk authorisation by sending /feishu auth to the bot.

Verify successful installation

Chat with the bot and send: /feishu start
If it returns the plugin version information, installation is complete.

Finally, to help OpenClaw understand the new plugin’s capabilities, send:
“Learn about the new Feishu plugin I just installed and list its abilities.” It will automatically load the feature list.

---

4. Real‑World Scenarios: Three Typical Ways to Let Your AI Run Errands

Core question this section answers: What practical tasks can I accomplish with OpenClaw after installing the plugin?

To give you a concrete sense of the plugin’s value, here are three everyday scenarios.

Scenario 1: Automatic Meeting Minutes

Pain point: After every meeting, you manually sift through chat logs and compile to‑dos.
New way: In the group chat, @OpenClaw: “Summarise the key discussion points from today’s product requirements review and list the action items.”
OpenClaw reads the group messages (including files and links), automatically generates structured meeting minutes, and can even create to‑do items directly in your task list.

Scenario 2: Fast Document Search and Summarisation

Pain point: Documents are scattered across knowledge bases; finding an old proposal takes ages.
New way: In a private chat with OpenClaw: “Find the technical proposal about performance optimisation from last December and extract the core conclusions.”
OpenClaw searches all documents you have access to (via Feishu’s search API), reads the content, and returns a concise summary.

Scenario 3: Automatic Schedule Coordination

Pain point: Scheduling meetings involves back‑and‑forth checking of everyone’s availability.
New way: In a group, @OpenClaw: “Are Manager Wang from Marketing and I both free tomorrow 2–4 PM? If so, create a meeting and invite him and Director Li.”
OpenClaw checks both your calendar and Manager Wang’s (if permissions allow), creates the event if free, or suggests alternative slots if conflicts exist.

Author’s reflection: These scenarios sound great in theory, but in practice, the precision of the permission scope affects the experience. In scenario 3, if OpenClaw lacks permission to read the other person’s calendar (which requires either that person’s authorisation or tenant‑level permissions), it can’t detect conflicts. Therefore, when using it within a team, consider having everyone authorise the same app, or use tenant‑level permissions where possible.

---

5. Daily Maintenance and Troubleshooting

Core question this section answers: How do I update the plugin and quickly fix errors when they occur?

5.1 Updating the Plugin

The official plugin receives continuous improvements, so periodic updates are recommended. Run:

feishu-plugin-onboard update

If the system reports that the command is not found, the helper script may not be installed. Install it manually:

Linux/macOS:

npm config set registry https://registry.npmjs.org
curl -o /tmp/feishu-openclaw-plugin-onboard-cli.tgz https://registry.npmjs.org/@openclaw/plugin-feishu-onboard/-/plugin-feishu-onboard-<latest_version>.tgz
npm install /tmp/feishu-openclaw-plugin-onboard-cli.tgz -g
rm /tmp/feishu-openclaw-plugin-onboard-cli.tgz

(Replace <latest_version> with the actual version number, or use the generic URL above—the exact version may be obtained from the npm registry.)

Windows (CMD):

npm config set registry https://registry.npmjs.org
curl -o "%TEMP%\feishu.tgz" https://registry.npmjs.org/@openclaw/plugin-feishu-onboard/-/plugin-feishu-onboard-<latest_version>.tgz
npm install -g "%TEMP%\feishu.tgz"
del "%TEMP%\feishu.tgz"

5.2 Common Diagnostic Commands

OpenClaw includes several built‑in diagnostic commands to help you quickly pinpoint issues:

Command	Purpose
/feishu start	Confirm whether the plugin is installed correctly.
/feishu doctor	Check configuration and output a diagnostic report.
/feishu auth	Bulk‑complete user authorisation (if skipped earlier).
feishu-plugin-onboard doctor	View more detailed system‑level issues in the terminal.
feishu-plugin-onboard doctor --fix	Attempt to automatically fix common configuration problems.
feishu-plugin-onboard info --all	Show complete version and configuration info (include this when reporting issues).

For example, running feishu-plugin-onboard doctor produces diagnostic output similar to the screenshot below, pointing out missing permissions or misconfigurations:

If automatic fixing fails, capture the diagnostic information and share it in the official support group for assistance.

---

6. Author’s Reflection: Why This Upgrade Is a Watershed

From the community edition to the official plugin, the biggest change is not the technology stack but a shift in interaction philosophy.

Previously, AI was an “add‑on”—you had to feed it information before it could work. Now, AI is embedded—it proactively retrieves information; you only give instructions. This relies on Feishu’s Open Platform’s robust support for user‑identity authorisation. OpenClaw no longer exists as a static bot identity; it can represent you and do what you can do.

But this also introduces new considerations:

• Security boundaries: The plugin requires “acting as the user,” meaning once authorised, it can access all data within your permission scope. Therefore, the official recommendation is not to deploy such a bot as a group bot for multiple users, because that would confuse the authorisation subject. It is better suited as a personal assistant or for scenarios where a single administrator authorises it for specific use cases.
• Permission management overhead: The imported permission list is extensive, covering almost all core Feishu functions. While a one‑time authorisation provides a smooth experience, it also requires administrators or users to understand the purpose of each permission and avoid over‑granting. Fortunately, Feishu supports granular revocation—you can always review and cancel certain permissions in your account security settings.

Lesson learned: During configuration, many people overlook card callback configuration, leading to no response when clicking buttons. As long as you follow the steps in this guide and ensure both long‑connection and callbacks are correctly set, you can avoid this pitfall.

---

7. One‑Page Quick Checklist: Installation and Operation Summary

For fast implementation, here is a condensed checklist:

• [ ] Check OpenClaw version: openclaw -v; upgrade if necessary.
• [ ] Create Feishu app: In the developer console, create an enterprise self‑built app and enable bot capability.
• [ ] Bulk‑import permissions: Use the complete JSON provided in this guide.
• [ ] Publish app version: Save, publish, and obtain App ID and App Secret.
• [ ] Install plugin: npm install -g @openclaw/plugin-feishu, then enter App ID/Secret.
• [ ] Start gateway: openclaw gateway run (keep it running).
• [ ] Configure event subscription: Switch to long connection, add message and reaction events.
• [ ] Configure card callbacks: Switch to long connection, add callback.
• [ ] Publish app again (to apply event config).
• [ ] Pair and authorise: Send a message to the bot, get pairing code, run openclaw pairing approve, complete web authorisation.
• [ ] Verify: Send /feishu start and ask the AI to learn the new plugin’s abilities.

---

8. Frequently Asked Questions (FAQ)

1. Will the new plugin conflict with my old Feishu plugin?

No. Installing the official plugin automatically disables the old one (its status becomes disabled). Both can coexist, but only the new plugin will be active.

2. Why can’t my AI read my documents/calendar?

Usually because user authorisation hasn’t been completed. Check whether you clicked the authorisation link after pairing, or manually send /feishu auth to trigger bulk authorisation. Also ensure the app has the required permissions (the JSON includes all necessary user scopes).

3. Is this plugin suitable for group chats with multiple users?

The official recommendation is not suitable for now. Because the plugin acts under a single user’s identity, placing it in a group would mean all messages use that one identity, potentially causing permission confusion or data leakage. It is better as a personal assistant or for admin‑only scenarios.

4. How do I update the plugin to the latest version?

Run feishu-plugin-onboard update. If the command isn’t found, manually install the helper script as described in section 5.1.

5. Can I close the terminal after running openclaw gateway run?

No. This process must remain running to listen for Feishu events. Use a process manager (like pm2 or screen) or set it up as a background service.

6. How long is the pairing code valid, and what if it expires?

The pairing code is valid for 5 minutes. If it expires, simply send another message to the bot to get a new code.

7. What should I do if I see “insufficient permissions” during installation?

Make sure your Feishu account has administrator privileges (at least admin for the self‑built app). Some permission requests require admin approval.

8. How can I confirm that event listening is working?

Check the terminal where gateway run is running. If you see logs indicating “event listener started” and the bot responds to your messages, everything is working.

---

This guide is based on the official Feishu OpenClaw plugin documentation and aims to provide a directly actionable walkthrough. If you encounter issues not covered here, feel free to seek help in the community, or simply send /feishu doctor to your bot for diagnostic assistance. Give your AI those “claws,” and your Feishu workflow will truly enter the era of intelligent automation.