What is httpc?

httpc is a javascript/typescript framework for building function-based API with minimal code and end-to-end type safety.


There are scenarios where an API is just a fancy way to expose functions. Likewise, most of the time a client just wants to call a function on the server.

The http protocol provides too many features (and complexity) to achieve that simple use case. httpc is an abstraction over http, making easy to call functions without worrying about the underlying protocol.

How it works?

You define functions on the server.

async function getById(productId: string) {
    const product = await db.getProduct(productId);
    if (!product) {
        throw new NotFoundError();

    return product;

export default {
    products: {

httpc provides the tooling to generate an api client to deliver a smooth developer experience.

const product = await client.products.getById("some-product-id");

No fetch requests, no body serialization, just natural function calls.

Key features

No boilerplate code

You just write functions and export them. No need to worry how the server will execute them.

function add(a: number, b: number) {
    return a + b;

function greet(name: string) {
    return `Hello ${name}`;

export default {


Run common logic via middlewares.

import { httpCall } from "@httpc/server";

const getPostById = httpCall(
    Authenticated(),    // <-- authentication check
    Validate(String),   // <-- parameters validation
    Cache("5m"),        // <-- result caching
    async (postId: string) => {
        const post = await"posts").where("id", postId);
        if (!post) {
            throw new NotFoundError();

        return post;

@httpc/kit provides many builtin middlewares covering authentication, validation, logging, etc… Or, you can create a custom one according your use case.

Context ubiquity

You can access the request context from everywhere in your application. Be in a handler, middleware o service logic, the context is always available with no need to pass parameters around.

async function getPosts() {
    const { user } = useContext();

    let category = "news";
    if (user) {
        category = user.preferredCategory;
        trace("Getting user preferred posts");
    return await"posts").where("category", category);

function trace(message: string) {
    const { requestId } = useContext();
    console.log(`[req:${requestId}] ${message}`);

export default {

You can extend the context with your own info with full type safety and autocompletion support.


Hooks encapsulate common logic around the request context. By convention hooks adopt the use prefix.

async function addNewComment(postId: string, message: string) {
    const user = useUser();

    if (!useIsAuthorized("comment:create")) {
        throw new ForbiddenError("Cannot add comments");

    return await db.createComment({

@httpc/kit offers several builtin hooks to cache data, to perform authorization checks, to make transactions…


You can host a full httpc API inside a serverless environment like Vercel, AWS Lambda or Netlify functions. This gives the advantage to deploy a single serverless function handling the whole API.

For example with Vercel, you can expose all your API functions and call them from pages with full type checking:

import { createHttpCVercelAdapter } from "@httpc/adapter-vercel";
import calls from "../calls";

export default createHttpCVercelAdapter({
    log: "info"

Client generation

Through @httpc/cli you can generate a specific client for your API. The generated client gives the following benefits:

Highly customizable

httpc family

Project status

httpc is experimental. It’s in its infancy stage. You can try it, adopt it in hobby projects. But it’s not ready for production.

The API is not stable yet. Breaking changes will happen.

httpc is under heavy development. You can checkout the Changelog and the Roadmap for future features.



You can join on Discord and follow the development, discuss contributions, receive support or ask for help. Participation in Github discussion is fine too.

File an Issue

For any bugs, feature requests or proposals you can file an issue. All issues are available on Github.


All contribution are welcome. Any PR, issue and feedback is appreciated. Checkout the contribution guide.

Next steps