To check Python with Ruff online, paste your code into a browser-based Ruff playground: it runs ruff check through WebAssembly and lists every issue with its rule code, line and column, and whether it's auto-fixable — nothing installs and nothing uploads. On my messy test file, Ruff 0.16.2 flagged 8 errors and marked 5 as auto-fixable in well under a second.
ruff check is the command most people mean by "running Ruff" — it's the linter that reads your Python and reports problems, from unused imports to deprecated typing. You don't need to install anything to try it: our Ruff Playground runs the exact same engine in your browser. But I wanted to show what "checking Ruff online" actually gives you, so I ran the real tool on a deliberately messy file and captured every line of output.
Everything below is real output from Ruff 0.16.2 — the same version the online playground runs.
What does `ruff check` do?
ruff check is Ruff's linter: it parses your Python and flags issues — unused imports (F401), un-sorted imports (I001), deprecated patterns (UP…), likely bugs (B…), and hundreds more — each tagged with a rule code so you can look it up or silence it. It's the counterpart to ruff format (which only restyles code). Ruff is written in Rust, so a check that takes Flake8 seconds finishes in milliseconds.
You can run every command in this article live, with no install, in the Ruff Playground — paste your code and the Diagnostics tab is ruff check. It also shows the formatted output, AST, tokens and formatter IR.
How to check Ruff online, step by step
- Open the Ruff Playground — it loads the official Ruff WebAssembly build in your browser.
- Paste or type your Python into the editor. Linting runs live as you type.
- Read the Diagnostics tab: every issue shows its rule code, line:column, and a
[*]marker if Ruff can auto-fix it. - Open Settings to edit the config as JSON — the same fields as
[tool.ruff]inpyproject.toml(select,ignore,line-length). - Switch tabs to also see the Formatted output (
ruff format), the AST, Tokens, or the Formatter IR.
That's the whole loop. Nothing is uploaded — the check runs on your machine — so you can safely paste proprietary code. Locally, the same command is ruff check path/to/file.py after pip install ruff (or uv add ruff).
Real test: running `ruff check` on a messy file
Here's the file I used — intentionally sloppy, the kind of thing that accumulates in a real codebase:
import os, sysimport jsonfrom typing import Listdef load(path):f = open(path)data = json.load(f)names: List[str] = data['names']result = []for i in range(len(names)):result.append(names[i].upper())unused = 42return resultx=load('data.json')print( x )
Running ruff check messy.py --select E,F,I,UP,B,SIM gives this — real, unedited output:
messy.py:1:1: E401 [*] Multiple imports on one linemessy.py:1:1: I001 [*] Import block is un-sorted or un-formattedmessy.py:1:8: F401 [*] `os` imported but unusedmessy.py:1:12: F401 [*] `sys` imported but unusedmessy.py:3:1: UP035 `typing.List` is deprecated, use `list` insteadmessy.py:6:9: SIM115 Use a context manager for opening filesmessy.py:8:12: UP006 [*] Use `list` instead of `List` for type annotationmessy.py:12:5: F841 Local variable `unused` is assigned to but never usedFound 8 errors.[*] 5 fixable with the `--fix` option (1 hidden fix can be enabled with the `--unsafe-fixes` option).
Eight issues from sixteen lines. Notice the [*] markers — those five are auto-fixable. The playground shows the same list in its Diagnostics tab, with the [*] rendered as a fixable badge.
Auto-fixing with `ruff check --fix`
Add --fix and Ruff rewrites the safe issues in place. On my file:
Found 8 errors (6 fixed, 2 remaining).
Six gone in one pass. The two left (SIM115, the file opened without a context manager, and the hidden unsafe fix) need a human decision — Ruff won't guess there. The import block collapsed and sorted itself down to just what's used:
import jsondef load(path):f = open(path)data = json.load(f)
os and sys (unused) were deleted, the import block was sorted, and List[str] became list[str] — the modern PEP 585 form. That's F401 + I001 + UP006 all resolved automatically.
Formatting too: `ruff format`
ruff check finds problems; ruff format fixes *style*. They're separate commands (and separate tabs in the playground). Real before/after on a badly-spaced snippet:
def add(a,b) :return a+bx = { "k":1,"y":2 }
def add(a, b):return a + bx = {"k": 1, "y": 2}
Same output you'd get from Black on most files — see Ruff format vs Black for where they differ. In the playground, this is the Formatted tab.
Reading Ruff's rule codes
Every diagnostic starts with a letter-prefixed code. The prefix tells you which family (and which flake8 plugin it replaces):
| Code | Means | From my test |
|---|---|---|
F401 | Imported but unused | os, sys |
I001 | Import block un-sorted (isort) | the import lines |
E401 | Multiple imports on one line | import os, sys |
UP006 / UP035 | Outdated typing (pyupgrade) | List → list |
SIM115 | Open file without a context manager | open(path) |
F841 | Local variable assigned but never used | unused = 42 |
You control which families run with select/ignore in the config — E/F (pyflakes + pycodestyle) are the sane default; add I, UP, B, SIM for import sorting, upgrades, bug-bears and simplifications. Edit these live in the playground's Settings panel.
Online vs `pip install ruff`
Checking Ruff online is perfect for a quick look — trying a rule, sharing a reproducible snippet, or checking code on a machine where you can't install anything. For day-to-day work you'll want it local (pip install ruff or uv add ruff) and wired into your editor and CI, so ruff check and ruff format --check run on every save and every push. The rules and output are identical; the online playground just skips the install.
Migrating from Flake8/Black? Ruff replaces both (plus isort and pyupgrade). See Ruff vs Flake8 & Black for the real benchmark.
Check Ruff online — free, in your browser
Paste your Python into the Ruff Playground and run ruff check live: diagnostics, formatting, AST and tokens, with an editable config. Nothing uploaded.
Open the Ruff PlaygroundFree tools mentioned here
Related guides
Frequently asked questions
How do I check Ruff online?
Open the Ruff Playground, paste your Python, and read the Diagnostics tab — it runs ruff check live in your browser via WebAssembly and lists every issue with its rule code, line and column, and whether it's auto-fixable. Nothing installs and nothing is uploaded.
What does ruff check do?
ruff check is Ruff's linter. It parses your Python and reports issues — unused imports (F401), un-sorted imports (I001), deprecated typing (UP035/UP006), likely bugs (B), and hundreds more — each tagged with a rule code. Add --fix to auto-correct the safe ones.
Can I run python ruff check without installing Ruff?
Yes. The online Ruff Playground loads the official Ruff WebAssembly build, so pasting code is the same as running ruff check locally — same rules, same diagnostics — with no pip install and no server round-trip. For daily use, install it (pip install ruff / uv add ruff) and run it in your editor and CI.
How do I auto-fix issues Ruff finds?
Run ruff check --fix to rewrite the safe issues in place. On my 8-error test file, --fix resolved 6 in one pass (unused imports removed, import block sorted, List→list); the remaining 2 needed a human decision. --unsafe-fixes enables riskier rewrites you should review.
Which version of Ruff does the online playground use?
Ruff 0.16.2 — the same version used in the tests in this article. It runs entirely in your browser (WebAssembly), so linting, formatting and parsing all happen locally and your code never leaves your machine.