Skip to main content
Guides

How to Check Python with Ruff Online (ruff check, Tested)

By Mithun··7 min read
Quick Answer

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

  1. Open the Ruff Playground — it loads the official Ruff WebAssembly build in your browser.
  2. Paste or type your Python into the editor. Linting runs live as you type.
  3. Read the Diagnostics tab: every issue shows its rule code, line:column, and a [*] marker if Ruff can auto-fix it.
  4. Open Settings to edit the config as JSON — the same fields as [tool.ruff] in pyproject.toml (select, ignore, line-length).
  5. 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, sys
import json
from typing import List
def 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 = 42
return result
x=load('data.json')
print( x )
messy.py — before

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 line
messy.py:1:1: I001 [*] Import block is un-sorted or un-formatted
messy.py:1:8: F401 [*] `os` imported but unused
messy.py:1:12: F401 [*] `sys` imported but unused
messy.py:3:1: UP035 `typing.List` is deprecated, use `list` instead
messy.py:6:9: SIM115 Use a context manager for opening files
messy.py:8:12: UP006 [*] Use `list` instead of `List` for type annotation
messy.py:12:5: F841 Local variable `unused` is assigned to but never used
Found 8 errors.
[*] 5 fixable with the `--fix` option (1 hidden fix can be enabled with the `--unsafe-fixes` option).
ruff 0.16.2 check — real output

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).
ruff check --fix

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 json
def load(path):
f = open(path)
data = json.load(f)
messy.py — after --fix (top of file)

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+b
x = { "k":1,"y":2 }
before
def add(a, b):
return a + b
x = {"k": 1, "y": 2}
after — ruff format

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):

CodeMeansFrom my test
F401Imported but unusedos, sys
I001Import block un-sorted (isort)the import lines
E401Multiple imports on one lineimport os, sys
UP006 / UP035Outdated typing (pyupgrade)Listlist
SIM115Open file without a context manageropen(path)
F841Local variable assigned but never usedunused = 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 Playground

Free 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.

Keep reading