# Creating Api Engpoints Using Bun

---

# Building High-Performance APIs with Bun: A Modern Developer’s Guide 🚀

APIs are the backbone of modern web development, powering everything from single-page applications to large-scale services. But building efficient APIs doesn’t have to be complicated. Enter **Bun**, a cutting-edge JavaScript runtime designed to streamline API development with its native HTTP server.

In this guide, we’ll explore how to create APIs using Bun and why it’s a game-changer for developers looking for speed, simplicity, and scalability.

---

## What Makes Bun Special? 🌟

Bun is a **lightning-fast JavaScript runtime** that combines:

* A **runtime** for executing JavaScript and TypeScript.
    
* A **bundler** for packaging your projects.
    
* A **package manager** to handle dependencies.
    

One standout feature of Bun is its **built-in HTTP server**, allowing you to create APIs without additional libraries like Express.

---

## Getting Started with Bun APIs 🛠️

Before diving in, make sure Bun is installed on your system. If not, head over to Bun’s [official website](https://bun.sh/) and follow the installation guide. Once done, you’re ready to create your first API!

---

### Creating a Simple API Endpoint

Let’s build a basic API server where the port is configurable via the command line.

```javascript
import { serve } from "bun";  

// Use a dynamic port or default to 3000  
const port = process.argv[2] || 3000;  

serve({  
  port: Number(port),  
  fetch(req) {  
    const url = new URL(req.url);  

    // A simple GET endpoint  
    if (url.pathname === "/api/hello" && req.method === "GET") {  
      return new Response(JSON.stringify({ message: "Hello, Bun!" }), {  
        status: 200,  
        headers: { "Content-Type": "application/json" },  
      });  
    }  

    // Handle undefined routes  
    return new Response("Not Found", { status: 404 });  
  },  
});  
```

### Running the Server

Save the file as `server.js` and start the server:

```bash
bun server.js 5000  
```

Visit [http://localhost:5000/api/hello](http://localhost:5000/api/hello), and you’ll see this response:

```json
{  
  "message": "Hello, Bun!"  
}  
```

If no port is specified, the server defaults to `3000`.

---

## Building Advanced APIs with Dynamic Routing 🔧

Let’s extend the server with:

* **Dynamic routes** for flexible endpoints.
    
* **Support for multiple HTTP methods**, like POST and GET.
    

### Example: Dynamic Routing and JSON Handling

```javascript
import { serve } from "bun";  

serve({  
  port: 3000,  
  fetch(req) {  
    const url = new URL(req.url);  

    // POST endpoint to greet a user  
    if (url.pathname === "/api/greet" && req.method === "POST") {  
      return req.json().then((body) => {  
        const name = body.name || "Guest";  
        return new Response(JSON.stringify({ message: `Hello, ${name}!` }), {  
          status: 200,  
          headers: { "Content-Type": "application/json" },  
        });  
      });  
    }  

    // Dynamic route for user IDs  
    if (url.pathname.startsWith("/api/user/") && req.method === "GET") {  
      const userId = url.pathname.split("/").pop();  
      return new Response(  
        JSON.stringify({ userId, message: `User ID is ${userId}` }),  
        {  
          status: 200,  
          headers: { "Content-Type": "application/json" },  
        }  
      );  
    }  

    return new Response("Not Found", { status: 404 });  
  },  
});  
```

---

## Testing the API Endpoints 🧪

### Test 1: Dynamic GET Request

```bash
curl http://localhost:3000/api/user/123  
```

Response:

```json
{  
  "userId": "123",  
  "message": "User ID is 123"  
}  
```

### Test 2: JSON POST Request

```bash
curl -X POST http://localhost:3000/api/greet \  
     -H "Content-Type: application/json" \  
     -d '{"name": "Alice"}'  
```

Response:

```c
{  
  "message": "Hello, Alice!"  
}  
```

---

## Why Choose Bun for API Development? 🎉

Here’s why Bun is a perfect fit for building APIs:

* **Blazing Speed**: Powered by Zig, Bun delivers unmatched performance.
    
* **Simplified Development**: The native HTTP server eliminates dependencies like Express.
    
* **All-in-One Tool**: Bun handles runtime, bundling, and package management seamlessly.
    

---

## Final Thoughts 🎯

Bun is a revolutionary tool for modern web developers, offering simplicity and performance in one package. Whether you’re building lightweight APIs or full-scale systems, Bun’s features make it an ideal choice.

Ready to give Bun a try? Install it today and unlock new possibilities for API development! 🚀

---