How to fix Cannot resolve TypeScript service in @typescript-eslint in TypeScript

The most common fix is to properly configure the project option in your ESLint config to point to your tsconfig.json:

For .eslintrc.js:

module.exports = {
  parser: '@typescript-eslint/parser',
  parserOptions: {
    project: './tsconfig.json',
    tsconfigRootDir: __dirname,
  },
  plugins: ['@typescript-eslint'],
  extends: [
    'plugin:@typescript-eslint/recommended',
    'plugin:@typescript-eslint/recommended-requiring-type-checking',
  ],
};

For eslint.config.js (flat config):

import tseslint from '@typescript-eslint/eslint-plugin';
import parser from '@typescript-eslint/parser';

export default [
  {
    files: ['**/*.ts', '**/*.tsx'],
    languageOptions: {
      parser: parser,
      parserOptions: {
        project: './tsconfig.json',
        tsconfigRootDir: import.meta.dirname,
      },
    },
    plugins: { '@typescript-eslint': tseslint },
  },
];

Key points:
- Use tsconfigRootDir: __dirname to ensure paths resolve correctly regardless of where ESLint runs
- The project path should be relative to tsconfigRootDir
- For multiple tsconfig files, use an array: project: ['./tsconfig.json', './tsconfig.node.json']

As of @typescript-eslint v5.52.0+, you can set project: true to automatically find the nearest tsconfig.json for each file:

module.exports = {
  parser: '@typescript-eslint/parser',
  parserOptions: {
    project: true,
    tsconfigRootDir: __dirname,
  },
};

This approach:
- Automatically finds the closest tsconfig.json for each linted file
- Works well with monorepos where different packages have different configs
- Eliminates the need to manually specify multiple tsconfig paths
- Requires @typescript-eslint/parser v5.52.0 or newer

Example project structure:

my-project/
├── .eslintrc.js (with project: true)
├── tsconfig.json
├── packages/
│   ├── app/
│   │   └── tsconfig.json
│   └── lib/
│       └── tsconfig.json

Each package's files will use their nearest tsconfig.json automatically.

Config files like .eslintrc.js, jest.config.ts, and other root-level TypeScript files often aren't included in your main tsconfig.json. Create a separate config for ESLint:

Create tsconfig.eslint.json:

{
  "extends": "./tsconfig.json",
  "include": [
    "src/**/*",
    ".eslintrc.js",
    "jest.config.ts",
    "*.config.ts",
    "scripts/**/*"
  ]
}

Update .eslintrc.js to use it:

module.exports = {
  parser: '@typescript-eslint/parser',
  parserOptions: {
    project: './tsconfig.eslint.json',
    tsconfigRootDir: __dirname,
  },
};

Important notes:
- Don't name it tsconfig.json - the TypeScript service won't recognize other names
- Use extends to inherit your main compiler options
- Include all files you want to lint
- This config is only for linting, not compilation

If you're getting errors about specific files not being in your TypeScript project, add them to the include array:

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "strict": true
  },
  "include": [
    "src/**/*",
    "tests/**/*",
    "*.config.ts",
    ".eslintrc.ts"
  ],
  "exclude": [
    "node_modules",
    "dist"
  ]
}

Alternative: Use .eslintignore for files you don't want to lint:

Create .eslintignore in your project root:

# Don't lint config files
*.config.js
.eslintrc.js

# Don't lint build output
dist/
build/

# Don't lint dependencies
node_modules/

This prevents ESLint from trying to lint files that shouldn't be type-checked.

If you upgraded to @typescript-eslint v6 and see module resolution errors, update your tsconfig.json moduleResolution strategy:

Old configuration (Node.js <16):

{
  "compilerOptions": {
    "moduleResolution": "node"
  }
}

New configuration (Node.js 16+):

{
  "compilerOptions": {
    "moduleResolution": "bundler",
    // OR for Node.js projects:
    "moduleResolution": "node16",
    // OR:
    "moduleResolution": "nodenext"
  }
}

Why this is needed:

@typescript-eslint v6+ uses package.json exports which require:
- Node.js 16 or higher
- Modern module resolution strategy (bundler, node16, or nodenext)

If you must stay on Node.js <16:

Downgrade to @typescript-eslint v5:

npm install --save-dev @typescript-eslint/parser@5 @typescript-eslint/eslint-plugin@5

@typescript-eslint/parser requires TypeScript as a peer dependency:

# Check if TypeScript is installed
npm list typescript

# If missing, install it
npm install --save-dev typescript

# Verify version (should be 4.x or 5.x)
npx tsc --version

Version compatibility:

| @typescript-eslint | TypeScript Version |
|--------------------|-------------------|
| v6.x | 4.3.5 - 5.3.x |
| v5.x | 3.3.1 - 5.1.x |
| v7.x | 4.7.4 - 5.4.x |

If you have multiple TypeScript versions (e.g., global + local), ensure ESLint uses the local one:

# Remove global TypeScript
npm uninstall -g typescript

# Use local TypeScript only
npx tsc --version

After making configuration changes, VS Code's ESLint server may have stale information:

Method 1: Command Palette

1. Press Cmd/Ctrl + Shift + P
2. Type "ESLint: Restart ESLint Server"
3. Press Enter

Method 2: Reload VS Code

1. Press Cmd/Ctrl + Shift + P
2. Type "Developer: Reload Window"
3. Press Enter

Method 3: Check ESLint Output

1. Open Output panel: View → Output
2. Select "ESLint" from dropdown
3. Look for error messages showing what went wrong

If errors persist:

Clear VS Code's cache and restart:

# Close VS Code completely
# Then on macOS/Linux:
rm -rf ~/.vscode/extensions/dbaeumer.vscode-eslint-*/

# On Windows:
# Delete: %USERPROFILE%\.vscode\extensions\dbaeumer.vscode-eslint-*

# Restart VS Code and reinstall ESLint extension