How to Check and Fix Your Python Code Online (Free)

Python does almost no checking up front. It parses your file (that's the only thing it verifies before running), then executes top to bottom — discovering every other mistake one crash at a time, at runtime. "Checking" your code means finding those mistakes without running it, and it comes in three layers:

1. Syntax — does it parse? (grammar only)
2. Types — do the values fit? (does greet(42) pass the wrong type?) — that's mypy
3. Lint — unused imports, undefined names, risky patterns, style — that's Ruff

Here's the broken file every test below uses. It has two bugs that are not syntax errors, so Python happily parses it — and would run right up until it crashes:

import os
import requests

def greet(name: str) -> str:
    return "Hello " + name

msg = greet(42)      # oops: passing an int where a str is expected
print(mesage)        # oops: typo -- should be 'msg'

The most basic check is whether the file is valid Python grammar at all. py_compile (or compile) answers that without running a line:

$ python -c "import py_compile; py_compile.compile('buggy.py', doraise=True)"
# (no error)  ->  the file PARSES fine

And that's the trap: buggy.py passes the syntax check. Parsing only proves the grammar is valid — it says nothing about whether the program is *correct*. Both real bugs (the wrong-typed argument and the misspelled name) sail straight through. That's why syntax is only layer one.

mypy reads your type hints and checks that the values flowing through actually fit them — the class of bug the interpreter only discovers when that exact line executes. On the same file:

$ mypy buggy.py
buggy.py:7: error: Argument 1 to "greet" has incompatible type "int"; expected "str"  [arg-type]
buggy.py:8: error: Name "mesage" is not defined  [name-defined]
Found 2 errors in 1 file (checked 1 source file)

Two real bugs caught without running anything. greet(42) would blow up at runtime with TypeError: can only concatenate str (not "int") to str — but only if execution reached it; mypy flags it statically. And print(mesage) is a NameError waiting to happen on line 8 — mypy sees the misspelling immediately. This is the highest-value layer: it finds logic bugs your tests might miss.

Ruff is the linter: it runs hundreds of rules for unused imports, undefined names, shadowed builtins, mutable default arguments, and more — extremely fast (it's written in Rust). On our file:

$ ruff check buggy.py
F401 [*] `os` imported but unused
F401 [*] `requests` imported but unused
F821 Undefined name `mesage`
I001 [*] Import block is un-sorted or un-formatted
Found 4 errors.
[*] 3 fixable with the `--fix` option.

Notice it caught the same mesage typo (F821) that mypy did, plus two unused imports and an import-order issue mypy doesn't care about. The [*] marks what Ruff can fix for you — the "corrector" part. Add --fix:

$ ruff check --fix buggy.py
Found 3 errors (2 fixed, 1 remaining).
# both unused imports removed automatically; imports left: 0

You don't need mypy or Ruff installed locally to do any of this — both run in your browser here, and your code is never uploaded:

Paste a snippet into the Type Checker to run mypy (pick your target Python version and strict mode), then the Ruff Linter to find and auto-fix the rest. Between them you've covered types, bugs, imports, and style — the full "is my code correct?" check — with nothing installed.

The short version: run mypy for correctness (the bugs that bite at runtime) and Ruff for cleanliness and quick fixes. They overlap a little (both catch undefined names) but mostly complement each other — types are mypy's job, everything else is Ruff's. Use both and your code is checked the way a careful reviewer would, in seconds.