There is a chmod command to set file permissions, but can I get file permissions in octal mode (such as 755) from the command line?

  • 4
    For people like me who accidentally landed on this page but actually were searching for how to do this on Mac: stackoverflow.com/a/14855227/470749 – Ryan Jan 8 '19 at 0:20
  • 2
    stat --format "%A" $FILE gives you the human readable drwxr-x--- format. which may or may not be useful. – Trevor Boyd Smith May 27 '19 at 15:10

You can try

stat -c "%a %n" *

Replace * with the relevant directory or the exact filename that you want to examine.

From the man page of stat,

-c  --format=FORMAT
          use  the  specified  FORMAT instead of the default; output a newline after
          each use of FORMAT
%a     Access rights in octal
%n     File name


  • With files:

    $ stat -c "%a %n" ./Documents/Udev.html 
    664 ./Documents/Udev.html
  • With folders:

    $ stat -c "%a %n" ./Documents/
    755 ./Documents/


  • 64
    on mac os, use stat -f '%A %a %N' * (credit: geeklog.adamwilson.info/article/58/…) – s2t2 Apr 15 '15 at 22:07
  • 1
    If you are more comfortable with ls: for f in $(ls -a); do stat -c "%a %n" $f; done; – rgajrawala Jul 18 '15 at 19:00
  • 4
    @usandfriends looping on the output of ls is a bad idea. If you really want to use a loop you can do for f in *; do stat "%a %n" "$f"; done – Tom Fenech Feb 18 '16 at 10:12
  • 2
    Why on mac os everything is slightly changed (even in unix iso utils)? Is there an actual reason of this? – Vassilis Aug 21 '16 at 2:32
  • 2
    Please @hackel, tell us how you really feel. lol! – MikeSchinkel May 30 '17 at 7:31

File permissions in Linux can be displayed in octal format using Linux stat command.

Just press Ctrl+Alt+T on your keyboard to open Terminal. When it opens, Navigate to the directory where you want to find the file permissions in octal mode.

stat -c '%A %a %n' *

%A Access rights in human readable form

%a Access rights in octal

%n File name

Octal numbers and permissions

You can use octal number to represent mode/permission:

r: 4
w: 2
x: 1

For example, for file owner you can use octal mode as follows. Read, write and execute (full) permission on a file in octal is 0+r+w+x = 0+4+2+1 = 7

Only Read and write permission on a file in octal is 0+r+w+x = 0+4+2+0 = 6

Only read and execute permission on a file in octal is 0+r+w+x = 0+4+0+1 = 5

Use above method to calculate permission for group and others. Let us say you wish to give full permission to owner, read & execute permission to group, and read only permission to others, then you need to calculate permission as follows: User = r+w+x = 0+4+2+1 = 7 Group= r+w+x = 0+4+2+0 = 6 Others = r+w+x = 0+0+0+1 = 1

Effective permission is 761.

Source: http://kmaiti.blogspot.com/2011/09/umask-concept.html

  • 2
    The initial 0 represent special bit too: pastebin.com/6ymkFt71 – Braiam Jul 28 '13 at 1:45
  • is it possible to force 4 digit output? – openCivilisation Jan 3 at 1:50
  • To include hidden files/folders starting with dot (eg. .git) you can use stat -c '%A %a %n' .* * – Sharak May 12 at 8:11

As detailed in “755”-style permissions with ‘ls’ by Adam Courtemanche on AgileAdam.com, you can create an alias lso that acts like ls -l but slightly processes the output1 to display permissions also in octal. This adds a leading column showing three-digit2 octal permissions. As written, this works for most files and directories, but it does not work properly if the sticky or setuid/setgid bits are set.3

alias lso="ls -alG | awk '{k=0;for(i=0;i<=8;i++)k+=((substr(\$1,i+2,1)~/[rwx]/)*2^(8-i));if(k)printf(\" %0o \",k);print}'"

This has a serious shortcoming, though, as techtonik points out. You cannot pass arguments to this lso alias as you would to the ls command, because they are taken as additional arguments to awk instead. Thus you cannot run lso on a specific file or directory, nor can you pass any options (like -F, or --color) to lso.

The fix is to define lso as a function rather than an alias.

lso() { ls -alG "$@" | awk '{k=0;for(i=0;i<=8;i++)k+=((substr($1,i+2,1)~/[rwx]/)*2^(8-i));if(k)printf(" %0o ",k);print}'; }

If you're trying this out interactively in your shell, run unalias lso to remove the alias--you can do that either before or after you define the function. If you're putting it into a file that is sourced, such as ~/.bashrc, just take out the alias line and add the function definition.

