This React Native accessibility guide gives you a reusable release checklist for labels, focus order, Dynamic Type, VoiceOver, TalkBack, keyboard navigation, contrast, and touch targets. Use it when adding a screen, changing a shared component, or testing a new iOS or Android release.
Overview
Accessibility in React Native is not a final polish step. It is a combination of semantic information, predictable navigation, readable layout, sufficient contrast, and interaction methods that do not depend on sight, precise tapping, or a particular input device. A screen can look correct in a simulator and still be difficult to use with VoiceOver, TalkBack, larger text, an external keyboard, or common motor-accessibility settings.
Start by defining what each control does, then expose that meaning through React Native accessibility props. A useful component should communicate its role, name, state, value, and available action. It should also remain usable when text grows or when a screen reader changes the order and timing of interaction.
The core props are:
| Prop | Use it for | Review question |
|---|---|---|
accessible | Making a view an accessibility element on supported platforms | Should this view be announced as one control, or should its children be read separately? |
accessibilityLabel | A concise name for an image, icon, or custom control | Would a person understand the control without seeing it? |
accessibilityRole | Describing a button, link, header, image, switch, checkbox, and other semantic roles | Does the announced role match the available action? |
accessibilityHint | Explaining the result of an action when the result is not obvious | Is a hint needed, or would it repeat the label? |
accessibilityState | Exposing disabled, selected, checked, busy, or expanded state | Does the spoken state update when the UI changes? |
accessibilityValue | Providing a value or range for controls such as sliders | Can the current value and its meaning be understood? |
accessibilityActions | Defining custom actions for controls that support more than a tap | Can a screen-reader user perform every important action? |
importantForAccessibility and platform-specific props | Controlling visibility or grouping behavior, particularly on Android | Are decorative or duplicate elements being announced? |
Use the native platform behavior as your baseline. React Native abstracts much of the implementation, but VoiceOver and TalkBack do not behave identically. Verify important flows on both platforms rather than assuming that one successful test covers the other.
Checklist by scenario
Buttons, links, and icon-only controls
- Use a native or semantically appropriate pressable component instead of making a generic
Viewclickable. - Give an icon-only control a specific label such as “Open filters” or “Remove saved item,” not “button” or the icon name.
- Set
accessibilityRoleto match the interaction. A control that toggles a setting should expose its current state throughaccessibilityState. - Make disabled controls genuinely disabled in both behavior and announced state. Do not only reduce opacity.
- Keep the touch target generous. A practical review baseline is approximately 44 points on iOS and 48 density-independent pixels on Android, while ensuring nearby targets do not overlap.
Forms, validation, and authentication
- Give every input a visible, persistent label. Do not rely on placeholder text as the only label.
- Set the appropriate input semantics, keyboard type, text-content type, and secure-entry behavior for the field.
- Associate validation feedback with the relevant field in the visual layout and in the accessibility announcement. Explain what must change, not only that the value is invalid.
- Do not clear a user’s entered value merely because validation fails.
- For authentication, expose loading, error, and success states without making a screen reader user guess whether submission completed. The React Native authentication guide covers the broader session and security workflow.
Lists, cards, and repeated content
- Decide whether a card is one actionable element or a group of independent controls. Avoid announcing the same title, metadata, and button multiple times.
- Provide meaningful labels for status indicators, favorite controls, download actions, and overflow menus.
- Preserve a logical order: heading, primary information, status, then actions.
- When content changes, update the relevant state or announce a concise result. Do not repeatedly announce an entire long list for a small update.
Navigation, dialogs, and dynamic screens
- Give each screen a clear heading and ensure the initial focus lands on a sensible element rather than a decorative view.
- When opening a modal or alert, keep interaction within the active surface according to the platform’s expected behavior, identify the dialog, and provide an obvious close action.
- When closing a modal, return focus to the control that opened it when that is practical.
- Do not use a visual animation as the only indication that navigation completed. Announce or expose the new screen’s heading and state through its structure.
- For complex custom focus behavior, test the actual native build. Focus APIs and platform-specific props can behave differently in development builds, production builds, VoiceOver, and TalkBack.
Text size, contrast, and orientation
- Allow text to scale unless there is a documented, tested reason not to. Review
allowFontScalingand anymaxFontSizeMultiplierlimits deliberately. - Avoid fixed-height text containers. Let labels wrap, and test long translations and large text settings.
- Do not communicate meaning with color alone. Pair color with text, an icon with a label, a pattern, or another clear cue.
- Check normal, disabled, focused, pressed, error, and selected states for adequate contrast under the team’s accessibility standard.
- Test portrait and landscape layouts if the app supports both, including large text and split-screen or reduced-width environments where applicable.
Keyboard and motor access
- Ensure the primary flow does not require precise swipes or rapid gestures when an equivalent tap or control is possible.
- Review external-keyboard navigation on supported devices. Focus should move in a predictable visual and logical sequence.
- Avoid controls that activate only on a narrow gesture or require simultaneous actions without an accessible alternative.
- Respect reduced-motion preferences where animations could create discomfort or obscure state changes. Keep transitions informative but not required for understanding.
What to double-check
Focus-order workflow
- Draw the intended reading and interaction order before changing code: heading, context, primary action, content, secondary actions.
- Inspect the React component tree and remove decorative elements from the accessibility tree where appropriate.
- Group content only when it should be announced as one unit. Over-grouping can hide useful controls; under-grouping can create a long, repetitive announcement.
- Open menus, sheets, alerts, and forms with a screen reader enabled. Confirm where focus starts, what can be reached, and where focus returns after dismissal.
- Repeat the flow after adding loading states, error messages, empty states, and conditional buttons. Conditional rendering often changes order unexpectedly.
Screen-reader test script
Run this short script on a physical iOS device with VoiceOver and an Android device with TalkBack:
- Navigate through the screen sequentially. Can you identify the screen, its purpose, and every actionable control?
- Activate each control without looking. Is the action result clear?
- Change every stateful control. Is selected, checked, expanded, busy, or disabled state announced?
- Submit an invalid form. Can you locate each error and understand the correction?
- Open and close a dialog, menu, or bottom sheet. Does focus remain in a sensible place?
- Increase text size and repeat the flow. Is anything clipped, overlapped, or unreachable?
- Try the flow with touch exploration, gestures, and an external keyboard where relevant.
Automated tests can verify that important elements have labels, roles, and states, but they cannot replace a real screen-reader pass. Add accessibility assertions to your component and end-to-end suites, then retain manual testing for focus, announcements, gestures, and layout. See the React Native testing strategy for a broader test-layer plan.
Common mistakes
- Adding labels to everything: A label on a decorative image or wrapper can create duplicate announcements. Hide decorative content or let the meaningful parent describe it.
- Using visible text as a complete accessibility strategy: Text does not automatically provide the correct role, state, focus behavior, or action result.
- Using an icon name as a label: “Chevron right” describes an asset, not what the user can do. Prefer “Open order details,” for example.
- Fixing clipping by shrinking text: Large text is a supported use case. Rework layout, wrapping, scrolling, and spacing before limiting scaling.
- Testing only with a simulator: Hardware, OS settings, keyboard behavior, and screen-reader gestures can expose issues that a visual simulator does not.
- Announcing every state change: Excessive announcements interrupt reading and make a screen harder to use. Announce only meaningful updates, such as a completed save or a focused validation error.
- Ignoring native and permission flows: Camera, notification, location, and biometric prompts have platform-owned accessibility behavior, but your surrounding explanation and fallback state still need labels and clear instructions. Use the React Native permissions guide and push notifications guide when auditing those flows.
When to revisit
Repeat this audit before each release candidate and whenever a shared component, navigation structure, native module, or operating-system target changes. Recheck it when introducing a new design system, localization, authentication method, notification flow, or device permission. Accessibility behavior can also change when React Native, Expo, a UI library, or a native dependency changes, so include screen-reader checks in dependency and tooling upgrades rather than treating them as unrelated maintenance.
Keep a small release worksheet for every important screen:
- VoiceOver and TalkBack tested on supported OS versions.
- Every interactive element has an appropriate name, role, and state.
- Focus order and modal return focus are verified.
- Large text does not clip or hide actions.
- Contrast, touch targets, keyboard navigation, and reduced-motion behavior are reviewed.
- Validation, loading, empty, offline, and error states are accessible.
- Automated accessibility assertions pass, and manual findings have owners.
Record the device, OS, React Native or Expo version, screen-reader setting, and result for each test. When a check fails, reproduce it in a minimal screen, fix the shared component if possible, and add a regression test. This turns accessibility from a one-time audit into a practical part of React Native app development. For related release checks, connect this review with your React Native CI/CD workflow and production error triage process.