# camelcase-keys

> Convert object keys to camel case

Latest version **10.0.2** (published 2026-01-25) · MIT license · 0 weekly downloads

## Install

```sh
npm install camelcase-keys
pnpm add camelcase-keys
yarn add camelcase-keys
bun add camelcase-keys
```

## Health

**Score 60/100 (C)** — status: stable.

Positive: has types; esm support; no vulnerabilities; high quality score.

Warnings: low downloads.

## Facts

| | |
|---|---|
| Version | 10.0.2 |
| Published | 2026-01-25 |
| First published | 2014-10-12 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | bundled |
| Module format | ESM |
| Node | >=20 |
| Dependencies | 4 |
| Unpacked size | 16.3 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 758 |
| Author | Sindre Sorhus |
| Maintainers | sindresorhus |
| Keywords | map, object, key, keys, value, values, iterate, camelcase, camel-case, camel, case, dash, hyphen, dot, underscore, separator, string, text, convert, pascalcase, pascal-case, deep, recurse, recursive |

## Links

- npm: https://www.npmjs.com/package/camelcase-keys
- Repository: https://github.com/sindresorhus/camelcase-keys
- Homepage: https://github.com/sindresorhus/camelcase-keys#readme
- Issues: https://github.com/sindresorhus/camelcase-keys/issues
- Funding: https://github.com/sponsors/sindresorhus
- npm.io page: https://npm.io/package/camelcase-keys

## Dependencies (4)

- [map-obj](https://npm.io/package/map-obj.md) 6.0.0
- [camelcase](https://npm.io/package/camelcase.md) ^9.0.0
- [quick-lru](https://npm.io/package/quick-lru.md) ^7.3.0
- [type-fest](https://npm.io/package/type-fest.md) ^5.4.1

## Alternatives

- [@mce/gif](https://npm.io/package/@mce/gif.md) — 2.6K weekly downloads
- [cleanse](https://npm.io/package/cleanse.md) — 173 weekly downloads
- [str](https://npm.io/package/str.md) — 127 weekly downloads
- [naming](https://npm.io/package/naming.md) — 95 weekly downloads
- [tap-telco-api](https://npm.io/package/tap-telco-api.md) — 19 weekly downloads

## Recent versions

- 10.0.2 (latest) — 2026-01-25
- 10.0.1 — 2025-11-02
- 10.0.0 — 2025-09-09
- 9.1.3 — 2024-01-13
- 9.1.2 — 2023-10-18
- 9.1.1 — 2023-10-17
- 9.1.0 — 2023-09-29
- 9.0.0 — 2023-08-16
- 8.0.2 — 2022-08-29
- 8.0.1 — 2022-06-22
- 8.0.0 — 2022-06-06
- 7.0.2 — 2022-02-01
- 7.0.1 — 2021-10-04
- 7.0.0 — 2021-06-25
- 6.2.2 — 2020-04-03
- … 17 more at https://npm.io/package/camelcase-keys/versions

## README

# camelcase-keys

> Convert object keys to camel case using [`camelcase`](https://github.com/sindresorhus/camelcase)

## Install

```sh
npm install camelcase-keys
```

## Usage

```js
import camelcaseKeys from 'camelcase-keys';

// Convert an object
camelcaseKeys({'foo-bar': true});
//=> {fooBar: true}

// Convert an array of objects
camelcaseKeys([{'foo-bar': true}, {'bar-foo': false}]);
//=> [{fooBar: true}, {barFoo: false}]
```

```js
import {parseArgs} from 'node:util';
import camelcaseKeys from 'camelcase-keys';

const commandLineArguments = parseArgs();
//=> {_: [], 'foo-bar': true}

camelcaseKeys(commandLineArguments);
//=> {_: [], fooBar: true}
```

Leading `_` and `$` are preserved as they have semantic meaning.

```js
camelcaseKeys({_foo_bar: true, $baz_qux: true});
//=> {_fooBar: true, $bazQux: true}
```

## API

### camelcaseKeys(input, options?)

#### input

Type: `Record<string, unknown> | ReadonlyArray<Record<string, unknown>>`

A plain object or array of plain objects to camel-case.

#### options

Type: `object`

##### exclude

Type: `Array<string | RegExp>`\
Default: `[]`

Exclude keys from being camel-cased.

For correct TypeScript types when using this option with a string array, add `as const` to the array.

##### deep

Type: `boolean`\
Default: `false`

Recurse nested objects and objects in arrays.

```js
import camelcaseKeys from 'camelcase-keys';

const object = {
	'foo-bar': true,
	nested: {
		unicorn_rainbow: true
	}
};

camelcaseKeys(object, {deep: true});
//=> {fooBar: true, nested: {unicornRainbow: true}}

camelcaseKeys(object, {deep: false});
//=> {fooBar: true, nested: {unicorn_rainbow: true}}
```

##### pascalCase

Type: `boolean`\
Default: `false`

Uppercase the first character: `bye-bye` → `ByeBye`

```js
import camelcaseKeys from 'camelcase-keys';

camelcaseKeys({'foo-bar': true}, {pascalCase: true});
//=> {FooBar: true}

camelcaseKeys({'foo-bar': true}, {pascalCase: false});
//=> {fooBar: true}
````

##### preserveConsecutiveUppercase

Type: `boolean`\
Default: `false`

Preserve consecutive uppercase characters: `foo-BAR` → `FooBAR`

```js
import camelcaseKeys from 'camelcase-keys';

camelcaseKeys({'foo-BAR': true}, {preserveConsecutiveUppercase: true});
//=> {fooBAR: true}

camelcaseKeys({'foo-BAR': true}, {preserveConsecutiveUppercase: false});
//=> {fooBar: true}
````

##### stopPaths

Type: `string[]`\
Default: `[]`

Exclude children at the given object paths in dot-notation from being camel-cased.

For correct TypeScript types when using this option, add `as const` to the array.

For example, with an object like `{a: {b: '🦄'}}`, the object path to reach the unicorn is `'a.b'`.

```js
import camelcaseKeys from 'camelcase-keys';

const object = {
	a_b: 1,
	a_c: {
		c_d: 1,
		c_e: {
			e_f: 1
		}
	}
};

camelcaseKeys(object, {
	deep: true,
	stopPaths: [
		'a_c.c_e'
	]
}),
/*
{
	aB: 1,
	aC: {
		cD: 1,
		cE: {
			e_f: 1
		}
	}
}
*/
```

When an object is inside an array, the path is specified without array indices. A `stopPath` will apply to all items in the array.

```js
import camelcaseKeys from 'camelcase-keys';

const object = {
	foo: [
		{
			bar: {
				baz_qux: 'value'
			}
		}
	]
};

camelcaseKeys(object, {
	deep: true,
	stopPaths: [
		'foo.bar'
	]
}),
/*
{
	foo: [
		{
			bar: {
				baz_qux: 'value'
			}
		}
	]
}
*/
```

## Related

- [decamelize-keys](https://github.com/sindresorhus/decamelize-keys) - The inverse of this package
- [snakecase-keys](https://github.com/bendrucker/snakecase-keys)
- [kebabcase-keys](https://github.com/mattiloh/kebabcase-keys)

---
_Source: https://npm.io/package/camelcase-keys · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._