# react-native-image-crop-picker: gallery, camera and cropper in one native module

> A React Native library that wraps native iOS and Android pickers, adds configurable compression and an in-app cropper. It is MIT licensed, still receiving pushes as of 2026-09-25, and version 0.50.0 or later is required for the new architecture.

**ivpusic/react-native-image-crop-picker** — iOS/Android image picker with support for camera, video, configurable compression, multiple images and cropping

- Repository: https://github.com/ivpusic/react-native-image-crop-picker
- Stars: 6,350 · Forks: 1,610
- Language: Objective-C
- License: MIT
- Published: 2026-09-28 · Updated: 2026-09-28 · Language: en
- Canonical page: https://hysenlabs.com/projects/ivpusic-react-native-image-crop-picker

## The gap react-native-image-crop-picker fills

A plain React Native app has no built-in way to open the system photo library, take a picture, or let the user crop the result. Each of those steps normally means writing platform code twice: a UIImagePickerController or PHPickerViewController on iOS, an intent plus an Activity result on Android. react-native-image-crop-picker packages all of that behind a JavaScript API. The README describes it as an "iOS/Android image picker with support for camera, video, configurable compression, multiple images and cropping", and the repository layout backs that up: an ios/ directory, an android/ directory, a podspec, and a single index.js entry point with TypeScript types in index.d.ts.

The intended user is an app developer who needs more than a file chooser. Cropping with a fixed output size, circular masks, multiple selection with a maxFiles cap, and base64 output are all options on the same request object. If your requirement is "let the user pick a photo and show it", the native module is more machinery than you need. If your requirement is "let the user pick, crop to 300 by 400, and hand me a path or a base64 string", the library exists for exactly that.

## How the picker, cropper and cleanup flow works

The JavaScript side is thin. index.js exposes an ImagePicker object with openPicker, openCamera, openCropper and clean methods, and each returns a promise. The work happens in the native modules under ios/ and android/, which is why the package declares react-native as a peer dependency rather than bundling a JS implementation.

Calling openPicker opens the native gallery. If cropping is true, the user is moved into the native crop screen before the promise resolves, so the object you receive already reflects the crop. openCamera follows the same path with the camera as the source. openCropper skips selection entirely and crops a path you already have. The resolved object carries the file path plus, when requested, base64 data and EXIF data.

One piece of state you should know about is the temporary file directory. The README states that the module creates tmp images "which are going to be cleaned up automatically somewhere in the future". That is not a guarantee about when. The library therefore exposes clean() to remove all tmp files and cleanSingle(path) to remove one. If your app crops repeatedly in a long session, those files accumulate until something removes them.

Compression is not a separate call. The width and height properties, documented as the "width of result image when used with cropping option", drive the output size, and the request object also exposes includeBase64, includeExif and an iOS-only writeTempFile flag that skips writing files to disk when you only need the base64 payload.

## Installing react-native-image-crop-picker and a first crop

The README shows the import and the call, not a full install command, so start from the package name exactly as published. The package.json declares the name react-native-image-crop-picker at version 0.51.1, and the repository ships an RNImageCropPicker.podspec for CocoaPods, which is what an iOS build will consume after you install the npm package and run pod install in your ios/ directory.

```bash
npm install react-native-image-crop-picker
```

The README's first example is a single pick with cropping enabled and a fixed output size. The promise resolves with an image object, which the example logs.

```javascript
import ImagePicker from "react-native-image-crop-picker";

ImagePicker.openPicker({
  width: 300,
  height: 400,
  cropping: true,
}).then((image) => {
  console.log(image);
});
```

For a multi-select flow, the README uses the multiple flag without a size, since cropping applies to a single result. The maxFiles property defaults to 5 and minFiles to 1.

```javascript
ImagePicker.openPicker({
  multiple: true,
}).then((images) => {
  console.log(images);
});
```

When you are done with temporary files, the README's cleanup call removes them from the tmp directory.

```javascript
ImagePicker.clean()
  .then(() => {
    console.log("removed all tmp images from tmp directory");
  })
  .catch((e) => {
    alert(e);
  });
```

After the first crop, the resolved object is your source of truth: read the path for uploads, or read data when includeBase64 is set. There is no test script in this package; package.json maps test to a command that exits with an error, so verification is manual on a device or simulator.

## Android edge cases the README warns about

