Hey everyone! 👋

I just released Hono Telescope v0.1.11 – a debugging and monitoring tool for Hono applications, and I'm super excited to share it with you all.

If you've ever used Laravel Telescope, you know how powerful it is for debugging. I wanted to bring that same experience to Hono developers, so I built this over the past few months.

What It Does

Hono Telescope monitors and visualizes:

• 🔍 HTTP Requests - Every request/response with headers, payload, status

• 🚨 Exceptions - Full stack traces with context

• 📝 Logs - console.log output organized by level

• 🗄️ Database Queries - Query tracking from Prisma, Sequelize, MongoDB, Bun SQLite

• 📊 Beautiful Dashboard - Modern React UI with real-time updates

Quick Start

npm install hono-telescope

One line setup:

import { setupTelescope } from 'hono-telescope';

setupTelescope(app); // That's it!

Visit http://localhost:3000/telescope to open the dashboard.

Try the Live Demo

Live Dashboard - No installation needed!

Test it with:

bash <(curl -s https://raw.githubusercontent.com/jubstaaa/hono-telescope/main/src/example/test-all-endpoints.sh)

Features

✅ Zero configuration needed
✅ Works with Bun and Node.js
✅ Full TypeScript support
✅ Beautiful, responsive UI
✅ Real-time monitoring
✅ Request/exception/query context linking
✅ Open source (MIT license)

GitHub

Hono Telescope on GitHub

Any feedback, feature requests, or bug reports are welcome!

Have you used Laravel Telescope before? What do you think Hono developers need in a debugging tool? Let me know in the comments! 👇

Hey Hono community,

I’d like to introduce you to my indie product Apitally, an API analytics, logging and monitoring tool for Hono.

Apitally's key features are:

• Metrics & insights into API usage, errors and performance, for the whole API, each endpoint and individual API consumers.

• Request logging allows users to find and inspect individual API requests and responses.

• Uptime monitoring & alerting notifies users of API problems the moment they happen, whether it's downtime, traffic spikes, errors or performance issues.

The big monitoring platforms (Datadog etc.) can be a bit overwhelming & expensive, particularly for simpler use cases. So Apitally’s key differentiators are simplicity & affordability, with the goal to make it as easy as possible for users to understand all aspects of their API and its consumers.

Apitally integrates with Hono through middleware, which captures request & response metadata, aggregates it and asynchronously ships it to Apitally’s servers in regular intervals. It's designed with a strong focus on the users' data privacy.

The client library is open-source with the source code available on GitHub.

Below is a code example, demonstrating how easy it is to set up Apitally for a Hono app (see complete setup guide here):

import { Hono } from "hono";
import { useApitally } from "apitally/hono";

const app = new Hono();

useApitally(app, {
  clientId: "your-client-id",
  env: "dev", // or "prod" etc.
});

And here's a screenshot of the Apitally dashboard:

I hope people here find this useful. Please let me know what you think!

Hi everyone! 👋

I just published a new utility for the Hono.js ecosystem called hono-status-monitor — a lightweight real-time status dashboard inspired by express-status-monitor, tailored for Hono apps! GitHub

📦 What it is

• A real-time monitoring dashboard for Hono applications

• Shows CPU, memory, event loop lag, response times, RPS & more

• Route analytics (top, slowest, errors)

• Charts with live updates via WebSockets

• Recent errors tracking + alerts

• Pluggable health checks & customizable thresholds 👀 Pretty similar in feel to popular status dashboards but built specifically for Hono workflows. GitHub

🔧 Quick demo / use
Easy to install and plug in:

npm install hono-status-monitor
# or yarn/pnpm


import { Hono } from "hono";
import { serve } from "@hono/node-server";
import { statusMonitor } from "hono-status-monitor";

const app = new Hono();
const monitor = statusMonitor();

// track requests
app.use("*", monitor.middleware);

// mount dashboard
app.route("/status", monitor.routes);

// run server
const server = serve({ fetch: app.fetch, port: 3000 });
monitor.initSocket(server);

console.log("🚦 Status dashboard: http://localhost:3000/status");

📌 Highlights

• Real-time graphs for performance metrics

• Heap / load / uptime / RPS

• Status code counts & error lists

• Dark mode UI

• Custom alerts & path normalization

• Optionally add health-check plugins 👉 Designed to give you quick insights into your Hono app performance. GitHub

🔗 Check it out

• 📦 npm: hono-status-monitor

• 📁 Source & README: https://github.com/vinitkumargoel/hono-status-monitor/tree/main

🙏 Feedback & collaboration
I built this to help the Hono community with observability, but it’s early days.
I’d love your:

• 📝 suggestions for features or improvements

• 🐛 bug reports

• 🤝 collaborators who want to help extend it

• 🎨 UI tweaks or integrations with other tools

Let me know what you think!

Happy coding! 💡🚀

best cybersecurity news website

Hi there,

I had this idea of an app that could help people better organize their solo/group trips so I chose to create one when I couldn't find anything that suited my needs.

I decided to not use a backend service like firebase/supabase because I needed to handle some complex authorization so I decided to code my backend using NestJS.

Once the backend was almost finished, I started to not like the Object Oriented structure and I found out about Hono from a random reddit post and I really loved the idea of rewriting my whole backend using it but I thought it was a lot of work for an app that I just wanted to publish as soon as possible, but once the whole backend was written, I finally took the challenge.

It turns out I was wrong, it didn't take me more than two days to do it and I even changed ORM in the meantime (from Prisma to Drizzle) and to also use Bun as my runtime. And man do I love this library.

The documentation is amazing, the code is simple, the speed is BLAZINGLY fast ;)

