PermissionError in Python means your code tried to access a file, folder, socket, or system resource without the required permission. The syntax may be correct, the file path may look reasonable, and the script may still fail because the operating system blocks the operation. This is common when writing files in protected folders, editing a file that is open in another program, using the wrong path, or running a script without enough privileges.
This English version is adapted for readers who want a practical troubleshooting guide, not a literal translation. You will learn what causes PermissionError, how to identify whether the problem is a locked file, a protected folder, a directory path, missing write permissions, or an execution privilege issue. You will also see how to handle the exception safely and how to use pathlib to avoid path mistakes. If you are still learning file handling, start with this guide to reading TXT files in Python and this article about managing paths with pathlib.
What Is PermissionError in Python?
PermissionError is an operating system related exception raised when Python is not allowed to complete an operation. It is not usually caused by invalid Python syntax. It is caused by the environment around the script: file permissions, folder restrictions, locked files, administrator rights, read-only paths, or security rules enforced by Windows, macOS, or Linux.
The official Python exception documentation defines PermissionError as an error raised when trying to run an operation without adequate access rights. In practice, the most common error message includes text such as [Errno 13] Permission denied.
Quick Checklist to Fix PermissionError
When you see PermissionError, start with the simplest checks. Most cases are solved quickly by confirming that the file is not open elsewhere, the path includes a file name rather than only a folder, the script is writing to a user-owned directory, and the current user has permission to read or write that location.
- Close the file in Excel, Word, a text editor, or another program.
- Check whether your path points to a folder instead of a file.
- Write to a normal project folder, not a protected system directory.
- Confirm the user account has read or write permission.
- Use absolute paths or
pathlibto avoid path confusion. - Run with elevated privileges only when truly necessary.
Do not start by adding random try blocks or running everything as administrator. First identify what the operating system is refusing. That leads to a cleaner and safer fix.
Cause 1: The File Is Open in Another Program
On Windows especially, files opened in Excel, Word, or another application may be locked. If your Python script tries to overwrite, delete, or modify that file, the operating system may deny access. This is very common with .csv, .xlsx, and report files generated by automation scripts.
with open("report.csv", "w", encoding="utf-8") as file:
file.write("name,totalnAna,100n")If report.csv is open in Excel, the script may fail. Close the file and run the script again. For automated workflows, consider writing to a temporary file and replacing the final file only after processing succeeds. If your workflow uses spreadsheets, this article about CSV files in Python can help.
Cause 2: You Passed a Folder Instead of a File
Another frequent cause is passing a directory path to open() when Python expects a file path. On some systems this appears as PermissionError; on others it may appear as IsADirectoryError. The fix is to include the full file name and extension.
# Wrong: this path points to a folder
with open("data/reports", "w", encoding="utf-8") as file:
file.write("hello")
# Correct: this path points to a file
with open("data/reports/output.txt", "w", encoding="utf-8") as file:
file.write("hello")Always ask: is this path a folder or a file? If the code is supposed to create a file inside a folder, the path must include the file name. This small detail prevents many permission-related mistakes.
Cause 3: You Are Writing to a Protected Folder
Operating systems protect certain directories. On Windows, folders such as Program Files, Windows, or system-level locations may require administrator rights. On Linux and macOS, writing to /, /usr, or other system directories usually requires elevated permissions. A normal user script should not write there unless there is a specific reason.
A better solution is to write inside your project folder, your user profile, a temporary directory, or an application-specific data directory. Running everything as administrator may hide the symptom, but it can also create security risks and confusing file ownership problems later.
from pathlib import Path
output_dir = Path.home() / "python_reports"
output_dir.mkdir(exist_ok=True)
output_file = output_dir / "report.txt"
output_file.write_text("Report generated successfully", encoding="utf-8")This writes to a folder inside the current user’s home directory, which is usually safer than writing to a protected system path. If you use Python for automation, this guide to Python automation gives more context for file-based workflows.
Use pathlib to Build Safer Paths
Path bugs often lead to permission errors. A missing file name, incorrect slash, wrong working directory, or accidental system path can send your script to the wrong place. The pathlib module makes paths easier to compose and inspect across operating systems.
from pathlib import Path
base_dir = Path(__file__).resolve().parent
input_file = base_dir / "data" / "input.txt"
output_file = base_dir / "output" / "result.txt"
output_file.parent.mkdir(parents=True, exist_ok=True)
output_file.write_text("Done", encoding="utf-8")This avoids hardcoding fragile paths such as C:/Users/name/Desktop. It also creates the output folder if it does not exist. For more examples, read the full guide to pathlib in Python.
Check the Current Working Directory
Relative paths depend on the current working directory. If you run the same script from a different terminal location or from an IDE, Python may look for files in a different folder than expected. That can cause errors that appear unrelated at first.
from pathlib import Path
print(Path.cwd())Use this line when debugging path problems. If the working directory is not what you expected, either change how you run the script or build paths relative to the script file using __file__. This is more predictable for reusable automation scripts.
Check File and Folder Permissions
If the path is correct and the file is not locked, inspect the folder permissions. On Windows, right-click the folder, open Properties, then check the Security tab. On Linux and macOS, use commands such as ls -l to inspect ownership and permissions. The account running Python must have the required read or write access.
# Linux or macOS
ls -l data
# Check current user
whoamiIf a file was created by another user or by an administrator process, your normal user may not be able to modify it. Fix ownership or permissions carefully. Avoid broad permission changes such as making everything writable unless you understand the security impact.
Should You Use Administrator or sudo?
Running a terminal as administrator or using sudo can solve some permission errors, but it should not be the default solution. Elevated privileges allow the script to modify sensitive system files. A bug in the script can then cause much more damage. Use elevated privileges only when the task truly requires system-level access.
For most beginner and automation scripts, the better fix is to choose a user-owned directory. If a script needs to write logs, exports, reports, or temporary files, those files should normally live in a project folder, user folder, or configured output directory rather than a protected system location.
Handle PermissionError with try and except
Professional scripts should handle predictable permission problems gracefully. That does not mean hiding the error. It means showing a clear message, explaining what the user can do, and stopping safely instead of crashing with a confusing traceback.
from pathlib import Path
path = Path("report.csv")
try:
path.write_text("name,totalnAna,100n", encoding="utf-8")
except PermissionError:
print("Permission denied. Close the file if it is open and check folder permissions.")This is useful for command-line tools, automation scripts, and beginner projects. For a complete explanation of exception handling, read this guide to try and except in Python.
Do Not Catch Every Exception Blindly
Avoid broad exception handling such as except Exception unless you have a specific reason and proper logging. Catching everything can hide unrelated bugs, such as invalid data, wrong paths, encoding problems, or logic errors. If you expect a permission issue, catch PermissionError specifically.
# Too broad for most cases
try:
save_report()
except Exception:
print("Something went wrong")
# Better when permission is the expected failure
try:
save_report()
except PermissionError as error:
print(f"Permission problem: {error}")Specific exception handling makes the program easier to debug and safer to maintain. It also helps you show better messages to users.
PermissionError in Jupyter, VS Code, and IDEs
In notebooks and IDEs, the current working directory may not be the folder you think it is. A notebook may run from the notebook location, the project root, or a configured workspace. VS Code may use a different terminal directory depending on how the project was opened. This can send output files to unexpected locations.
Print the current directory, use absolute paths during debugging, and prefer project-relative paths based on __file__ in scripts. In notebooks, use Path.cwd() and keep input/output folders explicit. If you use editors heavily, see this guide to Python IDEs.
PermissionError vs FileNotFoundError
These two errors are often confused. FileNotFoundError means the path does not exist. PermissionError means the path may exist, but Python is not allowed to perform the requested operation. For example, opening a missing file for reading raises FileNotFoundError. Writing to a protected folder may raise PermissionError.
Use the traceback and the path in the error message to decide which case you have. Then check existence, type, and permissions separately. The more precise your diagnosis, the faster the fix.
A Practical Debugging Flow
When PermissionError appears, first copy the exact path from the traceback. Check whether it is a file or folder. Close any program that may be using it. Print the current working directory. Try writing to a simple test file in the same folder. If that fails, the folder permission is the problem. If that works, your original file may be locked, protected, or incorrectly specified.
Then decide whether the script should write there at all. If the folder is protected, choose a safer output location. If the task truly requires elevated access, run with administrator privileges only for that specific operation and document why it is required.
Final Checklist
Close files that are open in other programs. Make sure your path includes a file name, not only a folder. Avoid writing to protected system directories. Use pathlib to build safer paths. Check the current working directory. Confirm read and write permissions. Use administrator or sudo only when necessary. Catch PermissionError specifically and show a helpful message.
PermissionError is Python reporting that the operating system refused access. Once you identify whether the issue is a locked file, a wrong path, a protected folder, or insufficient permissions, the fix is usually straightforward. The best solution is not always more privileges; often it is simply using the right path and writing to a location your script is allowed to control.
