Knip

Static analysis tool that finds unused files, exports, and dependencies in JavaScript and TypeScript projects. Supports monorepos, auto-detects 50+ frameworks via plugins, and can automatically remove dead code with the --fix flag.

What is Knip?

Knip (a Dutch word for "snip" or "cut") is an open-source static analysis tool for JavaScript and TypeScript codebases. It traces your project's dependency graph starting from configured entry points and identifies everything that is never imported or consumed: unused source files, unused exported symbols, and packages listed in package.json that are never actually used.

As projects grow, dead code accumulates silently. Developers rename functions without removing old versions, split files without deleting originals, or install packages that a feature pivot made redundant. Knip surfaces all of this in a single report so you can cut what no longer serves the codebase — reducing bundle size, speeding up builds, and lowering cognitive load for future maintainers.

Key Features

• Unused file detection — finds source files that are never imported from any entry point in the project graph
• Unused export detection — reports exported functions, classes, types, and constants that no other module imports
• Dependency auditing — identifies packages in dependencies and devDependencies that are never actually used
• Monorepo support — per-workspace configuration with correct cross-package reference tracking to avoid false positives
• 50+ framework plugins — auto-detects and configures entry points for Next.js, Astro, Vite, Vitest, ESLint, Tailwind CSS, Storybook, and more
• Test-only export reporting — flags exports consumed only in test files, which may be candidates for removal or internalization
• Auto-fix mode — removes unused export keywords, deletes unused files, and prunes package.json entries
• Zero dependencies — the Knip package itself has no runtime npm dependencies, keeping install fast and supply chain risk low

Installation

# Install Knip as a dev dependency
npm add -D knip

# Or run without installing
npx knip

# Auto-fix issues (removes unused exports, unlinks files, removes deps)
knip --fix

# Use the compact reporter for terse output
knip --reporter compact

# Check only specific issue types
knip --include files,dependencies

# Run in watch mode during development
knip --watch

Basic Configuration and Output

Create a knip.json at the project root with entry (known start files) and project (all source files to consider) glob patterns, then run npx knip.

// knip.json — minimal config at the project root
{
  "entry": ["src/index.ts", "src/cli.ts"],
  "project": ["src/**/*.ts"]
}

// Then run:
// npx knip
//
// Sample output:
// Unused files (2)
//   src/utils/legacy-helper.ts
//   src/types/old-types.ts
//
// Unused exports (3)
//   src/utils/format.ts: formatDate, formatTime
//   src/api/client.ts: legacyFetch
//
// Unlisted dependencies (1)
//   lodash (used in src/utils/sort.ts but not in package.json)
//
// Unused devDependencies (2)
//   @types/node, ts-node

Monorepo Configuration

Use the workspaces key to configure each package independently. Knip understands cross-workspace imports and will not flag symbols that are consumed by sibling packages.

// knip.json — monorepo workspace configuration
{
  "workspaces": {
    ".": {
      "entry": ["scripts/*.ts"],
      "project": ["scripts/**/*.ts"]
    },
    "packages/ui": {
      "entry": ["src/index.ts"],
      "project": ["src/**/*.ts"]
    },
    "packages/api": {
      "entry": ["src/index.ts", "src/routes/*.ts"],
      "project": ["src/**/*.ts"]
    },
    "apps/web": {
      "entry": ["src/app/**/*.{ts,tsx}", "src/pages/**/*.{ts,tsx}"],
      "project": ["src/**/*.{ts,tsx}"]
    }
  }
}

Framework Plugins

Knip ships with plugins for 50+ tools. Plugins are auto-activated based on what is installed in your project. They extend the entry patterns so framework-specific files (page routes, config files, test suites) are correctly recognized as entry points rather than reported as unused.

// knip.json — using plugins for popular frameworks
{
  "entry": ["src/index.ts"],
  "project": ["src/**/*.ts"],
  // Knip auto-detects and activates plugins for installed tools.
  // You can override plugin config explicitly:
  "next": {
    "entry": ["src/app/**/*.{ts,tsx}", "src/pages/**/*.{ts,tsx}"]
  },
  "vitest": {
    "entry": ["src/**/*.test.ts", "src/**/*.spec.ts"]
  },
  "eslint": {
    "config": [".eslintrc.json"]
  }
}

// Knip ships plugins for 50+ tools including:
// Next.js, Remix, Astro, SvelteKit, Vite, Vitest, Jest,
// ESLint, Prettier, Tailwind CSS, Storybook, Playwright,
// TypeScript, tsup, Rollup, Webpack, esbuild, and more.

CI Integration

Add Knip to your CI pipeline to catch dead code on every pull request. The process exits with a non-zero code when issues are found, blocking merges until the dead code is removed or explicitly ignored.

# .github/workflows/knip.yml
name: Knip — Dead Code Check

on:
  pull_request:
  push:
    branches: [main]

jobs:
  knip:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: npm
      - run: npm ci
      - name: Run Knip
        run: npx knip --reporter compact

Knip vs ESLint no-unused-vars

Pros and Cons