# How to debug Python code in Replit

- Tool: Replit
- Difficulty: Beginner
- Time required: 15 minutes
- Compatibility: All Replit plans (Starter, Core, Pro). Python 3.10+ via default Nix module.
- Last updated: March 2026

## TL;DR

Replit provides several ways to debug Python code directly in the browser. Start with print statements and Console output for quick checks, then graduate to Python's built-in pdb debugger in the Shell for step-through debugging. The Console pane shows structured stdout and stderr, making it easy to trace errors without any local setup.

## Debug Python code in Replit without leaving the browser

Debugging is the process of finding and fixing errors in your code. Replit gives you a full Python environment in the browser, complete with Console output, Shell access, and support for Python's standard debugging tools. Whether you are dealing with a simple typo, a logic error, or a confusing traceback, this tutorial walks you through practical techniques that work inside Replit's workspace without installing anything on your computer.

## Before you start

- A free Replit account at replit.com
- A Python Repl (create one by clicking + Create App and selecting Python)
- Basic familiarity with Python syntax (variables, functions, loops)
- Understanding of the difference between Shell and Console in Replit

## Step-by-step guide

### 1. Use print statements to inspect variables

The simplest debugging technique is adding print statements to your code. In Replit, anything printed to stdout appears in the Console pane when you click Run. Place print calls before and after suspicious lines to see the actual values your variables hold at runtime. This is especially useful for catching unexpected None values, wrong data types, or off-by-one errors in loops. Print debugging is not sophisticated, but it solves the majority of beginner bugs in seconds.

```
def calculate_total(prices):
    print(f"DEBUG: prices received = {prices}")  # inspect input
    total = 0
    for price in prices:
        total += price
        print(f"DEBUG: running total = {total}")  # trace each iteration
    return total

result = calculate_total([10, 20, 30])
print(f"Final result: {result}")
```

**Expected result:** The Console shows each variable value at every step, letting you pinpoint exactly where the logic goes wrong.

### 2. Read Python tracebacks in the Console

When Python encounters an error, it prints a traceback in the Console. A traceback reads from bottom to top: the last line tells you the error type and message, while the lines above show the call stack leading to the error. Common errors include NameError (misspelled variable), TypeError (wrong data type), IndexError (list index out of range), and KeyError (missing dictionary key). Learning to read tracebacks is the single most valuable debugging skill in Python.

```
# This code intentionally has a bug
user_data = {"name": "Alice", "email": "alice@example.com"}
print(user_data["phone"])  # KeyError: 'phone'
```

**Expected result:** You see a KeyError traceback in the Console. Reading the last line tells you the key 'phone' does not exist in the dictionary.

### 3. Use try/except blocks to catch and log errors

Wrap risky code in try/except blocks to prevent crashes and log meaningful error messages instead. This is especially important for operations that depend on external input, like reading user data, calling APIs, or accessing files. The except block catches the error, and you can print the exception details to the Console for debugging. This technique lets your app continue running while you investigate the problem.

```
import traceback

def fetch_user_setting(settings, key):
    try:
        value = settings[key]
        return value
    except KeyError as e:
        print(f"ERROR: Missing setting '{key}' - {e}")
        traceback.print_exc()  # prints full traceback
        return None

config = {"theme": "dark"}
result = fetch_user_setting(config, "language")
print(f"Got: {result}")
```

**Expected result:** The Console shows the error message and traceback, but the program continues running and prints 'Got: None' instead of crashing.

### 4. Debug interactively with pdb in the Shell

Python's built-in pdb debugger lets you pause execution and inspect your program step by step. Open the Shell pane in Replit (not Console) and run your script with the -m pdb flag. You can also insert breakpoint() directly in your code to pause at a specific line. Once paused, use pdb commands: 'n' for next line, 's' to step into a function, 'p variable' to print a variable, 'c' to continue, and 'q' to quit. This is more powerful than print debugging for complex logic bugs.

