Liveblocks MCP. Control real-time state and collaboration data.
Liveblocks MCP connects your AI agent to real-time collaboration infrastructure. Manage collaborative spaces, authorize user permissions, track shared document state (Yjs), and resolve comment threads directly from your client. Use this to build complex multiplayer features without leaving your IDE.
Claude 
ChatGPT 
Cursor 
Gemini 
Windsurf 
VS Code 
JetBrains 
Vercel Give Claude and any AI agent real-world access
Create, read, update, or delete entire collaboration rooms.
Obtain tokens to authorize users and identify them within a room for proper permissions.
Inspect, patch, or update the raw JSON data of collaborative documents (Yjs).
Create new conversation threads and query existing comment history within a room.
Get lists of active users in a room or push custom data broadcasts to all connected clients.
Ask an AI about this
Waiting for input…
What AI agents can do with Liveblocks: 18 Tools for Collaborative Systems
These tools give your agent granular control over every aspect of a collaborative space, from user authentication to shared document patching.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Liveblocks MCPAuthorize User
Generates an access token, allowing a client to join a specific room.
Broadcast Event
Sends a JSON event to all users currently connected in the specified room.
Create Room
Sets up an entirely new collaborative space with a unique ID.
Create Thread
Starts a new discussion thread and writes the first comment automatically.
Delete Room
Permanently removes an existing collaboration room.
Get Room
Retrieves all metadata and details for a specified room.
Get Storage
Reads the entire current state tree of the room's shared data storage.
Get Thread
Pulls up all comments and details for a specific discussion thread.
Get Ydoc
Outputs the collaborative document's current state as a JSON object representation...
Identify User
Obtains an ID token for a specific client, managing user permissions on the backend.
Initialize Storage
Sets up or resets the room's collaborative storage state.
List Active Users
Retrieves a list of all user IDs currently connected and active in a specific room.
List Rooms
Lists all available rooms, with options to filter by metadata or access level.
List Threads
Fetches a list of every discussion thread that exists within a room.
Patch Storage
Applies precise JSON Patch operations to modify the room's storage state.
Resolve Thread
Marks a discussion thread as resolved, closing it out for future reference.
Update Room
Modifies the properties of an existing room, such as its name or description.
Update Ydoc
Sends a binary update to synchronize the shared Yjs document state across clients.
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Claude AI
Open Claude Settings
Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.
Add Custom Connector
Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:
https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp
Replace [YOUR_TOKEN_HERE] with your token
from cloud.vinkius.com. For OAuth-protected servers, expand
Advanced settings to add credentials.
Start a conversation
Open a new chat. The Liveblocks integration is available immediately — no restart needed.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on each call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Liveblocks, then connect any of our 5,200+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,200+ others, all in one place
- Add new capabilities to your AI anytime you want
- Connections are secured and governed automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog weekly
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Liveblocks. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS CLOUD
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on each call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Managing real-time collaboration state used to feel like an entire backend job.
Today, building something that handles multiple users collaborating on the same document—like a shared whiteboard or a group planning session—means dealing with layers of complexity. You have to manage user tokens, track who is online, and implement custom logic just to sync every keystroke across different clients, all while worrying about data corruption.
With this MCP, you stop writing that boilerplate code. Instead, your agent handles the entire infrastructure layer. You simply ask it to 'get the current state' or 'update the shared document.' The complexity of real-time synchronization disappears; you just get clean, actionable data.
Control the collaborative room lifecycle with Liveblocks MCP.
Manually managing rooms means writing separate functions for listing spaces, creating them when needed, and cleaning up old or abandoned environments. It's tedious, error-prone code that slows down development velocity.
Now you can use `list_rooms` to see all available collaboration areas and `create_room` instantly programmatically. You treat the entire room lifecycle—from inception to deletion—as a single conversational task.
What Liveblocks MCP does for your AI
This connector lets you control the hardest part of modern web apps: real-time state. Instead of building out a clunky backend just to handle user presence or shared document editing, you can orchestrate those experiences using natural language prompts through your AI client. Your agent handles room lifecycle—creating spaces, managing who gets in, and deleting them when they're done.
You can read the current status of collaborative storage or patch it directly via commands. It also keeps track of conversations within a space, letting you query comment threads to see what was decided days ago. When working with complex real-time systems, having all this functionality centralized is huge. With Vinkius hosting this MCP, you connect once and get access to powerful tools for handling everything from user authentication to broadcasting custom events across any compatible client.
019e38b9-385c-737c-ae0f-89e2c1671ed1 
How to set up Liveblocks MCP
The bottom line is that your agent treats complex real-time infrastructure like a simple set of commands you can type into conversation.
Subscribe to this MCP using your Vinkius credentials.
Input your Liveblocks Secret Key into the connection settings.
Tell your AI client what you need to do, like 'List all active users in the main editor room,' and it executes the command.
Who uses Liveblocks MCP
This MCP is for full-stack developers building anything multi-user. If your job requires managing shared state, user permissions, or live collaboration features, this saves days of backend boilerplate.
Needs to quickly debug a room's storage structure or programmatically manage access tokens without writing dedicated microservices.
Must automate the provisioning of collaborative environments and enforce complex user access rules across multiple project rooms.
Needs a simple way to monitor which collaboration sessions are active or review historical comment threads before committing to a feature build.
Benefits of connecting Liveblocks MCP
Debug complex storage issues instantly. Instead of manually connecting to a database, use get_storage or patch_storage to inspect and modify the room's shared state directly through your agent.
Manage user entry points without writing auth middleware. Use authorize_user and identify_user to ensure only authorized clients can enter specific collaboration rooms.
Keep track of project decisions efficiently. You can use create_thread, list_threads, or resolve_thread to manage the history of discussions, keeping context organized within a room.
Monitor who is working right now. The list_active_users tool gives you an immediate list of all users connected to a given room, useful for status checks or presence systems.
Control the entire lifecycle of collaborative spaces. Use create_room, update_room, and delete_room to provision and decommission collaboration environments programmatically.
Liveblocks MCP use cases
The onboarding team needs to check permissions for a new project room.
A dev asks their agent: 'List all rooms associated with the marketing department, then authorize user X and get the full metadata.' The agent uses list_rooms first, identifies the correct space, runs authorize_user, and confirms access rights using get_room.
A shared document needs a state correction.
The PM notices some data is corrupted. They ask their agent to 'Inspect and fix the main editor's storage.' The agent runs get_storage, identifies the faulty tree, and then uses patch_storage to apply the necessary JSON fix.
Tracking a complex feature discussion.
A developer needs to know what was decided last week. They ask their agent: 'Check out the thread for the payment gateway design.' The agent uses get_thread and then runs resolve_thread after confirming the final decision.
Multiplayer game session setup.
A developer needs to set up a new private gaming room. They prompt: 'Create a new room called 'Alpha Test' and broadcast an event saying it's open.' The agent uses create_room followed by broadcast_event.
Liveblocks MCP tradeoffs
What to watch out for, and the recommended way to handle each one.
Using simple CRUD for state changes
Trying to manage shared data using only basic 'update' functions, resulting in lost context and corrupted document history.
Don't just update the whole room. Use patch_storage to apply precise JSON Patch operations, or use get_ydoc followed by update_ydoc for binary synchronization.
Manual user permission checks
Writing custom code every time a new user needs access to a room, leading to brittle and redundant authorization logic.
Let the agent handle this. Use identify_user first, then use authorize_user to issue the necessary token for immediate access.
Forgetting historical context
Starting a new discussion without linking it to past decisions, forcing teammates to search through old emails or documents.
Use create_thread and get_thread together. This keeps the conversation history linked directly within the collaboration room itself.
When to use Liveblocks MCP
Use this MCP if your application's core functionality revolves around multiple users interacting with a single, evolving piece of data—think shared whiteboards, live document co-editing, or complex gaming lobbies. You need mechanisms for real-time presence (list_active_users), state synchronization (patch_storage), and structured communication history (get_thread). Don't use this if you just need simple database record keeping; general CRUD tools work fine then. If your application is single-user, or only handles asynchronous messaging without shared document states, this connector is overkill. This MCP solves the problem of 'state persistence in a group context,' making it essential for any truly collaborative tool.
Frequently asked questions about Liveblocks MCP
How do I manage user access using Liveblocks MCP? +
You use identify_user to get an ID token for the client, and then you run authorize_user with that token. This sequence ensures the user has explicit permission to enter the room.
Can I read the full shared document history with Liveblocks MCP? +
Yes. You can use get_ydoc to get a JSON representation of the current state, or you can use get_storage for more detailed tree information.
What is the difference between listing rooms and getting room details with Liveblocks MCP? +
Listing rooms (list_rooms) gives you a directory of available spaces. Getting room details (get_room) fetches all the specific metadata for one, already identified, space.
How do I prevent users from entering a room without permission? +
You must first use identify_user to get their ID token. Then, you invoke authorize_user using that token and specify the desired permissions for access.
Can Liveblocks MCP handle simple messages in a room? +
While it doesn't send plain text messages directly, it handles structured discussions. You can use create_thread to start a discussion or broadcast_event for custom system alerts.