Skip to content
Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
Go to file
Cannot retrieve contributors at this time
title description nav
Migrating to Jotai v2 API
New "Async" API

RFC: #1514

Jotai v1 is released at June 2022, and there has been various feedbacks. React also proposes first-class support for promises. Jotai v2 will have a new API.

Unfortunately, there are some breaking changes along with new features.

What are new features

Vanilla library

Jotai comes with vanilla (non-React) functions and React functions separately. They are provided from alternate entry points like jotai/vanilla.

Store API

Jotai exposes store interface so that you can directly manipulate atom values.

import { createStore } from 'jotai' // or from 'jotai/vanilla'

const store = createStore()
store.set(fooAtom, 'foo')

console.log(store.get(fooAtom)) // prints "foo"

const unsub = store.sub(fooAtom, () => {
  console.log('fooAtom value in store is changed')
// call unsub() to unsubscribe.

You can also create your own React Context to pass a store.

More flexible atom write function

The write function can accept multiple arguments, and return a value.

  (get) => get(...),
  (get, set, arg1, arg2, ...) => {
    return someValue

What are breaking

Async atoms are no longer special

Async atoms are just normal atoms with promise values. Atoms getter functions don't resolve promises. On the other hand, useAtom hook continues to resolve promises.

Writable atom type is changed (TypeScript only)

// Old
WritableAtom<Value, Arg, Result extends void | Promise<void>>

// New
WritableAtom<Value, Args extends unknown[], Result>

In general, we should avoid using WritableAtom type directly.

Some functions are dropped

  • Provider's initialValues prop is removed, because store is more flexible.
  • Provider's scope props is removed, because you can create own context.
  • abortableAtom util is removed, becuase the feature is included by default
  • waitForAll util is removed, because Promise.all just works

Migration guides

Async atoms

get function for read function of async atoms doesn't resolve promises, so you have to put await.

In short, the change is something like the following. (If you are TypeScript users, types will tell where to changes.)

Previous API

const asyncAtom = atom(async () => 'hello')
const derivedAtom = atom((get) => get(asyncAtom).toUppercase())


const asyncAtom = atom(async () => 'hello')
const derivedAtom = atom(async (get) => (await get(asyncAtom)).toUppercase())

Provider's initialValues prop

Previous API

const countAtom = atom(0)

  <Provider initialValues={[[countAtom, 1]]}>


const countAtom = atom(0)
const store = createStore()
store.set(countAtom, 1)

  <Provider store={store}>

Provider's scope prop

Previous API

const myScope = Symbol()

  // Parent component
  <Provider scope={myScope}>

  // Child component
  useAtom(..., myScope)


const MyContext = createContext()
const store = createStore()

  // Parent component
  <MyContext.Provider value={store}>

  // Child Component
  const store = useContext(MyContext)
  useAtom(..., { store })

abortableAtom util

You no longer need the previous abortableAtom util, because it's now supported with the normal atom.

Previous API

const asyncAtom = abortableAtom(async (get, { signal }) => {


const asyncAtom = atom(async (get, { signal }) => {

waitForAll util

You no longer need the previous waitForAll util, because we can use native Promise APIs.

Previous API

const allAtom = waitForAll([fooAtom, barAtom])


const allAtom = atom((get) => Promise.all([get(fooAtom), get(barAtom)]))

Some other changes


  • atomWithStorage util's delayInit is removed as being default.
  • useHydrateAtoms can only accept writable atoms.

Import statements

The v2 API is also provided from alternate entry points for library authors and non-React users.

  • jotai/vanilla
  • jotai/vanilla/utils
  • jotai/react
  • jotai/react/utils
// Available since v1.11.0
import { atom } from 'jotai/vanilla'
import { useAtom } from 'jotai/react'

// Available since v2.0.0
import { atom } from 'jotai' // is same as 'jotai/vanilla'
import { useAtom } from 'jotai' // is same as 'jotai/react'