# react-native-camera-kit: Tesla's MIT Camera Library for React Native

> react-native-camera-kit wraps AVFoundation and CameraX behind one Camera component for iOS and Android. It is a good fit for scan and capture flows, and a poor fit for teams that want the library to handle permissions or filter-heavy previews.

**teslamotors/react-native-camera-kit** — A high performance, easy to use, rock solid camera library for React Native apps.

- Repository: https://github.com/teslamotors/react-native-camera-kit
- Stars: 2,706 · Forks: 634
- Language: Swift
- License: MIT
- Published: 2026-09-28 · Updated: 2026-09-28 · Language: en
- Canonical page: https://hysenlabs.com/projects/teslamotors-react-native-camera-kit

## What react-native-camera-kit covers and who it is for

The README describes react-native-camera-kit as a high performance, easy to use, rock solid camera library for React Native apps, published by Tesla under the MIT license. It targets two platforms, iOS and Android, and its stated feature list is short: a cross platform camera, a capture path tuned for a high photo capture rate, QR and barcode scanning, face detection, and a camera preview that works in the iOS simulator.

That list tells you who the library is for. If your app needs to open a camera, show a preview, take a picture, or read a code, this is the scope. The project ships a barebones Camera component for what the README calls an advanced or customized interface, so you own the surrounding UI: shutter button, review screen, retake flow. It is not a full camera application in a package.

It is also not a general computer vision toolkit. Face detection returns geometry (id, yaw, pitch, roll and a bounding box) rather than images or landmarks, and the README documents no segmentation, text recognition or object classification. Teams that want to run their own model over camera frames should look elsewhere, because the documented surface does not expose frames.

## How the Camera component, barcode scanning and face detection work

The public API is a single component plus a small set of props. You import Camera and CameraType from react-native-camera-kit, render Camera with a ref, and set cameraType to CameraType.Back or the front option, with back as the default. flashMode accepts values such as auto. Everything else is opt in.

Barcode scanning is enabled by the scanBarcode prop. When it is on, onReadCode fires with the decoded result, showFrame draws a transparent scanning layer with a laser animation that stops once a code has been found, and laserColor and frameColor control the appearance of that frame. The README is explicit that the code is read only inside the frame area, and that the frame always sits at the center of the screen. That is a real constraint on layout: you cannot move the scan region to the top of the preview through a documented prop.

Face detection is a different path on each platform. iOS uses Apple Vision and Android uses Google ML Kit, which means behaviour and model availability differ by OS even though the JavaScript prop is the same. You enable it with faceDetectionEnabled, throttle callbacks with faceDetectionThrottleMs (default 100ms), and receive an array of faces in onFaceDetected. On Android, the library depends on the unbundled play-services-mlkit-face-detection variant, so the model is downloaded by Google Play Services rather than bundled in the APK. The onFaceDetectionInstallStatus callback reports states of pending, downloading, installing, ready, failed or unavailable. The README states plainly that Android face detection requires a Google Play Store device, which excludes many emulators and sideloaded builds.

## Installing react-native-camera-kit and taking a first photo

The README targets React Native above 0.60 and gives two commands. The first adds the package from npm; the second installs the iOS pod.

```bash
yarn add react-native-camera-kit
cd ios && pod install && cd ..
```

On Android the README points to docs/kotlin.md and asks you to review your Kotlin configuration for compatibility before building. That step is easy to skip and it is the kind of thing that surfaces as a Gradle error rather than a helpful message.

Permissions are deliberately out of scope. The README says you must use a separate library for prompting the user before rendering the Camera component and recommends zoontek's react-native-permissions. It warns that if you fail to prompt for permission, the camera will appear blank or black. The reasoning given is that permission state is more complex than granted or denied, with unavailable, blocked and limited results, and the maintainers do not want to duplicate that flow. Older versions had a permissions API and the README says those APIs will be removed.

You still declare the platform entries yourself. On Android, add the camera and storage permissions to AndroidManifest.xml, usually under android/src/main/.

```xml
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
```

On iOS, add usage descriptions to Info.plist, usually under ios/PROJECT_NAME/, for example NSCameraUsageDescription with the string For taking photos and NSPhotoLibraryUsageDescription with the string For saving photos. Once permissions are granted, rendering the component is short.

```tsx
import { Camera, CameraType } from 'react-native-camera-kit';

<Camera
  ref={(ref) => (this.camera = ref)}
  cameraType={CameraType.Back}
  flashMode="auto"
/>
```

For a scanning screen, the same component gains the barcode props. The README shows scanBarcode, onReadCode, showFrame and the two colour props together, with showFrame defaulting to false. If you want to run the library's own demo, the repository ships an example project; the README lists yarn bootstrap followed by yarn example ios or yarn example android, and package.json defines bootstrap as installing example dependencies and running pod install.

## Where react-native-camera-kit stops being the right tool

The permission decision is the clearest boundary. A library that refuses to own permissions is making a defensible architectural choice, and the README explains it. The cost lands on you: an app that renders Camera before permission is granted shows a black preview, and there is no documented prop that turns that into an in-component placeholder. You have to guard the render yourself.

