Docs/grpc

src/pages/send-requests/_meta.js

@@ -3,5 +3,6 @@ export default {
   "REST": "REST",
   "graphql": "GraphQL",
   "soap": "SOAP",
+  "grpc": "gRPC",
   "res-data-cookies": "Response Data and Cookies"
 } 

src/pages/send-requests/grpc/_meta.js

@@ -0,0 +1,6 @@
+export default {
+    "overview": "Overview",
+    "grpc-request": "Create Request",
+    "grpc-proto": "Proto Files",
+    "grpc-streams": "Streams"
+}

src/pages/send-requests/grpc/grpc-proto.mdx

@@ -0,0 +1,16 @@
+# gRPC Proto Files
+
+Proto files (`.proto`) are the foundation of gRPC services, defining the contract between clients and servers. Bruno supports adding proto files to enhance your gRPC development experience with better IntelliSense, method discovery, and type safety.
+
+## Adding Proto Files
+
+1. Open your gRPC request in Bruno
+2. In the gRPC interface, locate the **Using Reflection** section
+3. Click on the **Select Proto File** button or toggle the proto file option
+4. Click the file browser to select `.proto` files from your local system
+
+![Add Proto Files](/screenshots/send-request/grpc/5-add-probo-files.webp)
+
+Bruno will validate that the selected files are valid proto files.
+You can add multiple proto files if your service uses imports or multiple definitions.
+

src/pages/send-requests/grpc/grpc-request.mdx

@@ -0,0 +1,48 @@
+# gRPC Request
+
+Bruno provides comprehensive support for gRPC requests, enabling you to test and interact with gRPC services directly from the interface. With Bruno's gRPC support, you can:
+
+- **Add Proto files** for enhanced IntelliSense and method discovery
+- **Call server methods** with full parameter support
+- **Test real-time streaming APIs** including unary, server streaming, client streaming, and bidirectional streaming
+- **Debug gRPC services** with detailed request/response inspection
+
+## gRPC Interface
+
+![gRPC Iiterface](/screenshots/send-request/grpc/1-grpc-interface.webp)
+
+## Creating a gRPC Request
+
+### Step 1: Enable gRPC Support
+
+First, you need to enable gRPC support in Bruno's beta features:
+
+1. Go to **Settings** > **Beta**
+2. Check the **Enable** checkbox for gRPC support
+
+![Enable gRPC Support](/screenshots/send-request/grpc/1-enable.grpc-support.webp)
+
+### Step 2: Create a gRPC Request
+
+1. Open collection context menu and select **New Request** from dropdown.
+2. Select **gRPC** as your request type.
+3. Enter the **service endpoint** in the URL field.
+
+![Create gRPC Request](/screenshots/send-request/grpc/2-create-grpc-req.webp)
+
+### Step 3: Configure the Request
+
+1. Choose the **method** you want to call from the dropdown
+2. Add any **required inputs** in the message section.
+
+![Select Method](/screenshots/send-request/grpc/3-select-method.webp)
+
+### Step 4: Send the Request
+
+Click the **Send** button to execute your gRPC request.
+
+![Add Message and Receive Response](/screenshots/send-request/grpc/4-add-msg-receive-resp.webp)
+
+You'll see relevant response in the **Response** section. 
+
+To learn about proto files, navigate to the [Adding Proto file section.](./grpc-proto.mdx)

src/pages/send-requests/grpc/grpc-streams.mdx

@@ -0,0 +1,62 @@
+# gRPC Streams
+
+gRPC streaming enables real-time, bidirectional communication between clients and servers. Bruno supports all four types of gRPC streaming patterns, allowing you to test and interact with streaming APIs efficiently.
+
+## Understanding gRPC Streaming
+
+gRPC streaming allows you to send and receive multiple messages over a single connection, making it ideal for:
+- **Real-time applications** (chat, notifications, live updates)
+- **Large data transfers** (file uploads, bulk operations)
+- **Continuous data processing** (sensor data, analytics)
+- **Bidirectional communication** (collaborative editing, gaming)
+
+## Streaming Workflow
+
+### Step 1: Configure Request
+
+1. Open your collection and create a new gRPC request
+2. Add your gRPC server URL (e.g., `https://grpcb.in/`)
+3. Select a streaming method from the dropdown
+
+![Select Streaming Method](/screenshots/send-request/grpc/grpc-streams/1-grpc-select-stream.webp)
+
+### Step 2: Auto-Generate or Add Proto Files
+
+You have two options to add message schema:
+
+**Option A: Auto-Generate Messages**
+- Bruno can auto-generate message templates based on server reflection (Click the **Auto Fill** 🔄 button)
+- This works when your gRPC server has reflection enabled
+
+**Option B: Add Proto Files**
+- Upload your `.proto` files for enhanced IntelliSense
+- Provides better type safety and method discovery
+
+![Auto-Fill gRPC Messages](/screenshots/send-request/grpc/grpc-streams/2-autofill-grpc-msg.webp)
+
+### Step 3: Build Stream Connection
+
+1. **Start Stream**: Click the send button to establish the bidirectional connection
+
+![Building Stream Connection](/screenshots/send-request/grpc/grpc-streams/3-building-stream-conn.webp)
+
+### Step 4: Send Multiple Messages
+
+Once the stream is active:
+
+1. **Send Message**: Click the send button to transmit your message (next to **Auto Fill** button)
+2. **Add More Messages**: Continue sending additional messages as needed
+
+![Add Multiple Messages](/screenshots/send-request/grpc/grpc-streams/4-add-multiple-msg.webp)
+
+### Step 5: End Stream and View Timeline
+
+1. **End Message Stream**: Click the ✓ icon (end stream button) to stop sending messages
+2. **Complete Request**: End the entire streaming session
+3. **View Response Timeline**: See the complete conversation timeline with timestamps
+
+![gRPC Response Timeline](/screenshots/send-request/grpc/grpc-streams/5-grpc-res.webp)
+
+
+
+

src/pages/send-requests/grpc/overview.mdx

@@ -0,0 +1,17 @@
+import {Callout} from "nextra/components";
+
+# Overview
+
+<Callout emoji="">
+    gRPC is available in beta mode in [Bruno 2.9.0](https://www.usebruno.com/downloads) and higher versions.
+</Callout>
+
+gRPC (Google Remote Procedure Call) is a modern, high-performance Remote Procedure Call (RPC) framework developed by Google. It's designed for efficient communication when one service needs to interact with another.
+
+Imagine your Authentication Service needs to tell your Notification Service to send an OTP. In a high-traffic scenario, traditional request-response calls (like REST over HTTP/1.1) can be less efficient and introduce latency.
+
+gRPC solves this by faster communication, efficient data transfer and streaming capabilities.
+
+
+Feel free to explore our sample [gRPC collection](https://github.com/bruno-collections/gRPC-api-collection) to play around.
+