```
# Add breakpoint() where you want to pause
def process_items(items):
    results = []
    for item in items:
        breakpoint()  # execution pauses here in Shell
        processed = item.strip().lower()
        results.append(processed)
    return results

process_items(["  Hello ", "WORLD  ", " Python "])
```

**Expected result:** The Shell shows a (Pdb) prompt. Typing 'p item' displays the current list element. Typing 'n' advances to the next line. Typing 'c' continues to the next breakpoint.

### 5. Use logging instead of print for persistent debug output

Python's logging module gives you leveled output (DEBUG, INFO, WARNING, ERROR) that you can turn on and off without removing code. Set the logging level to DEBUG during development and WARNING for production. This avoids the common problem of forgetting to remove print statements before deploying. Logging output appears in the Console just like print statements but with timestamps and severity levels.

```
import logging

logging.basicConfig(
    level=logging.DEBUG,
    format="%(asctime)s [%(levelname)s] %(message)s"
)

def divide(a, b):
    logging.debug(f"divide() called with a={a}, b={b}")
    if b == 0:
        logging.error("Division by zero attempted")
        return None
    result = a / b
    logging.info(f"Result: {result}")
    return result

divide(10, 0)
divide(10, 3)
```

**Expected result:** The Console shows timestamped log messages with severity levels. The ERROR line for division by zero stands out clearly from the DEBUG and INFO messages.

### 6. Debug common Python errors in Replit

Some errors are specific to the Replit environment. ModuleNotFoundError usually means the package is not installed; fix it by running pip install package_name in the Shell or adding the package via the Dependencies tool. FileNotFoundError often occurs because the working directory is not what you expect; use os.getcwd() to check. IndentationError is common when pasting code from external sources because of mixed tabs and spaces. When your Repl shows 'Your Repl ran out of memory,' you are hitting the plan's RAM limit, which is 2 GiB on the free tier.

```
import os
import sys

# Diagnostic script for common Replit issues
print(f"Python version: {sys.version}")
print(f"Working directory: {os.getcwd()}")
print(f"Files here: {os.listdir('.')}")

# Check if a module is importable
try:
    import flask
    print(f"Flask version: {flask.__version__}")
except ModuleNotFoundError:
    print("Flask not installed. Run: pip install flask in Shell")
```

**Expected result:** The Console prints your Python version, working directory, file listing, and module availability, helping you diagnose environment-specific issues.

## Complete code example

File: `debug_helpers.py`

```python
"""Reusable debugging helpers for Python projects on Replit."""
import logging
import traceback
import os
import sys

# Configure logging with a clear format
logging.basicConfig(
    level=logging.DEBUG,
    format="%(asctime)s [%(levelname)s] %(funcName)s:%(lineno)d - %(message)s"
)
logger = logging.getLogger(__name__)


def debug_environment():
    """Print diagnostic info about the Replit environment."""
    logger.info(f"Python: {sys.version}")
    logger.info(f"CWD: {os.getcwd()}")
    logger.info(f"Platform: {sys.platform}")
    logger.info(f"REPL_SLUG: {os.getenv('REPL_SLUG', 'not set')}")


def safe_call(func, *args, **kwargs):
    """Call a function with error catching and logging."""
    try:
        result = func(*args, **kwargs)
        logger.debug(f"{func.__name__} returned: {result}")
        return result
    except Exception as e:
        logger.error(f"{func.__name__} failed: {type(e).__name__}: {e}")
        traceback.print_exc()
        return None


def inspect_variable(name, value):
    """Log detailed info about a variable for debugging."""
    logger.debug(
        f"{name} = {repr(value)} "
        f"(type: {type(value).__name__}, "
        f"len: {len(value) if hasattr(value, '__len__') else 'N/A'})"
    )


# Example usage
if __name__ == "__main__":
    debug_environment()

    data = {"users": ["Alice", "Bob"], "count": 2}
    inspect_variable("data", data)

    def risky_division(a, b):
        return a / b

    # This succeeds
    safe_call(risky_division, 10, 3)

    # This fails gracefully
    safe_call(risky_division, 10, 0)

    print("\nProgram completed without crashing.")
```

