Keyboard Shortcut to Go Back in Chrome: A Practical 2026 Guide

Master the fastest keyboard shortcut to go back in Chrome on Windows and macOS. This comprehensive guide covers cross-platform mappings, code examples, testing tips, and best practices for reliable browser navigation.

Shortcuts Lib Team

March 16, 2026·5 min read

Keyboard Shortcuts Windows Shortcuts Chrome Shortcuts Mac Shortcuts

Chrome Back Shortcut - Shortcuts Lib — Photo by Zulfugar Karimov on Unsplash

Quick AnswerDefinition

The keyboard shortcut to go back in Chrome is platform-specific. On Windows and Linux, press Alt+Left Arrow or Backspace to navigate to the previous page. On macOS, use Cmd+Left Arrow or Cmd+[, which also goes back. These mappings work in most contexts, making them essential for fast browsing and efficient navigation in Chrome.

Understanding the keyboard shortcut to go back in Chrome

Mastering the keyboard shortcut to go back in chrome is a cornerstone of efficient browsing. This quick operation lets you retrace steps without reaching for the mouse, saving time during research, coding, or testing sessions. The core concept is simple: a backward navigation command maps to a browser action that loads the previous page in history. We’ll explore platform differences, practical code examples for developers, and how to test these shortcuts in real work scenarios. For researchers and developers, this shortcut forms part of a broader set of navigation controls and can be extended or customized in scripts and extensions. Below you’ll find a few concrete demonstrations that tie the user action to a code-level equivalent.

JavaScript

// Simple programmatic back button in a web page
history.back();

JSON

{
  "windows_linux": ["Alt+Left Arrow", "Backspace"],
  "macos": ["Cmd+Left Arrow", "Cmd+[" ]
}

This mapping reinforces how keyboard shortcuts translate into browser history navigation, a pattern useful for UI design and automation.

On Windows and Linux, the standard back shortcut is Alt+Left Arrow, with Backspace serving as an alternative in many contexts, especially when focus is not inside a text field. On macOS, the typical mappings are Cmd+Left Arrow or the symmetric Cmd+[. Understanding these differences helps you design cross‑platform workflows and communicate expectations across teams. The following snippet shows a quick cross‑platform representation and a listener you can reuse in web apps to honor these keys (without interfering with form inputs).

JSON

{
  "windows_linux": ["Alt+Left Arrow", "Backspace"],
  "macos": ["Cmd+Left Arrow", "Cmd+"]
}

JavaScript

// Quick listener to trigger back navigation from anywhere in your web app
document.addEventListener('keydown', (e) => {
  const isBack = (e.altKey && e.key === 'ArrowLeft') || (e.key === 'Backspace' && !e.metaKey);
  if (isBack) history.back();
});

These patterns help you reason about how the same user intent maps to different OS-level shortcuts.

If you’re a developer, you may want to wire a UI button or a keyboard shortcut to the browser history. The history API provides a robust way to implement go back and go forward actions in a controlled way. This section demonstrates a small utility you can drop into a web app to offer a consistent back navigation experience, even when your app runs in a constrained sandbox. You’ll see how to prevent navigation when there’s nothing to go back to, and how to keep the UX predictable for keyboard users.

JavaScript

function safeBack() {
  if (window.history.length > 1) {
    history.back();
  } else {
    console.log('No history to go back to.');
  }
}
// Bind the same function to a custom hotkey in a web app UI
document.getElementById('backButton').addEventListener('click', safeBack);

JavaScript

// Global keyboard shortcut binding for a web app (keeps native browser shortcuts intact)
document.addEventListener('keydown', (e) => {
  const isOurShortcut = (e.altKey && e.key === 'ArrowLeft') || (e.metaKey && e.key === 'ArrowLeft');
  if (isOurShortcut) {
    e.preventDefault();
    safeBack();
  }
});

These examples illustrate how to encapsulate navigation behavior in a reusable fashion while respecting native browser shortcuts.

Testing shortcuts in Chrome DevTools and automation scripts

Testing keyboard shortcuts in a browser environment requires attention to focus, event handling, and the browser’s security model. The tests below show how to verify the behavior with JavaScript, both manually and in automated environments. Start by loading a page sequence so you have a history stack to traverse. Then simulate back navigation via code and manual keypress checks to confirm consistent results across platforms. For automation, you can script browser actions using DevTools protocol or a headless browser to confirm back navigation behavior across different histories and nested frames.

JavaScript

// Manual check: navigate forward and back using history API in DevTools Console
history.forward(); // move to next page if possible
history.back(); // go to previous page

JavaScript

// Simulated keypress in a test environment (note: real key events may be blocked by security policies)
function simulateBackKeypress() {
  const e = new KeyboardEvent('keydown', { key: 'ArrowLeft', altKey: true });
  window.dispatchEvent(e);
  // The browser will handle the event if not prevented
}
simulateBackKeypress();

Cross‑platform tests should verify Alt+Left Arrow and Cmd+Left Arrow behave as expected on Windows/Linux and macOS respectively.

Keyboard navigation is a core accessibility feature. When implementing or documenting shortcuts, ensure you do not conflict with screen reader users or other assistive tech. Avoid overriding standard browser shortcuts in ways that degrade discoverability. Provide visible focus indicators when back navigation is triggered from custom UI, and consider ARIA labels for any on-screen navigation controls. If you expose custom back buttons or hotkeys, document their behavior clearly and provide a fallback using the native browser shortcut so users with different assistive technologies can navigate reliably.

HTML

<button aria-label="Go back" onclick="history.back()">Back</button>

CSS

button:focus {
  outline: 2px solid #1a73e8; /* visible focus outline for accessibility */
}

These practices help ensure your shortcuts are usable by all users, regardless of the interaction mode.

Power users sometimes want to tailor shortcuts beyond the default Chrome mappings. A lightweight approach is to use a user script manager (like Tampermonkey) or a small extension that binds a custom key combination to history.back(). While this increases flexibility, it also requires caution to avoid conflicts with existing shortcuts. The example below shows a minimal user script that binds a chosen key combo to go back, while leaving native shortcuts intact for general use. Test across sites to ensure compatibility and avoid accidental navigation.

JavaScript

// ==UserScript==
// @nameBackShortcut
// @namespace https://example.com
// @version 1.0
// @description Custom back navigation
// ==/UserScript==
document.addEventListener('keydown', (e) => {
  // Custom: Ctrl/Cmd + B to go back
  const isCustom = (e.ctrlKey || e.metaKey) && e.key.toLowerCase() === 'b';
  if (isCustom) {
    e.preventDefault();
    history.back();
  }
});

JSON

{
  "name": "Back Navigator",
  "version": "1.0.0",
  "permissions": ["history", "tabs"],
  "description": "Bind a custom key to go back in Chrome"
}

These patterns empower power users while keeping the core browser behavior intact for general users.

Common pitfalls and how to avoid them

Even seasoned users hit snags when relying on keyboard shortcuts. A frequent pitfall is Backspace acting as a browser navigation if the focus is not in a text field, leading to accidental page loads and data loss. Another pitfall is overriding native shortcuts with custom bindings, which can confuse users. To avoid these issues, always test keyboard bindings in multiple contexts (forms, inputs, and contenteditable regions). Consider providing a global, non-intrusive alternative and keep a fallback to the browser’s built‑in navigation so users can still browse without friction.

JavaScript

// Guarded back navigation that only fires outside form fields
document.addEventListener('keydown', (e) => {
  const inInput = ['INPUT', 'TEXTAREA', 'SELECT'].includes(document.activeElement.tagName);
  const isBack = (e.altKey && e.key === 'ArrowLeft') || (e.key === 'Backspace' && !inInput);
  if (isBack) history.back();
});

HTML

<!-- Accessible on-page control that does not steal native shortcuts -->
<a href="#" onclick="history.back(); return false;" aria-label="Go back">Back</a>

Following these practices reduces unexpected navigation and improves reliability across devices.

Reliability comes from consistency. Use stable mappings that align with platform conventions (Alt+Left Arrow on Windows/Linux and Cmd+Left Arrow on macOS) and avoid overloading your app with multiple shortcuts for the same action. When building web apps or extensions, prefer listening for key combinations rather than mutating the default behavior in a way that degrades performance across tabs. Debounce or throttle handler execution if you implement complex back navigation logic to prevent rapid repeated navigations that could degrade responsiveness.

JavaScript

// Debounced back navigation to avoid multiple rapid triggers
let lastTrigger = 0;
document.addEventListener('keydown', (e) => {
  const now = Date.now();
  const isBack = (e.altKey && e.key === 'ArrowLeft') || (e.key === 'Backspace' && !e.metaKey);
  if (isBack && now - lastTrigger > 250) {
    lastTrigger = now;
    history.back();
  }
});

Bash

# Quick check: ensure you can reproduce the shortcut in a minimal Chrome profile
# Open a simple HTML page and press Alt+Left Arrow to confirm backward navigation works as expected

These practices help ensure the shortcut remains fast and predictable in real-world usage.

Best practices for multi-device workflows: consistency is key

Teams that work across Windows, macOS, and Linux benefit from a consistent mental model of navigation. Document the platform mappings clearly and encourage users to rely on their OS conventions, even when using web apps. If you provide additional shortcuts for advanced workflows, group them logically and avoid duplicating existing browser shortcuts. A well-documented baseline reduces cognitive load and improves collaboration across devices and teams.

YAML

# YAML example: cross-platform shortcut mapping for a team doc
windows_linux:
  back: ["Alt+Left Arrow", "Backspace"]
macos:
  back: ["Cmd+Left Arrow", "Cmd+"]

JSON

{
  "name": "Cross‑Platform Guide",
  "backShortcut": {
    "windows_linux": ["Alt+Left Arrow", "Backspace"],
    "macos": ["Cmd+Left Arrow", "Cmd+"]
  }
}

By aligning practice across devices, you maintain a smooth workflow and reduce friction when navigating Chrome on different machines.

Steps

Estimated time: 10-15 minutes

1
Identify target page
Open a page with a history trail you want to back out of. Ensure the active element is not a form field so Backspace navigation remains predictable. This establishes a baseline for testing the shortcut in real-world browsing.
Tip: Test in incognito or a clean profile to avoid extensions affecting behavior.
2
Trigger back navigation
Use the platform-specific shortcut: Alt+Left Arrow on Windows/Linux or Cmd+Left Arrow on macOS. Observe that Chrome loads the previous page from history. If you use Backspace, verify focus context to avoid accidental navigation.
Tip: If Backspace does not navigate back, try Alt+Left Arrow first.
3
Test forward and edge cases
Navigate back, then use the forward shortcut to return. Test in multiple tabs and across sites with dynamically loaded content. Check behavior when history is limited.
Tip: Ensure there is a history entry before testing to avoid no-op results.
4
Document and share
Record platform-specific mappings and any deviations you observed. Share a quick guide with teammates to align expectations across devices.
Tip: Include accessibility notes for keyboard users.

Pro Tip: Prefer OS-native shortcuts to maximize consistency across apps and minimize surprises.

Warning: Backspace can navigate back when focus is outside input fields; always test focus scenarios.

Note: Cmd+Left Arrow on Mac generally mirrors Windows Alt+Left Arrow for parity.

Pro Tip: When building UI controls, expose a visible, accessible back button in addition to keyboard shortcuts.

Prerequisites

Required

Google Chrome browser (latest stable)↗
Required
Windows or macOS with standard keyboard
Required
Basic keyboard navigation knowledge
Required
Developer Tools knowledge for DevTools testing↗
Required

Optional

Optional: A text editor to test code samples (e.g., VS Code)↗
Optional

Keyboard Shortcuts

Action	Shortcut
Go back one pageApplies in most apps and within Chrome	`Alt`+`Left Arrow, Backspace`
Go forward one pageComplementary navigation in Chrome	`Alt`+`Right Arrow`

Questions & Answers

What is the standard keyboard shortcut to go back in Chrome on Windows?

On Windows, the common shortcut is Alt+Left Arrow, with Backspace as an alternative in many contexts when the focus isn’t in an input field. This reliably navigates to the previous page in Chrome.

What is the Mac equivalent for going back in Chrome?

On macOS, use Cmd+Left Arrow or Cmd+[ to navigate back to the previous page. These are the standard Mac shortcuts that align with Chrome navigation.

Can Backspace ever be used to go back on Mac?

Backspace is less reliable on macOS because it is often used for deleting text within input fields. Prefer Cmd+Left Arrow or Cmd+[ for Mac to avoid conflicts.

How can I customize or extend back navigation safely?

You can bind custom shortcuts via user scripts or extensions, but ensure you don’t override native shortcuts. Provide fallbacks and test across sites to maintain usability and accessibility.

Is history.back() equal to clicking the Back button?

history.back() navigates to the previous entry in the session history, which is effectively the same as clicking the Back button, but can be triggered from scripts, making it useful for programmatic navigation.

What should I do if a shortcut doesn’t work in a particular site?

Some sites prevent or override certain shortcuts with JavaScript. Check site scripts, try a different page, or rely on the browser’s native controls.

Main Points

Know the platform-specific mappings: Windows/Linux Alt+Left Arrow; macOS Cmd+Left Arrow.
Use history.back() for programmatic back navigation in scripts.
Test keyboard shortcuts in real contexts to avoid form-field conflicts.
Document cross-device mappings for team consistency.
Respect native browser shortcuts to preserve accessibility and predictability.