How to Check File and Folder Permissions in Terminal on a Mac

Quick Answer

To check a file or folder’s permissions in Terminal, use ls -l followed by the item’s path:

ls -l ~/Documents/example.txt

For a folder, add -d so Terminal reports the folder itself instead of its contents:

ls -ld ~/Documents

The output shows who owns the item and whether the owner, group, and other users can read, write, or access it. For more detail—including access control entries (ACLs)—use:

ls -le ~/Documents/example.txt

Checking permissions does not change the file or folder. It is safe to run these commands.

What File Permissions Mean on a Mac

macOS uses Unix-style permissions to control access to files and folders. Three permission categories are shown:

• Owner: The user account that owns the item.
• Group: Users assigned to the item’s group.
• Others: Everyone else with access to the Mac or shared location.

The basic permissions are:

• Read (r): View a file’s contents or list a folder’s contents.
• Write (w): Change a file or add, remove, or rename items in a folder.
• Execute (x): Run a program file. For a folder, this generally means entering it or accessing items inside it.

A permissions string might look like this:

-rw-r--r--

The first character identifies the item type. A hyphen means it is a regular file; d means it is a directory. The remaining nine characters are grouped into owner, group, and others:

rw- r-- r--

In this example, the owner can read and write, while the group and others can only read.

Open Terminal and Identify the Item

Open Terminal from Applications > Utilities, or search for it with Spotlight.

Before checking permissions, identify the exact file or folder path. You can type the path manually, but dragging an item from Finder into a Terminal window usually enters its full path automatically.

You can also check your current location:

pwd

This prints the path of the current working directory. To see the files and folders there, use:

ls

The ls command lists directory contents. It does not change anything.

If a name contains spaces, enclose the path in quotation marks:

ls -l "~/Documents/Project Files/notes.txt"

Alternatively, escape each space with a backslash:

ls -l ~/Documents/Project Files/notes.txt

Check a File’s Permissions

The following command displays a file’s permissions, owner, group, size, modification time, and name:

ls -l ~/Documents/example.txt

A result has this general structure:

-rw-r--r--  1 owner  group  size  date  name

The spacing and details can vary. Focus on the first field, owner, and group.

For example, in -rw-r--r--:

1. The first character, -, identifies a regular file.
2. rw- shows the owner can read and write.
3. r-- shows the group can read but not write.
4. r-- shows other users can read but not write.

The number after the permission string is the item’s link count. It is usually not necessary when diagnosing an ordinary permission problem.

ls -l ~/Documents/example.txt

If the file is not in your home folder, replace the example path with the actual path. Do not type the angle brackets sometimes used in instructional examples; use a real path instead.

Check a Folder’s Permissions

When you run ls -l on a folder, Terminal normally lists the folder’s contents. To inspect the folder itself, use -d:

ls -ld ~/Documents

The -l option requests the detailed listing format, while -d tells ls to treat the directory as an item rather than listing what is inside it.

A folder’s permission string is interpreted slightly differently from a file’s:

• Read (r): List the names of items in the folder.
• Write (w): Add, remove, or rename items in the folder.
• Execute (x): Enter the folder and access items when you know their names.

A folder can therefore allow you to see names without allowing you to open or change the items inside. Conversely, access to a file also depends on the permissions of every parent folder in its path.

To inspect a folder and its contents, omit -d:

ls -l ~/Documents

That command does not recursively inspect every subfolder. It lists the immediate contents only.

See Permissions for Every Folder in a Path

When access fails, checking only the final file may not reveal the problem. One of its parent folders may deny access. The namei command is not available by default on every Mac, so use stat for the item itself and inspect parent directories individually with ls -ld.

For example:

ls -ld ~ ~/Documents ~/Documents/Project Files

This checks the home folder, the Documents folder, and a nested folder. Each path is treated as a directory because of -d.

You can also use stat to print detailed metadata for a specific item:

stat -f '%Sp %Su %Sg %N' ~/Documents/example.txt

This format reports:

• %Sp: Symbolic permissions, such as -rw-r--r--
• %Su: Owner username
• %Sg: Group name
• %N: Item name

stat only displays information. It does not modify the file or folder.

Check for Access Control Lists

Basic Unix permissions are not always the whole story. macOS can also use access control lists, or ACLs, which add specific rules for individual users or groups.

Use ls -le to display them:

ls -le ~/Documents/example.txt

The -e option includes ACL entries when they exist. If no ACL is attached, you may see only the normal detailed listing.

To check a folder itself:

ls -lde ~/Documents

ACL output can include entries that grant or deny access beyond the standard owner, group, and other permissions. This is especially useful when the basic permission string appears correct but an application or user still cannot access the item.

ls -lde ~/Documents

Do not remove ACL entries merely because they appear unfamiliar. Some may be intentional, and changing them can affect access for other users or applications.

Check Ownership and Permissions Together

The following command displays the standard permission string, owner, group, and path in a compact format:

stat -f 'Permissions: %Sp
Owner: %Su
Group: %Sg
Path: %N' ~/Documents/example.txt

This is useful when you want an easy-to-read summary rather than the standard ls layout.

For a folder:

stat -f 'Permissions: %Sp
Owner: %Su
Group: %Sg
Path: %N' ~/Documents

If the path contains spaces, quote it:

stat -f 'Permissions: %Sp
Owner: %Su
Group: %Sg
Path: %N' "~/Documents/Project Files"