The documentation lists two Android problems plainly. The first concerns video: "The prop 'cropping' has been known to cause videos not to be displayed in the gallery on Android. Please do not set cropping to true when selecting videos." That is a hard constraint on the API surface, not a preference. If your screen lets users choose either photos or videos and you set cropping globally, expect the video path to misbehave on Android.

The second is the new architecture. The README states that if you use the React Native new architecture you must use version 0.50.0 or later. The package.json codegenConfig block, naming RNCImageCropPickerSpec and pointing at the src directory with the Java package com.reactnative.ivpusic.imagepicker, is the TurboModule scaffolding that requirement refers to. If you are pinned to an older release for other reasons, the new architecture is not available to you.

Beyond those, the trade-off is structural. This is a native module, so anything that changes how native code is linked will affect it: a bare workflow upgrade, a CocoaPods change, an Android Gradle bump. The README does not document rollback or a migration path between major versions, and there is no changelog in the repository listing beyond the release tags. Treat version upgrades as a change that needs a device test on both platforms.

## Alternatives: expo-image-picker and a picker plus a resizer

The most common alternative is expo-image-picker. The difference in approach is where the native code lives. expo-image-picker is part of the Expo SDK, so in a managed Expo project you add it through the Expo tooling and the native side is handled by the Expo runtime. react-native-image-crop-picker is a standalone native module that you link yourself and that declares react-native as a peer dependency. The README gives no Expo installation instructions, so if your project is managed Expo, this library is not the path of least resistance. What you gain by linking it yourself is direct control over the iOS and Android implementations in this repository, and the cropper that ships with it.

A second pattern is composing two libraries: a picker for selection and a separate resizer for output dimensions. The search data around this project includes React-native-image-resizer, which is the kind of package that pattern uses. The trade-off is that you get cropping as a separate step or not at all, and you own the wiring between the two. react-native-image-crop-picker folds selection, cropping and sizing into one promise, which is fewer moving parts but also fewer places to swap out a piece you dislike.

## Maintenance, licence and upgrade cost

The repository is not archived, and the last push was on 2026-09-25, which is recent. Releases are tagged rather than only committed: v0.51.1 on 2025-10-21, v0.51.0 on 2025-08-08 and v0.50.0 on 2025-05-29. The version in package.json matches v0.51.1, so the published package and the latest tag line up. That pattern suggests fixes arrive as tagged releases rather than floating on master, which is easier to reason about when you pin a version.

The licence is MIT, declared in package.json and present as a LICENSE file at the repository root. MIT is permissive: you can use the code in closed-source apps. That is a statement about the licence text, not legal advice, and the practical obligation is to keep the copyright notice with any distribution of the code. The repository also carries an Open Collective badge set in the README, so funding exists outside the licence, but that has no bearing on what you may do with the code.

Upgrade cost is dominated by the native surface. Because the library is Objective-C on iOS and Java on Android behind a JS API, a React Native upgrade that changes native linking can require changes here even when the JS API is unchanged. The new-architecture floor of 0.50.0 is the clearest example in the README: the version you can use depends on the React Native version you run.

## Conclusion

Adopt it if you need native cropping, configurable compression and multi-select in one module and you can accept manual native linking plus the Android edge-to-edge and video caveats. Do not adopt it if you want a managed Expo workflow, because the README gives no Expo install path, or if you only need a simple picker and would rather avoid a native module. Verify first that your React Native version matches the new-architecture requirement of 0.50.0 or later, and check the properties table in the README against the exact options you plan to pass.

## FAQ

### How do I use react-native-image-crop-picker to pick an image?

Import the default export and call openPicker with a request object, then read the resolved image. The README's first example passes width, height and cropping, and logs the result.

### Can react-native-image-crop-picker crop images?

Yes. Setting cropping to true on openPicker or openCamera moves the user into the crop screen before the promise resolves, and openCropper crops a path you already have. width and height set the output size when cropping is enabled.

### What is an image picker in React Native?

It is the component that opens the device's photo library or camera and returns the chosen file to your app. react-native-image-crop-picker implements that on top of the native iOS and Android pickers and adds cropping and compression options.

## Sources

- [Issues](https://github.com/ivpusic/react-native-image-crop-picker/issues)
- [ivpusic/react-native-image-crop-picker on GitHub](https://github.com/ivpusic/react-native-image-crop-picker)
- [License: MIT](https://github.com/ivpusic/react-native-image-crop-picker/blob/master/LICENSE)
- [README](https://github.com/ivpusic/react-native-image-crop-picker/blob/master/README.md)
- [Releases](https://github.com/ivpusic/react-native-image-crop-picker/releases)

---

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