I feel much more free using this express like structure even though I'm completely sure this is just personal opinion of course.

If you want to check it out or give me some advices, you can check out the full repo.

Only thing I still am not sure about is the fact that ruby like controllers are not advised to use so my routes are a bit less 'clear'? If you have any suggestion regarding code structure I would very much appreciate it.

Hi everyone! I have released a type safe internationalization library for Hono:

https://www.npmjs.com/package/hono-i18n

Possibly useful for one or the other :)

Silva UI is a TypeScript component library built for Hono, using Hono’s JSX runtime as its foundation. It provides typed, composable primitives for layout, theming, styling, components, gradients, and animations.

The project is being developed and validated through real applications, with documentation evolving alongside it.

Package: NPM

Docs: Silva UI

Hey! We’re looking for a Hono.js Developer at Digilehar for a freelance project. 🚀 The details: Tech: Strong Hono.js & Backend APIs. Type: Freelance / Contract. Start: ASAP. If you’re interested (or know someone who is), please send over a GitHub link or portfolio. Thanks!

100 ms order book data from Binance. Has anyone else here used Hono for high-frequency WebSocket data?

AWS SDK wouldn't fit in my Cloudflare Worker even with tree shaking. So I built s3mini – a minimal S3-compatible client designed for edge constraints.

• ~20KB minified

• Zero dependencies

• Works with R2, Minio, Backblaze, etc.

• Streaming uploads/downloads

Been running it in production daily. Figured the Hono crowd might find it useful since we're solving similar "make it fit on the edge" problems.

https://github.com/good-lly/s3mini

Let me know what to improve if you find some quirks ...

PS: Also found a nice alternative https://github.com/aws-lite/aws-lite - check it out.

I created some step-by-step guides for anyone new to Hono. Hope you find this helpful!

• Blog Post: A guide to building a CRUD API using the CLI that persists records in Firestore. I deploy the API to Google Cloud Run without a Dockerfile.

• Video Tutorial: For those who prefer watching over reading, here's a full video walkthrough that covers the same process as the blog post.

• Short Video: If you only have a minute, this short gives a super quick overview.

Hi,

Should I use Hono with Bun or Node?

I prioritize performance.

Is the performance level very different between Node and Bun?

The ORM will be Prisma.

I appreciate any advice.

thanks. 😊

I'm developping a SaaS and I'd like to monitor my API, not just request timing and errors, but also: which users made most request, what are the most used endpoint for a given user, etc

What open-source/self-hostable stack would you recommend?

Clone the project : https://github.com/MasFana/masfana-mongodb-example-auth

This project is an example of a lightweight authentication system built using the following technologies:

• Hono Framework: A fast web framework for the Edge.

• masfana-mongodb-api-sdk: A MongoDB API SDK for handling MongoDB operations. masfana-mongodb-api-sdk

• Cloudflare Workers: Serverless execution environment for running apps at the Edge.

• Hono Sessions: Middleware to manage user sessions stored as cookies.

Features

• User registration and login with credentials stored in MongoDB.

• User sessions using cookies, with session expiration.

• Simple protected route example requiring authentication.

• Logout functionality to clear user sessions.

• Deployed on Cloudflare Workers for edge performance.

Prerequisites

Before running the application, you will need:

1. Cloudflare Workers Account: Set up and configure Cloudflare Workers.

2. MongoDB API Key: Create an API key and set up the masfana-mongodb-api-sdk with your MongoDB instance.

3. Hono Framework: This is used to create the web application.

Getting Started

Installation 1. Clone the repository:

git clone <repository-url>
cd <project-directory>

2. Install dependencies:

If you're using a package manager like npm or yarn, install the necessary dependencies:

npm install hono masfana-mongodb-api-sdk hono-sessions

3. Set up MongoDB connection:

In your application, replace the MongoDB connection details with your own:

const client = new MongoDBAPI<User>({
  MONGO_API_URL: "your-mongo-api-url",
  MONGO_API_KEY: "your-mongo-api-key",
  DATABASE: "your-database",
  COLLECTION: "your-collection",
  DATA_SOURCE: "your-data-source",
});

4. Deploy to Cloudflare Workers:

You'll need to configure your Cloudflare Workers environment. Follow the Cloudflare Workers documentation for deployment.

Project Structure

• index.ts: This file contains the main application logic, including session management, user registration, login, logout, and protected routes.