Why does this work? Unlike aliases, bash shell functions can take positional parameters, i.e., command-line arguments. "$@" expands to the full argument list, causing arguments to the lso function to be passed to ls. (Unlike an alias definition, a function body is not quoted; hence it was necessary to remove the \characters before $ and ".)

Since you can pass options to lso when defined this way as a function, you may wish to remove the -a and -G options from the definition--you can pass them manually in cases where you want them. (The -l option is required for details like file permissions to be shown at all, so there is no benefit to removing it.)

lso() { ls -l "$@" | awk '{k=0;for(i=0;i<=8;i++)k+=((substr($1,i+2,1)~/[rwx]/)*2^(8-i));if(k)printf(" %0o ",k);print}'; }

Thanks to techtonik for pointing out the limitation in defining lso as an alias, thus motivating me to expand this post with material about making it a function instead.

1One may note this seems to flout the general rule about not parsing output from ls. ls produces very human-readable output; this introduces idiosyncrasies and limitations making it generally unsuitable as input for other commands. In this case we parse ls since we wish to preserve the exact behavior of ls except our one added change.

2One limitation of this alias, which also applies to the function version shown below it, and which may be considered a bug, is that it only displays three octal digits even when the fourth octal digit is zero. As jfmercer has rightly pointed out, the octal digits displayed here don't reflect the sticky bit if present, nor setuid or setgid bits.

3More seriously than merely not showing the fourth octal digit is that this method assumes they are not set, and if they are--if you see t, s, or S in the permission string--then you should disregard the octal digits. This because the bits are inferred from the permissions string in a way that does not account for sticky setuid/setgid bits.

  • doesn't work with directories - awk: read error (Is a directory) – anatoly techtonik Jul 25 '14 at 7:25
  • @techtonik Thanks for pointing this out! I've (finally) updated this answer to include a fix for that. – Eliah Kagan Apr 10 '15 at 20:37
  • 2
    You can add --color parameter for show colors lso() { ls -alG "$@" --color | awk '{k=0;for(i=0;i<=8;i++)k+=((substr($1,i+2,1)~/[rwx]/)*2^(8-i));if(k)printf(" %0o ",k);print}'; } – tagplus5 Mar 13 '17 at 0:03
  • 1
    have you discovered a solution to the sticky setuid/setgid issue since posting this? – Silvestris Mar 3 '19 at 4:00

Just extending\simplifying previous 'stat' related answers:

You can simply run:

stat <path_to_file>

The output will contain octal permission along with other info.

Details(stat version and example):

# stat --version
stat (GNU coreutils) 8.4

[user@localhost ~]# touch /tmp/TEST_PERMISSONS

[user@localhost ~]# chmod 644 /tmp/TEST_PERMISSONS

[user@localhost ~]# stat /tmp/TEST_PERMISSONS
  File: `/tmp/TEST_PERMISSONS'
  Size: 0           Blocks: 0          IO Block: 4096   regular empty file
Device: fd00h/64768d    Inode: 1010058     Links: 1
Access: (0644/-rw-r--r--)  Uid: (    0/    root)   Gid: (    0/    root)
Access: 2015-08-26 18:58:59.000000000 +0300
Modify: 2015-08-26 18:58:59.000000000 +0300
Change: 2015-08-26 18:59:16.000000000 +0300

Note the: (0644/-rw-r--r--)


For portability, you can use perl:

$ perl -e 'printf "%04o %s\n", (stat)[2] & 07777, $_ for @ARGV' *.txt
0644 1.txt
0644 2.txt
0644 3.txt
0644 4.txt
0600 PerlOneLiner.txt
0664 perl.txt

If you want to notice when an error occurs, try:

perl -e '
for (@ARGV) {
    print "$!: $_\n" and next unless -e;
    printf "%03o %s\n", (stat)[2] & 07777, $_;
' *.txt
  • 2
    In addition to being portable, @cuonglm's solution shows four octal characters rather than three, thus showing the state of the "sticky bit" that is often forgotten about. – jfmercer Jul 22 '15 at 14:28
  • how about show hidden files ? – MaXi32 May 14 '20 at 21:28
  • @MaXi32 use .* – cuonglm May 15 '20 at 2:45

You can use find with the -printf action.

ls doesn't show octal permissions, but you can use this find-based workaround:

find path -printf "%m:%f\n"

For example, to check my Videos directory:

$ find Videos -printf "%m:%f\n"

The %m format specifier tells the -printf action to print octal permissions, while the %f format specifier causes it to print the filename.

You can pass multiple filenames to find. You can even use globs (e.g., find * -printf "%m:%f\n").

You don't have to use a test like -name or -iname; it is sufficient to pass the names of the files or directories you are interested in as starting points to find. That is, supply their names as arguments immediately after the word find, as shown above.

find gives you great control over how it shows output. There are two modifications in particular that you might find useful:

  • By default, find recurses subdirectories, similar to ls -R. If you don't want find to visit the subdirectories of the starting points you pass to it, you can add -maxdepth 0 (or use -maxdepth with other values to indicate how deep you want it to go).

    $ find Documents -maxdepth 0 -printf "%m:%f\n"
  • %f only shows a filename, so if find has to recurse to get to a file, you might not know where it is located. To show a path, beginning with whichever starting point the file was found under, use %p instead.

    $ find /boot -printf "%m:%p\n"

See man find for more information about using the find command.

Another Method (ls and awk)

This can be used to list all directory files with their permissions:

ls -l | awk '{k=0;for(i=0;i<=8;i++)k+=((substr($1,i+2,1)~/[rwx]/) \
             *2^(8-i));if(k)printf("%0o ",k);print}'

This is essentially the same command as in Adam Courtemanche's lso alias, which that answer cited, just run as a single command. If you're only using this once, or on rare occasion, then you might not want to bother writing it as an alias or shell function.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.