These commands only read metadata. They do not require administrator authentication for ordinary items that your account can inspect.

Check Numeric Permission Values

Permissions can also be represented numerically. Use stat to see the mode value:

stat -f '%Mp%Sp %N' ~/Documents/example.txt

The numeric portion represents the permission bits. Common values include:

• 644: Owner can read and write; group and others can read.
• 600: Owner can read and write; group and others have no permissions.
• 755: Owner can read, write, and execute; group and others can read and execute.

The numeric value may include additional file-type or special-mode information, so do not assume every complete number is a simple three-digit permission code.

Numeric values are most useful when comparing items or documenting a configuration. The symbolic form, such as -rw-r--r--, is usually easier to read.

Check Permissions Recursively

To inspect a directory and everything below it, use find with -ls:

find ~/Documents/Project Files -ls

This lists matching items recursively, including permissions and ownership information. It can produce a large amount of output, so use it only on a specific folder rather than your entire home directory.

To inspect only regular files:

find ~/Documents/Project Files -type f -exec ls -l {} +

To inspect only directories:

find ~/Documents/Project Files -type d -exec ls -ld {} +

These commands only report information. They do not change any permissions.

If a path contains spaces, quote it:

find "~/Documents/Project Files" -type d -exec ls -ld {} +

Understand Common Permission Errors

“Permission denied”

This usually means your account lacks permission to access the item or one of its parent folders. Check the item and its parent directories:

ls -ld ~/Documents ~/Documents/Project Files
ls -le ~/Documents/Project Files/example.txt

A permission string that appears open may not tell the whole story if an ACL, ownership issue, privacy restriction, or application-specific rule is involved.

“No such file or directory”

Terminal cannot find the path exactly as entered. Check spelling, capitalization, spaces, and punctuation. You can list the parent folder:

ls -la ~/Documents

The -a option includes hidden items.

The command prints nothing

Some commands intentionally produce no output when they find no matching entries. For example, a filtered find command may return nothing if no item matches. Run a broader listing to confirm the path exists:

ls -ld ~/Documents

The file is visible but cannot be opened

The file may have readable metadata but still be blocked by an ACL, a parent directory, an application permission setting, or macOS privacy protections. Compare the file’s ACL and each parent folder:

ls -lde ~/Documents ~/Documents/Project Files ~/Documents/Project Files/example.txt

When You Should Not Change Permissions

Checking permissions is harmless, but changing them can affect applications, other users, shared folders, and system behavior. Avoid changing permissions on system locations or unfamiliar files unless you understand the result.

Do not use a broad recursive command such as chmod -R as a first response to an error. It can alter many files at once, including files that intentionally have different permissions.

Before changing anything, make a backup or record the current state:

ls -lde ~/Documents/Project Files

If you do make a change, use the narrowest possible path and verify the result immediately. A change made with chmod can generally be reversed by applying the previous mode, but the correct reversal depends on the original permissions. ACL changes have their own rules and should not be reversed blindly.

Some operations may also require administrator privileges. A command that uses sudo can affect files owned by other users or the system. macOS will request your account password, and Terminal will not display characters while you type it. Do not use sudo unless you know exactly what the command does.

Troubleshooting Checklist

Work through these checks in order:

1. Confirm the path.

bash
ls -ld "~/Documents/Project Files/example.txt"

2. Check the parent folders.

bash
ls -ld ~ ~/Documents "~/Documents/Project Files"

3. Check the file’s standard permissions and ACL.

bash
ls -le "~/Documents/Project Files/example.txt"

4. Check ownership separately.

bash
stat -f 'Permissions: %Sp
Owner: %Su
Group: %Sg
Path: %N' "~/Documents/Project Files/example.txt"

5. Check whether the item is a symbolic link.

bash
ls -l "~/Documents/Project Files/example.txt"

A path beginning with l identifies a symbolic link. The displayed target may have different permissions from the link itself.

6. Avoid changing permissions until you know which rule is blocking access.

If the item is on an external, network, or shared volume, its permission behavior may also depend on that volume’s format and sharing configuration.

find "~/Documents/Project Files" -type d -exec ls -lde {} +

This command checks every directory below the specified folder and includes ACL information. It can produce extensive output; stop it with Control-C if necessary. It does not modify any files or folders.

Frequently Asked Questions

What is the simplest Terminal command for checking permissions?

Use:

ls -l /path/to/file

For a folder itself, use ls -ld /path/to/folder.

How do I check permissions for a folder and not its contents?

Add the -d option:

ls -ld /path/to/folder

Without -d, ls lists the folder’s contents instead.

What does rwx mean?

r means read, w means write, and x means execute. For folders, x generally means you can enter the folder and access items inside it.

How do I see ACL permissions?

Use the -e option:

ls -le /path/to/item

For a folder itself, use ls -lde /path/to/folder.

Can checking permissions damage my files?

No. The commands in this guide only read and display metadata. Commands such as chmod, chown, and ACL-editing commands change permissions or ownership and should be treated separately.

Why can I access a file even when its basic permissions look restrictive?

An ACL, your account’s ownership, a group membership, or an application and privacy rule may provide access that is not obvious from the basic permission string alone.

Final Thoughts

Use ls -l for a quick permission check, ls -ld to inspect a folder itself, and ls -le when you need to see ACL entries. If access is still unclear, check the item’s owner, ACL, and every parent folder before changing anything. This approach helps you diagnose storage and file-access problems without making unnecessary system changes.