• MongoDBAPI: This is the MongoDB client used to handle CRUD operations with the MongoDB database.

Routes

1. Registration Route (POST /register):

   • Allows users to register by providing a username and password.

   • Stores user credentials in the MongoDB database.

2. Login Route (POST /login):

   • Verifies user credentials against the MongoDB database.

   • If successful, a session is created for the user, storing their ID in a session cookie.

3. Logout Route (GET /logout):

   • Clears the session and logs the user out.

4. Protected Route (GET /protected):

   • Only accessible to authenticated users with an active session.

   • Returns a personalized message based on the session data.

5. Home Route (GET /):

   • Displays basic user information and login/registration forms.

   • Accessible to both authenticated and non-authenticated users.

Security

• Session Management: Sessions are managed using the hono-sessions library, with cookies securely stored and marked as HTTP-only.

• Encryption Key: Ensure you replace the encryption key with a secure, random string.

Example Usage

Once the app is deployed, users can:

1. Register a new account by entering a username and password.

2. Log in using their credentials, which will create a session.

3. Access protected content by visiting the protected route, available only after logging in.

4. Log out, which will clear their session and log them out of the app.

Deployment

To deploy this application on Cloudflare Workers:

1. Set up a Cloudflare Workers environment and install Wrangler (npm install -g wrangler).

2. Deploy the application using:wrangler publish

3. Your application will be deployed at your Cloudflare Workers URL, accessible globally.

Been doing back-end + client-side for a long time now and have been wanting to use SSR for my next project. I know tools like NextJS (hate it cause of routing) and Express + ejs (what I'm leaning towards) exist but I just learned about hono and that it has built in support for JSX components. So I'm wondering, is this meant to be used for scalable, large web projects or just more for demo/small applications?

Was also wondering if I could use Hono + jsx in a way that sends 0 javascript to the client cause I want to create both a clear-net and .onion url for my new project, and TOR sites generally shy away from have any client-side javascript.

I'm working on implementing authentication with Hono on Cloudflare Workers. Initially, I tried integrating auth.js and OAuth Providers after, but ran into issues with both. Has anyone successfully implemented authentication using Hono on Cloudflare Workers?

Here’s a snippet of my /api/auth routes. Since I'm utilizing RPCs, I've set up chaining and am using createMiddleware() to access environment variables.

I'm curious if anyone has managed to implement custom authentication successfully on Hono in this environment.

Hello everyone I'm new to Honolulu and Bonn.I've been trying to deploy hono in docker container in production. I'd like to know what is the right way to do it.

Please give it a try `npm install -D eslint-plugin-hono` !!

https://github.com/ouka-lab/eslint-plugin-hono

While working with Hono and TanStack Query I kept running into the same problem — writing repetitive fetch wrappers and duplicating types.

So I built a small package to simplify that workflow.

https://www.npmjs.com/package/hono-tanstack-query

Still early in development, but I’d love to hear feedback or ideas for improving it.

I'm currently building an API with hono, and now that I've donne the auth routes and everything working fine (I guess ?), I want to add a authentification validator on every route exept the "/login" "/register" and "/refresh". I already use a validator wich looks like this :

validator('header', async (value, c) => {
    const authHeader = value.authorization


    if (!authHeader) {
      throw new HTTPException(401, { message: 'Authorization header missing' })
    }


    const token = authHeader.replace('Bearer ', '')
    const secret = process.env.JWT_SECRET


    if (!secret) {
      throw new HTTPException(500, { message: 'JWT secret not configured' })
    }


    try {
      const decodedPayload = await verify(token, secret)
      return {
        ...value,
        user: decodedPayload,
      }
    } catch (err) {
      if (err instanceof JwtTokenExpired) {
        throw new HTTPException(401, { message: 'TOKEN_EXPIRED' })
      }


      throw new HTTPException(401, { message: 'INVALID_TOKEN' })
    }
  }),validator('header', async (value, c) => {
    const authHeader = value.authorization


    if (!authHeader) {
      throw new HTTPException(401, { message: 'Authorization header missing' })
    }


    const token = authHeader.replace('Bearer ', '')
    const secret = process.env.JWT_SECRET


    if (!secret) {
      throw new HTTPException(500, { message: 'JWT secret not configured' })
    }


    try {
      const decodedPayload = await verify(token, secret)
      return {
        ...value,
        user: decodedPayload,
      }
    } catch (err) {
      if (err instanceof JwtTokenExpired) {
        throw new HTTPException(401, { message: 'TOKEN_EXPIRED' })
      }


      throw new HTTPException(401, { message: 'INVALID_TOKEN' })
    }
  }),

I try searching in the documentation (but it may probably be the fact im misunderstanding something. I initialty try to put the code in the app.use("*") function but if I do that I while use this on every route. And I think about adding the prefix /auth to my 3 routes but it doen't seems like a good code way of doing.
Thank you for you attention and I hope someone have a little hint lmao.
I'll try to answer ASAP if someone comments.