Android face detection carries a second constraint. Because the library uses the unbundled ML Kit variant, the model arrives through Google Play Services after install, and the README notes that the default download happens on first use. It does document a way to pre-download: adding a meta-data entry to the application element of AndroidManifest.xml, with a link to Google's installation-paths guidance. Without that, a user's first face-detection session can begin before the model is ready, and your only signal is the install status callback. Devices without Play Services, including the Play Store requirement the README states, are out of scope entirely.

The scanning frame is the third limit. Since the read area is fixed at the center of the screen, a design that wants a code read in a corner region needs a different approach. And if your product needs custom frame processing, filters or a preview composed in JavaScript, this library does not document that capability. In those cases the component is the wrong layer, not a configuration problem.

## react-native-camera-kit compared with react-native-vision-camera

The obvious alternative is react-native-vision-camera, which appears in the related searches for this project. The difference in approach is architectural rather than cosmetic. react-native-camera-kit presents one Camera component whose behaviour is configured through props and whose heavy lifting happens in Swift and Kotlin, with the JavaScript side receiving events such as onReadCode and onFaceDetected. The README frames the component as barebones, meaning the library supplies the camera and you supply the interface.

react-native-vision-camera is built around frame processors, which let JavaScript or native code work on camera frames as they arrive. That is the capability react-native-camera-kit does not document, and it is the reason teams building on-device vision features tend to reach for the other library. The trade-off runs the other way too: a frame processor pipeline is more to configure and more to debug than rendering a component and reading a callback.

For a checkout scanner, a document capture screen or a simple selfie flow, the prop-driven model here is less machinery. For a product whose value depends on what you compute from each frame, the frame-processor model is the one that matches the problem. Neither is a drop-in replacement for the other, so the decision should be made before the camera screen is written, not after.

## Maintenance, upgrades and what the MIT license means here

The repository is not archived, and the last push was on 2026-08-03. The most recent release listed is v18.0.1, published the same day, following v18.0.0 on 2026-05-12 and v17.0.1 on 2026-01-12. The cadence visible in the release list is a major or minor bump roughly every few months, with patch releases in between.

Upgrade cost concentrates in three places. Major versions can change the JavaScript surface, and the README already records one such removal: permissions APIs existed in earlier versions and will be removed, so code written against those older APIs has to move to react-native-permissions. Native configuration is the second area, since the README directs Android users to review Kotlin compatibility and the iOS side involves a podspec and a pod install step. Face detection is the third, because it depends on Apple Vision on one platform and an unbundled Google ML Kit module on the other, so an OS or Play Services change can affect one platform without touching the other.

The license is MIT, stated in the README badge and present as a LICENSE file at the repository root. MIT is permissive: it allows commercial and closed source use, modification and redistribution, provided the copyright notice and permission notice are retained. That is a description of the license text, not legal advice; if your organization has specific obligations around attribution or dependency review, confirm them with your own counsel.

## Conclusion

Adopt react-native-camera-kit if your app needs a native preview, photo capture, QR or barcode scanning or face detection on iOS and Android, and you are willing to manage permissions yourself with react-native-permissions. Do not adopt it if you need a JavaScript-controlled preview pipeline, GPU filters or frame processors, since the README documents no such API. Before writing code, verify that the Kotlin configuration in your Android project matches docs/kotlin.md, that your target devices are Play Store devices if you use face detection, and that you are prepared to write the NSCameraUsageDescription and NSPhotoLibraryUsageDescription entries in Info.plist, because omitting any of these produces a black preview or a failed build rather than a clear runtime error.

## FAQ

### Is React Native still a good choice in 2026 for a camera screen?

The repository does not make a general claim about React Native. What the README shows is that react-native-camera-kit targets React Native above 0.60 and wraps native camera code on iOS and Android, so the camera preview itself runs in Swift and Kotlin rather than in JavaScript.

### Can React Native use Vision Camera to detect faces?

The README does not document react-native-vision-camera's face detection. For react-native-camera-kit, face detection is enabled with faceDetectionEnabled, uses Apple Vision on iOS and Google ML Kit on Android, and reports faces through onFaceDetected.

### Is React Native only for phones?

The README does not discuss target hardware beyond platforms. It states that Android face detection requires a Google Play Store device, and that camera preview is supported in the iOS simulator, which is the only non-phone environment the documentation mentions.

## Sources

- [Issues](https://github.com/teslamotors/react-native-camera-kit/issues)
- [License: MIT](https://github.com/teslamotors/react-native-camera-kit/blob/master/LICENSE)
- [README](https://github.com/teslamotors/react-native-camera-kit/blob/master/README.md)
- [Releases](https://github.com/teslamotors/react-native-camera-kit/releases)
- [teslamotors/react-native-camera-kit on GitHub](https://github.com/teslamotors/react-native-camera-kit)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/teslamotors-react-native-camera-kit