ReactError Fix2026 Updated

React Context Not Updating— Fixed [2026]

Also covers: useContext returns undefined · context value not changing · memo blocking updates

January 20266 min readReact 18 · Next.js

⚡ Complete Working Context Pattern

context/ThemeContext.jsx
import { createContext, useContext, useState, useMemo } from 'react'

const ThemeContext = createContext(null)

export function ThemeProvider({ children }) {
  const [theme, setTheme] = useState('light')
  const value = useMemo(() => ({ theme, setTheme }), [theme])
  return <ThemeContext.Provider value={value}>{children}</ThemeContext.Provider>
}

export function useTheme() {
  const ctx = useContext(ThemeContext)
  if (!ctx) throw new Error('useTheme must be inside ThemeProvider')
  return ctx
}

Why Context Does Not Update Consumers

React context triggers re-renders in consumers only when the value prop on the Provider changes by reference. Same reference = no re-render. Most context problems are caused by wrong tree structure, mutating state directly, or unstable value references.

1

Wrap Consumers Inside the Provider

useContext returns undefined — component outside tree
1 min
app.jsx
// ❌ WRONG — UserProfile is outside the Provider
function App() {
  return (
    <div>
      <UserProfile />        {/* cannot access context — undefined! */}
      <UserProvider>
        <Dashboard />
      </UserProvider>
    </div>
  )
}

// ✅ CORRECT — Provider wraps all consumers
function App() {
  return (
    <UserProvider>
      <UserProfile />        {/* ✅ has access */}
      <Dashboard />          {/* ✅ has access */}
    </UserProvider>
  )
}
2

Pass State (Not Plain Object) as Value

Context never updates — static value
2 min
context/CounterContext.jsx
import { createContext, useContext, useState } from 'react'

const CounterContext = createContext(null)

// ❌ WRONG — static object, never changes
export function CounterProvider({ children }) {
  const count = 0
  return <CounterContext.Provider value={{ count }}>{children}</CounterContext.Provider>
}

// ✅ CORRECT — useState triggers re-renders when count changes
export function CounterProvider({ children }) {
  const [count, setCount] = useState(0)
  return (
    <CounterContext.Provider value={{ count, setCount }}>
      {children}
    </CounterContext.Provider>
  )
}

// Consumers
function CounterDisplay() {
  const { count } = useContext(CounterContext)
  return <p>{count}</p>  // re-renders when count changes
}

function IncrementButton() {
  const { setCount } = useContext(CounterContext)
  return <button onClick={() => setCount(c => c + 1)}>+1</button>
}
3

Never Mutate the Context Value Directly

Mutation does not trigger re-render
2 min
component.jsx
// ❌ WRONG — mutation does not change reference → no re-render
const { user } = useContext(UserContext)
user.name = 'John'   // mutates the object — React does not see this

// ✅ CORRECT — replace via setter function from context
const { user, setUser } = useContext(UserContext)
setUser(prev => ({ ...prev, name: 'John' }))  // new object → re-render

// ✅ In the Provider — always use setState for updates
export function UserProvider({ children }) {
  const [user, setUser] = useState({ name: 'Guest', role: 'viewer' })
  return <UserContext.Provider value={{ user, setUser }}>{children}</UserContext.Provider>
}
4

Memoize Context Value With useMemo

Prevent unnecessary consumer re-renders
2 min

Without memoization, a new value object is created on every parent render, causing all consumers to re-render even if the context data has not changed.

context/AuthContext.jsx
import { createContext, useState, useMemo } from 'react'

const AuthContext = createContext(null)

export function AuthProvider({ children }) {
  const [user, setUser] = useState(null)
  const [loading, setLoading] = useState(true)

  // ❌ Without useMemo — new object every render → all consumers re-render
  // return <AuthContext.Provider value={{ user, setUser, loading }}>

  // ✅ With useMemo — only re-renders consumers when user or loading changes
  const value = useMemo(
    () => ({ user, setUser, loading }),
    [user, loading]
  )

  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>
}
5

One createContext() Per Context — No Duplicates

Two different context objects — import mismatch
1 min
context/UserContext.js
// ❌ WRONG — createContext() in two files creates two DIFFERENT contexts
// fileA.js: export const UserCtx = createContext(null)
// fileB.js: export const UserCtx = createContext(null)  ← different object!
// Provider uses fileA, consumer imports fileB → never connected

// ✅ CORRECT — one file, one createContext(), export everywhere
// context/UserContext.js
export const UserContext = createContext(null)

// Provider file imports from context/UserContext.js
// Consumer files import from context/UserContext.js
// All use the SAME context object

Complete Working Context Pattern

context/AppContext.jsx
import { createContext, useContext, useState, useCallback, useMemo } from 'react'

// 1. Create context
const AppContext = createContext(null)

// 2. Provider — owns the state
export function AppProvider({ children }) {
  const [user, setUser]     = useState(null)
  const [theme, setTheme]   = useState('light')

  const login  = useCallback((userData) => setUser(userData), [])
  const logout = useCallback(() => setUser(null), [])
  const toggleTheme = useCallback(() => setTheme(t => t === 'light' ? 'dark' : 'light'), [])

  const value = useMemo(
    () => ({ user, theme, login, logout, toggleTheme }),
    [user, theme, login, logout, toggleTheme]
  )

  return <AppContext.Provider value={value}>{children}</AppContext.Provider>
}

// 3. Custom hook with guard
export function useApp() {
  const ctx = useContext(AppContext)
  if (!ctx) throw new Error('useApp must be used inside AppProvider')
  return ctx
}

// 4. Usage
function NavBar() {
  const { user, logout, toggleTheme } = useApp()
  return (
    <nav>
      <span>{user?.name ?? 'Guest'}</span>
      <button onClick={toggleTheme}>Toggle Theme</button>
      {user && <button onClick={logout}>Logout</button>}
    </nav>
  )
}

Prevention

Frequently Asked Questions

Why is React context not updating consumers?+
Context consumers only re-render when the context value reference changes. The three most common causes: 1) The consumer is not inside the Provider in the component tree, 2) You are mutating the context object instead of replacing it with setState, 3) A value object literal is created fresh every render but its contents did not change — use useMemo to stabilise.
useContext returns undefined — how to fix?+
The component calling useContext is not wrapped inside the matching Provider. Move the Provider higher in the tree so it is an ancestor of all components that need the context. Also verify you are importing the same context object in both the Provider file and consumer files.
Context updates but component does not re-render?+
React compares context value by reference. If you write <MyCtx.Provider value={{ count, setCount }}> directly, it creates a new object on every render but React may optimise away the update if contents appear the same. Use useMemo: const value = useMemo(() => ({ count, setCount }), [count]).
How do I update context from a child component?+
Include the state setter in the context value: const [user, setUser] = useState(null); return <UserCtx.Provider value={{ user, setUser }}>{children}</UserCtx.Provider>. Children call setUser from useContext to update the shared state.
Should I use React Context or Zustand/Redux for state?+
Context is best for low-frequency updates — theme, locale, auth session. For high-frequency updates (form inputs, real-time data), use Zustand, Jotai, or Redux Toolkit. Every context update re-renders all consumers, which can cause performance problems at high frequency.
Can I have multiple Providers?+
Yes. You can nest multiple Providers for different concerns: <ThemeProvider><AuthProvider><LanguageProvider>{children}</LanguageProvider></AuthProvider></ThemeProvider>. Each context is independent. Components use only the context they need.

Need Expert Help?

We Build Production-Grade React Apps

Softplix builds full-stack React and Next.js applications. Need help with state management or context architecture? We can help.

Talk to an Engineer