Bruno MCP Server
Enables programmatic creation and management of Bruno API testing collections, environments, and requests, including generation of .bru files for HTTP methods, support for authentication methods, and addition of test scripts and assertions.
Provides code quality checking for the development of the Bruno MCP server.
Supports repository cloning as part of the installation process, enabling version control of Bruno API testing collections.
Enables installation, building, and running the MCP server through npm commands, with support for dependency management.
Offers code formatting capabilities for the development of the Bruno MCP server.
Supports building the Bruno MCP server project from TypeScript source code.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Bruno MCP Server create a collection for my e-commerce API tests"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Bruno MCP Server
A Model Context Protocol (MCP) server for generating Bruno API testing files programmatically.
Overview
Bruno MCP Server enables you to create, manage, and generate Bruno API testing collections, environments, and requests through standardized MCP tools. This allows for automated setup of API testing workflows and integration with Claude and other MCP-compatible clients.
Related MCP server: Bruno MCP
Features
📁 Collection Management: Create and organize Bruno collections
🌍 Environment Configuration: Manage multiple environments (dev, staging, prod)
🔧 Request Generation: Generate .bru files for all HTTP methods
🔐 Authentication Support: Bearer tokens, Basic auth, OAuth 2.0, API keys
📝 Test Scripts: Add pre/post request scripts and assertions
🔄 CRUD Operations: Generate complete CRUD request sets
📊 Collection Statistics: Analyze existing collections
Installation
# Clone the repository
git clone https://github.com/macarthy/bruno-mcp.git
cd bruno-mcp
# Install dependencies
npm install
# Build the project
npm run buildClient Integration
The Bruno MCP Server can be integrated with various AI clients that support the Model Context Protocol:
Quick Setup for Claude Desktop
Edit Claude Desktop config file:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%/Claude/claude_desktop_config.jsonLinux:
~/.config/Claude/claude_desktop_config.json
Add Bruno MCP Server:
{ "mcpServers": { "bruno-mcp": { "command": "node", "args": ["/absolute/path/to/bruno-mcp/dist/index.js"], "env": {} } } }Restart Claude Desktop
Supported Clients
✅ Claude Desktop App - Full support
✅ Claude Code (VS Code) - Full support
✅ Continue - Tools and resources
✅ Cline - Tools and resources
✅ LM Studio - Tools support
✅ MCP Inspector - Development/testing
✅ Custom MCP Clients - via SDK
📖 For detailed integration instructions with all clients, see INTEGRATION.md
Usage
With Claude Code or MCP Inspector
Start the MCP server:
npm startUse the MCP Inspector to test tools:
npx @modelcontextprotocol/inspectorAvailable MCP Tools
create_collection
Create a new Bruno collection with configuration.
Parameters:
name(string): Collection namedescription(string, optional): Collection descriptionbaseUrl(string, optional): Default base URLoutputPath(string): Directory to create collectionignore(array, optional): Files to ignore
Example:
{
"name": "my-api-tests",
"description": "API tests for my application",
"baseUrl": "https://api.example.com",
"outputPath": "./collections"
}create_environment
Create environment configuration files.
Parameters:
collectionPath(string): Path to Bruno collectionname(string): Environment namevariables(object): Environment variables
Example:
{
"collectionPath": "./collections/my-api-tests",
"name": "production",
"variables": {
"baseUrl": "https://api.example.com",
"apiKey": "prod-key-123",
"timeout": 30000
}
}create_request
Generate .bru request files.
Parameters:
collectionPath(string): Path to collectionname(string): Request namemethod(string): HTTP methodurl(string): Request URLheaders(object, optional): HTTP headersbody(object, optional): Request bodyauth(object, optional): Authentication configfolder(string, optional): Folder organization
Example:
{
"collectionPath": "./collections/my-api-tests",
"name": "Get User Profile",
"method": "GET",
"url": "{{baseUrl}}/users/{{userId}}",
"headers": {
"Authorization": "Bearer {{token}}"
},
"folder": "users"
}create_crud_requests
Generate complete CRUD operation sets.
Parameters:
collectionPath(string): Path to collectionentityName(string): Entity name (e.g., "Users")baseUrl(string): API base URLfolder(string, optional): Folder name
Example:
{
"collectionPath": "./collections/my-api-tests",
"entityName": "Products",
"baseUrl": "{{baseUrl}}/api/v1",
"folder": "products"
}add_test_script
Add test scripts to existing requests.
Parameters:
bruFilePath(string): Path to .bru filescriptType(string): Script type (pre-request, post-response, tests)script(string): JavaScript code
get_collection_stats
Get statistics about a collection.
Parameters:
collectionPath(string): Path to collection
Generated File Structure
my-collection/
├── bruno.json # Collection configuration
├── environments/ # Environment files
│ ├── development.bru
│ ├── staging.bru
│ └── production.bru
├── auth/ # Authentication requests
│ ├── login.bru
│ └── get-profile.bru
└── users/ # User management
├── get-all-users.bru
├── get-user-by-id.bru
├── create-user.bru
├── update-user.bru
└── delete-user.bruBruno BRU File Format
Generated .bru files follow the Bruno markup language specification:
meta {
name: Get Users
type: http
seq: 1
}
get {
url: {{baseUrl}}/users
body: none
auth: none
}
headers {
Content-Type: application/json
Authorization: Bearer {{token}}
}
script:pre-request {
bru.setVar("timestamp", Date.now());
}
script:post-response {
if (res.status === 200) {
bru.setVar("userId", res.body[0].id);
}
}
tests {
test("Status should be 200", function() {
expect(res.status).to.equal(200);
});
}Testing
Run Unit Tests
npm testRun Integration Tests
npm run test:integrationTest with Bruno CLI
# Generate a collection first
# Then run tests with Bruno CLI
bruno-cli run ./collections/my-api-tests/Examples
See the examples/ directory for complete usage examples:
examples/jsonplaceholder/- JSONPlaceholder API testingexamples/authentication/- Authentication workflowsexamples/complex-workflows/- Multi-step API scenarios
Development
Project Structure
src/
├── index.ts # Main entry point
├── server.ts # MCP server implementation
├── bruno/
│ ├── types.ts # TypeScript interfaces
│ ├── generator.ts # BRU file generator
│ ├── collection.ts # Collection management
│ ├── environment.ts # Environment management
│ └── request.ts # Request builder
└── tools/ # Individual MCP toolsBuilding
npm run build # Build TypeScript
npm run dev # Development mode
npm run clean # Clean build artifactsCode Quality
npm run lint # ESLint
npm run format # PrettierContributing
Fork the repository
Create a feature branch
Make your changes
Add tests
Submit a pull request
License
MIT License - see LICENSE file for details.
Links
Generated with Bruno MCP Server 🚀
Available Tools
1 toolrun-collectionC
Run a Bruno Collection using Bruno CLI
Inputs: collection (required), environment, variables.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 1 tool
With only one tool, there is no possibility of ambiguity or overlap between tools. The single tool has a clearly defined and distinct purpose.
A single tool inherently has perfect naming consistency, as there are no other tools to compare it against for patterns or conventions.
One tool is too few for a server's purpose, as it severely limits functionality and scope. This feels thin and incomplete for any meaningful domain coverage.
The server's purpose appears to be running Bruno Collections, but with only a 'run' operation, there are significant gaps. Missing operations like listing collections, creating collections, or managing them make the surface severely incomplete.
Maintenance
Related MCP Connectors
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
The Mercado Pago MCP Server implements the Model Context Protocol to provide AI agents and LLMs with access to Mercado Pago's APIs and tools within compatible development environments. It acts as an intermediary that translates Mercado Pago resources into executable functions (tools) that AI applications can invoke to perform actions and automate flows. The server simplifies integration, enables using documentation to implement or improve code, and optimizes operations through natural language interactions without manual implementations.
Model Context Protocol server for the Apideck Unified API. Connect any MCP-compatible agent framework to 100+ accounting systems, HRIS platforms, file storage providers, and more through one integration. More information https://www.apideck.com/mcp-server
MCP server for interacting with the Supabase platform
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceExposes Bruno API collections as Model Context Protocol (MCP) tools, allowing AI agents and MCP clients to interact with your API collections.2ISC
- MIT
- AlicenseNot gradedqualityDmaintenanceMCP server that executes requests from Bruno API collections via the Bruno CLI tool, enabling API request execution and collection management.19 PyPI4MIT
- AlicenseNot gradedqualityDmaintenanceA headless MCP server for Bruno workspaces, enabling CRUD operations on collections, folders, requests, environments, and dotenv files, plus request execution with scripting, tests, and assertions over HTTP, GraphQL, gRPC, and WebSocket.MIT