How to Set Up a Node.js API with TypeScript in 2025

Nowadays, creating an efficient and scalable API with Node.js and TypeScript is simpler and more powerful than ever. At CodeInit, we aim to deliver practical and straightforward tutorials to help you build professional solutions that meet market demands. In this article, I’ll walk you step-by-step through setting up a modern API using the best practices for 2025.

Whether you're a beginner or an experienced developer looking to boost your workflow, this guide is for you. Let’s dive into it together!

Why Use Node.js and TypeScript?

Node.js remains one of the most popular backend technologies, and when combined with TypeScript, you get the best of both worlds: speed and safety. TypeScript adds static typing, making your code easier to maintain and reducing common errors.

In 2025, mastering tools that boost productivity and align with market trends is essential.

What You Need Before Starting

Before getting started, make sure your environment is set up correctly. Here are the prerequisites:

• Node.js 20 or later
• Text Editor – I recommend Visual Studio Code
• Basic knowledge of JavaScript and terminal
• npm, yarn, or pnpm installed on your system

Tip: Use the integrated terminal in VS Code to follow this tutorial more easily.

Personally, I like using pnpm. To install pnpm globally, use the command below:

npm i -g pnpm

Step 1: Setting Up the Environment

First, ensure that Node.js is installed:

node -v

If everything is set up correctly, you should see the Node.js version. Otherwise, download the latest version from the official website.

Now, let’s create the project structure:

mkdir my-api && cd my-api
pnpm init -y

This command creates the package.json file, which manages the project dependencies.

Step 2: Installing TypeScript

TypeScript is essential for maintaining and organizing larger projects. Let’s install it:

pnpm install typescript tsx @types/node -D

Next, configure TypeScript by creating a tsconfig.json file:

npx tsc --init

Edit the file to reflect the best practices for 2025:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "CommonJS",
    "strict": true,
    "outDir": "dist",
    "rootDir": "src"
  }
}

Create the src directory to organize your code:

mkdir src

Step 3: Adding ESLint

Maintaining clean code is crucial. Let’s add ESLint to ensure quality and standardization.

Use the command below to configure ESLint:

pnpm create @eslint/config@latest

Recommended ESLint Settings

• How would you like to use ESLint? (To check syntax and find problems)
• What type of modules does your project use? (JavaScript modules (import/export))
• Which framework does your project use? (None)
• Does your project use TypeScript? (Yes)
• Where does your code run? (Node)
• Would you like to install them now? (Yes)

Once installed, the eslint.config.js file will be created in the project root.

Here’s an example configuration:

import pluginJs from '@eslint/js';
import globals from 'globals';
import tseslint from 'typescript-eslint';

/** @type {import('eslint').Linter.Config[]} */
export default [
  { files: ['**/*.{js,mjs,cjs,ts}'] },
  { languageOptions: { globals: globals.node } },
  pluginJs.configs.recommended,
  ...tseslint.configs.recommended,
  {
    rules: {
      semi: 'off',
      quotes: ['error', 'single']
    }
  }
];

Add ESLint Commands

Add the following scripts to package.json:

"scripts": {
  "lint": "npx eslint ./src/**",
  "lint:fix": "npx eslint ./src/** --fix"
}

The first command runs ESLint and displays errors in the console, while the second tries to fix the errors automatically.

Run:

pnpm lint

or

pnpm lint:fix

Step 4: Building the API

Creating the Health Check Route

Now it’s time to get started with your API. Let’s use Express, a minimalist framework for Node.js.

Install Express and its types:

pnpm add express @types/express

Create the src/index.ts file and add the following code:

import express, { Request, Response } from 'express';

const app = express();
app.use(express.json());

// Health check route with defined types
app.get('/health', (req: Request, res: Response) => {
  res.status(200).json({ status: 'API is running successfully!' });
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

Add the following script to package.json:

"scripts": {
  ...
  "start": "tsx watch src/index.ts"
}

Run:

pnpm start

Visit: http://localhost:3000/health to check the API health.

Adding the Pokémon Route

Let’s expand the API with a route that returns a list of Pokémon.

Update src/index.ts with the following code:

// Interface to define a Pokémon type
interface Pokemon {
  id: number;
  name: string;
  type: string;
}

// Sample data
const pokemons: Pokemon[] = [
  { id: 1, name: 'Pikachu', type: 'Electric' },
  { id: 2, name: 'Charmander', type: 'Fire' },
  { id: 3, name: 'Bulbasaur', type: 'Grass/Poison' }
];

// Route to return the list of Pokémon
app.get('/pokemons', (req: Request, res: Response<Pokemon[]>) => {
  res.status(200).json(pokemons);
});

Test the route: http://localhost:3000/pokemons.

Conclusion

In this guide, you learned how to set up a modern API with Node.js and TypeScript, starting with a simple route and expanding it to include typed data. This is just the beginning! With this foundation, you can implement authentication, database connections, and much more.

If you found this article helpful, share it with other developers and subscribe to our newsletter for more tips. Let’s conquer the development world together! 🚀