With the growing ecosystem of JavaScript runtime environments, Bun is gaining attention as a fast, modern alternative to Node.js and Deno. Designed for speed and developer productivity, Bun provides built-in tools like a JavaScript runtime, bundler, and task runner—all in one package. This makes it a great choice for building APIs quickly and efficiently. In this blog, we’ll walk you through creating an API endpoint using Bun.

What Is Bun? 🤔

Bun is a new JavaScript runtime designed with the following goals:

If you’re already familiar with Node.js or Deno, picking up Bun will feel natural.

Why Use Bun? 🔍

Prerequisites 🛠️

Before we dive in, make sure you have:

• Bun installed on your machine:

    bashCopyEditcurl https://bun.sh/install | bash
  

• Basic knowledge of JavaScript and HTTP concepts.

• A code editor (e.g., VS Code).

Step 1: Initialize a New Bun Project 🔥

Create a new Bun project. Open your terminal and run:

bashCopyEditbun init api-example
cd api-example

The bun init command will scaffold a new Bun project with a basic structure and a package.json file.

Step 2: Install Dependencies (Optional) 📦

Bun has a built-in package manager that is faster than npm or Yarn. If your API requires external dependencies, install them using Bun. For example:

bashCopyEditbun add express

However, Bun can handle HTTP requests without additional libraries, thanks to its built-in APIs.

Step 3: Create Your API Server 🚀

Bun’s HTTP module makes creating a server easy. Create a file named server.js (or server.ts for TypeScript). Inside, write the following code:

javascriptCopyEditimport { serve } from "bun";

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

    // Define routes
    if (path === "/") {
      return new Response(JSON.stringify({ message: "Welcome to the Bun API!" }), {
        headers: { "Content-Type": "application/json" },
      });
    } else if (path === "/hello") {
      return new Response(JSON.stringify({ message: "Hello, World!" }), {
        headers: { "Content-Type": "application/json" },
      });
    }

    // Handle 404
    return new Response(JSON.stringify({ error: "Not Found" }), {
      status: 404,
      headers: { "Content-Type": "application/json" },
    });
  },
});

Explanation:

• serve: Bun’s built-in function to start an HTTP server.

• fetch: Handles incoming HTTP requests.

• req.url: The URL of the request, which is used to define simple routing logic.

• Response: The object returned to the client.

Step 4: Start the Server 🏃‍♂️

To start the server, run the following command:

bashCopyEditbun server.js

Bun will start your server at http://localhost:3000. You should see output indicating that the server is running.

Step 5: Test Your API 🔍

Test your API endpoints using tools like Postman, cURL, or a browser.

For example:

• Navigate to http://localhost:3000
  Response: { "message": "Welcome to the Bun API!" }

• Navigate to http://localhost:3000/hello
  Response: { "message": "Hello, World!" }

• Navigate to a non-existent route like http://localhost:3000/unknown
  Response: { "error": "Not Found" }

Step 6: Enhance Your API 🔧

Want to extend your API? Here are a few ideas:

• Add query parameters:
  Use url.searchParams.get("key") to access query parameters.

• Handle POST requests:
  Check req.method === "POST" and use await req.json() to parse JSON bodies.

• Use middleware:
  Create reusable functions for tasks like authentication or logging.

Example for handling a POST request:

javascriptCopyEditif (path === "/submit" && req.method === "POST") {
  const body = await req.json();
  return new Response(JSON.stringify({ received: body }), {
    headers: { "Content-Type": "application/json" },
  });
}

Advantages of Using Bun for APIs 🚀

Use Cases of Bun 🌱

• API Development 📡: Quickly spin up and manage RESTful APIs for your applications.

• Prototyping 🔄: Ideal for fast prototyping with its simplicity and speed.

• Microservices 🐝: Build fast, lightweight microservices that can scale efficiently.

• Static Site Generation 📑: Leverage Bun’s bundler for static site generation that’s lightning fast.

Conclusion 🎉

Building APIs with Bun is straightforward and highly efficient, thanks to its modern design and built-in features. Whether you’re prototyping a small app or developing a large-scale API, Bun provides the tools to get started quickly. Try it out today and experience the speed and simplicity for yourself! 🚀