## Common mistakes

- **Running pdb in the Console instead of the Shell, which causes the debugger to hang because Console does not accept interactive input** — undefined Fix: Open the Shell pane and run your script with python main.py. The Shell supports interactive prompts like (Pdb).
- **Leaving print or logging.debug statements in production code, which fills Console logs and slows performance** — undefined Fix: Set logging level to WARNING or ERROR before deploying: logging.basicConfig(level=logging.WARNING)
- **Ignoring ModuleNotFoundError and assuming the package is installed because it works locally** — undefined Fix: Run pip install package_name in the Shell. For system-level dependencies, add them to replit.nix.
- **Not checking the working directory when FileNotFoundError appears — Replit's CWD may not match expectations** — undefined Fix: Use os.getcwd() and os.listdir('.') to verify the directory and available files before opening files.

## Best practices

- Always read tracebacks from bottom to top — the last line contains the error type and the most useful information
- Use the Shell for interactive debugging with pdb and reserve the Console (Run button) for running your app
- Replace print debugging with the logging module for any project you plan to deploy
- Check the Resources panel (stacked computers icon) when your Repl crashes — you may be hitting the 2 GiB RAM limit on the free tier
- Use breakpoint() instead of import pdb; pdb.set_trace() for cleaner code (Python 3.7+)
- Add type hints to function signatures — they help catch TypeError bugs before runtime
- Test functions in isolation by running them directly in the Shell with python -c before integrating them
- Remove or disable all debug output before deploying with Autoscale or Reserved VM deployments

## Frequently asked questions

### Does Replit have a built-in visual debugger with breakpoints like VS Code?

Replit does not currently offer a visual step-through debugger with clickable breakpoints. Use Python's built-in pdb module in the Shell or insert breakpoint() calls in your code for step-through debugging.

### Why does my pdb debugger hang when I click Run?

The Console pane (triggered by Run) does not support interactive input. Open the Shell pane instead and run your script manually with python main.py to use pdb interactively.

### How do I see print output in Replit?

Click the Run button at the top of the workspace. All print() output appears in the Console pane. If you do not see the Console, open it from the Tools dock on the left sidebar.

### Can I use third-party debuggers like ipdb or pudb in Replit?

Yes. Install them in the Shell with pip install ipdb or pip install pudb, then use them the same way as pdb. Run your script from the Shell for interactive debugging.

### How do I debug a Flask or Django app running on Replit?

Enable debug mode in your framework (app.run(debug=True) for Flask, DEBUG=True in settings for Django). This shows detailed error pages in the Preview pane. For deeper debugging, add logging statements or use pdb in specific route handlers.

### What does 'Your Repl ran out of memory' mean?

Your program exceeded the plan's RAM limit (2 GiB on free, 8 GiB on Core). Process data in smaller chunks, delete unused variables with del, and check the Resources panel to monitor memory usage in real time.

### Can RapidDev help if I'm stuck debugging a complex Replit project?

Yes. RapidDev's engineering team specializes in troubleshooting AI-built applications, including Replit projects. They can help diagnose tricky bugs, optimize performance, and resolve deployment issues that go beyond basic debugging.

### How do I debug code that only fails in deployment but works in the workspace?

Check three things: secrets must be added separately in the Deployments pane (workspace secrets do not carry over), the server must bind to 0.0.0.0 instead of localhost, and the filesystem resets on each deploy so do not rely on local files.

---

Source: https://www.rapidevelopers.com/replit-tutorial/how-to-debug-python-code-effectively-with-replit-s-debugging-tools
© RapidDev — https://www.rapidevelopers.com/replit-tutorial/how-to-debug-python-code-effectively-with-replit-s-debugging-tools