How to create users and shares by importing a users list file

Right now, I am up to so many users and so many shares and particular permissions that can be set in one file. But I am struggling to get beyond the so many to get to the next level, and I am not sure if it is the limit of the OS or if it is a mistake that I have created which prevents me from going over the hurdle. So here follows the file containing so many users and so many shares and their relationships as to accessibility of each share to whatever user. So embedded here, I have copy-pasted the text content of the file that works up to a limited number us users and shares, but when I add a few more pairs of users and shares, and start as a clean slate, and run the file with the added number of users and shares beyond what I know worked, it then appears to fail to work with the increase information. So, unless I have made a mistake, I may have reached a limit. So what is it that I am importing? Here I will attempt to copy-paste it in here somewhere, and I will also attempt to upload it.

But for now, I can roughly describe the specifications of what I want to produce from importing that file as follows:
I want to create six primary users assigned to six staff members. Actually, I need to do much more than six, but for this example that I know works, I want six.
For each primary user, there will be a share assigned that is read only to all other staff. Now that doubles the number of created users from six to twelve. But the additional six users will function as shares. That means that I block or deny access to those additional users thus making them useless as users but useful as shares that users can share with others. So these shares I can think of them as shared folders. But there will be another three shares added that will work something like group folders or sites. So certain users will be members of a club that gets to manage their own group folder. And yet there will be another three shares but semiprivate, you could say, and shareable to non-club members. In total, for the stage, with one file, I will be able to create and manage six users and their shares, totaling 12, and then, you could say, 3 special work “sites” and 3 read only sharable corresponding shares. Altogether, this file can create six primary users and six shareable folders one for each user, and six special folders, you could say.

But how you might ask does one create and distinguish between users and shares? When importing the file, it looks at one line at a time and processes what’s given. And I have good reason to believe that it looks at the list of users to be created in alphabetical order. Also, I have discovered that it requires that one run the file twice, because the first run, it creates the users, the second run it sets the permissions. I am trying to be able to create both users and shares. The distinction is that a user will be signing in, whereas a share is like a folder, and even though the import file requires that any type of folder created gets assigned a password, the way to perfectly distinguish the user from the share is that the share will be blocked by way of the sixth parameter that I call Denied Access or access denied or something like that. In that parameter, I simply list all the shares or users that were created, separated by a colon, as one always has to do in each parameter.

So here is the import file:

Username password member ReadWrite ReadOnly AccessDenied Quotas
alvaro_sh dummypassword alvaro_usr:alvaro_sh:camilo_usr:camilo_sh:carlos_usr:carlos_sh:christian_usr:christian_sh:enrique_usr:enrique_sh:vladimir_usr:vladimir_sh:z_fin_xsh:z_fin_sh:z_hr_xsh:z_hr_sh:z_ops_xsh:z_ops_sh 20000:0:0
alvaro_usr alvaro1223 alvaro_usr:alvaro_sh:z_ops_xsh:z_ops_sh camilo_sh:carlos_sh:christian_sh:enrique_sh:vladimir_sh:z_fin_sh:z_hr_sh camilo_usr:carlos_usr:christian_usr:enrique_usr:vladimir_usr:z_fin_xsh:z_hr_xsh 20000:0:0
camilo_sh dummypassword alvaro_usr:alvaro_sh:camilo_usr:camilo_sh:carlos_usr:carlos_sh:christian_usr:christian_sh:enrique_usr:enrique_sh:vladimir_usr:vladimir_sh:z_fin_xsh:z_fin_sh:z_hr_xsh:z_hr_sh:z_ops_xsh:z_ops_sh 20000:0:0
camilo_usr camilo7530 camilo_usr:camilo_sh:z_ops_xsh:z_ops_sh alvaro_sh:carlos_sh:christian_sh:enrique_sh:vladimir_sh:z_fin_sh:z_hr_sh alvaro_usr:carlos_usr:christian_usr:enrique_usr:vladimir_usr:z_fin_xsh:z_hr_xsh 20000:0:0
carlos_sh dummypassword alvaro_usr:alvaro_sh:camilo_usr:camilo_sh:carlos_usr:carlos_sh:christian_usr:christian_sh:enrique_usr:enrique_sh:vladimir_usr:vladimir_sh:z_fin_xsh:z_fin_sh:z_hr_xsh:z_hr_sh:z_ops_xsh:z_ops_sh 20000:0:0
carlos_usr carlos1336 carlos_usr:carlos_sh:z_fin_xsh:z_fin_sh:z_hr_xsh:z_hr_sh alvaro_sh:camilo_sh:christian_sh:enrique_sh:vladimir_sh:z_ops_sh alvaro_usr:camilo_usr:christian_usr:enrique_usr:vladimir_usr:z_ops_xsh 20000:0:0
christian_sh dummypassword alvaro_usr:alvaro_sh:camilo_usr:camilo_sh:carlos_usr:carlos_sh:christian_usr:christian_sh:enrique_usr:enrique_sh:vladimir_usr:vladimir_sh:z_fin_xsh:z_fin_sh:z_hr_xsh:z_hr_sh:z_ops_xsh:z_ops_sh 20000:0:0
christian_usr christian7530 christian_usr:christian_sh:z_fin_xsh:z_fin_sh:z_hr_xsh:z_hr_sh alvaro_sh:camilo_sh:carlos_sh:enrique_sh:vladimir_sh:z_ops_sh alvaro_usr:camilo_usr:carlos_usr:enrique_usr:vladimir_usr:z_ops_xsh 20000:0:0
enrique_sh dummypassword alvaro_usr:alvaro_sh:camilo_usr:camilo_sh:carlos_usr:carlos_sh:christian_usr:christian_sh:enrique_usr:enrique_sh:vladimir_usr:vladimir_sh:z_fin_xsh:z_fin_sh:z_hr_xsh:z_hr_sh:z_ops_xsh:z_ops_sh 20000:0:0
enrique_usr enrique1599 enrique_usr:enrique_sh:z_ops_xsh:z_ops_sh alvaro_sh:camilo_sh:carlos_sh:christian_sh:z_fin_sh:z_hr_sh alvaro_usr:camilo_usr:carlos_usr:christian_usr:vladimir_usr:z_fin_xsh:z_hr_xsh 20000:0:0
vladimir_sh dummypassword alvaro_usr:alvaro_sh:camilo_usr:camilo_sh:carlos_usr:carlos_sh:christian_usr:christian_sh:enrique_usr:enrique_sh:vladimir_usr:vladimir_sh:z_fin_xsh:z_fin_sh:z_hr_xsh:z_hr_sh:z_ops_xsh:z_ops_sh 20000:0:0
vladimir_usr vladimir5577 vladimir_usr:vladimir_sh:z_ops_xsh:z_ops_sh alvaro_sh:camilo_sh:carlos_sh:christian_sh:enrique_sh:z_fin_sh:z_hr_sh alvaro_usr:camilo_usr:carlos_usr:christian_usr:enrique_usr:z_fin_xsh:z_hr_xsh 20000:0:0
z_fin_sh dummypassword alvaro_usr:alvaro_sh:camilo_usr:camilo_sh:carlos_usr:carlos_sh:christian_usr:christian_sh:enrique_usr:enrique_sh:vladimir_usr:vladimir_sh:z_fin_xsh:z_fin_sh:z_hr_xsh:z_hr_sh:z_ops_xsh:z_ops_sh 20000:0:0
z_fin_xsh dummypassword alvaro_usr:alvaro_sh:camilo_usr:camilo_sh:carlos_usr:carlos_sh:christian_usr:christian_sh:enrique_usr:enrique_sh:vladimir_usr:vladimir_sh:z_fin_xsh:z_fin_sh:z_hr_xsh:z_hr_sh:z_ops_xsh:z_ops_sh 20000:0:0
z_hr_sh dummypassword alvaro_usr:alvaro_sh:camilo_usr:camilo_sh:carlos_usr:carlos_sh:christian_usr:christian_sh:enrique_usr:enrique_sh:vladimir_usr:vladimir_sh:z_fin_xsh:z_fin_sh:z_hr_xsh:z_hr_sh:z_ops_xsh:z_ops_sh 20000:0:0
z_hr_xsh dummypassword alvaro_usr:alvaro_sh:camilo_usr:camilo_sh:carlos_usr:carlos_sh:christian_usr:christian_sh:enrique_usr:enrique_sh:vladimir_usr:vladimir_sh:z_fin_xsh:z_fin_sh:z_hr_xsh:z_hr_sh:z_ops_xsh:z_ops_sh 20000:0:0
z_ops_sh dummypassword alvaro_usr:alvaro_sh:camilo_usr:camilo_sh:carlos_usr:carlos_sh:christian_usr:christian_sh:enrique_usr:enrique_sh:vladimir_usr:vladimir_sh:z_fin_xsh:z_fin_sh:z_hr_xsh:z_hr_sh:z_ops_xsh:z_ops_sh 20000:0:0
z_ops_xsh dummypassword alvaro_usr:alvaro_sh:camilo_usr:camilo_sh:carlos_usr:carlos_sh:christian_usr:christian_sh:enrique_usr:enrique_sh:vladimir_usr:vladimir_sh:z_fin_xsh:z_fin_sh:z_hr_xsh:z_hr_sh:z_ops_xsh:z_ops_sh 20000:0:0

So the sufix _sh suggests that it is a created user that is repurposed as a share, so that’s why it gets a dummypassword for a password because nobody is going to sign in through that share. The real users are the ones ending in usr and so they get a real password because somebody is going to use it to gain read only access to shares from others. There’s a few special purpose shares, the ones beginning in z and ending in either _sh or _xsh. _xsh means exclusive share because only certain people gain access to those, so those shares are like group resources. But those in the group can share with special folders ending in _sh but they are read only to others outside the group.

I wish I could find others in the world who are attempting to use this feature of the OS to get things done and manage what has been created. Then I would form a group or association of users and try to get WD to support this feature and improve its documentation found in the online users manual, mostly on Appendix A. It’s a pretty good resource but a few difficulties have been found. One is that you don’t use a / character to separate the parameters, instead, what you do need is the tab character to separate parameters. And another thing is that the quota, that’s the seventh and last parameter of the import file, the syntax won’t work as given, through trial and error, I found out that the first number gives you the megabytes, so 20000:0:0 gives me 20 Gigabytes.

I almost forgot to mention a very important point that is nowhere documented unless I am doing something wrong in how I create the file, and that is, that in order for the import file to work, I have to run it twice, the first time it only creates the users and shares, but the permissions are not fully set, so I have to run the same file a second time, and that sets the permissions correctly.

Also I notice that being that the file gets processed in alphabetically order, I suspect, that it will process, that is, create whatever user comes first alphabetically. And so I notice that I am creating a share first, over a user given the alphabetical order. So for example, I have a user alvaro, so I name his user alvaro_usr, and I have a corresponding share for alvaro that I name alvaro_sh. Since alvaro_sh gets processed first over alvaro_usr according to alphabetical rules I assume are built into the process, then the share gets assigned to the user correctly. But if I had named it another way whereby the user got created first, it would be looking for a share that doesn’t yet exist on the first pass. So I am only hinting that it’s possible that what gets created first even on the first run is important. This is because I had another naming scheme and things didn’t go so well. I am only trying to figure out why what I have pasted here worked whereas other ways didn’t. But beyond that, I also want to figure out how to create more users and shares in a more complex file, but the problem is that I have yet to get beyond this size, and hopefully I have not reached a limit of the OS but a failure in my next level file by having introduced an error that keeps it from setting permissions.


My Cloud Personal Storage User Manual (

My Cloud OS 5 Online User Manual (
See, Managing Users and Groups
Users: * Number of Users: Enter the number of user accounts you’d like to create. The maximum number you can add appears to the right.

Have you looked at everything provided in the Dashboard for creating users and shares?

You do own a 2nd generation My Cloud, right?

From the OS5 My Cloud User Manual:

Managing Users and Groups

Import Multiple Users

  1. Click Download to download a .txt file identifying the format you’ll need to set up your user import file.
  2. Create and save your import file. For details on how to create and format your user import file, see “Appendix A: Creating a User Import File.”
  3. Click Import Users List and select the import file you created.
  4. Click Next.
  5. Review your imported user list, then click Apply.
    Your new user accounts save to your personal cloud.

The following contains information on the import file layout with examples:

Appendix A: Creating a User Import File

Thank you for responding, cat0w. I am very well versed in creating users and shares, although the manual doesn’t really state that when you create a user, you are also creating a share.
I am using MyCloud OS5 PR4100, a very capable NAS. Except that nobody seems to bother to thoroughly use the import users tool, a text file that one creates, sort of a configuration file, that will contain a line per each user, with 7 parameters per user all required in the given order, all need to be separated by a tab character, even if left blank, however I think only a few can be left blank, that would be the permissions parameters, read-write, read-only, and access denied, I think the system may produce an error if certain other parameters are left blank, but I have not thoroughly tested that out to figure which parameters cause what errors if left blank. I think that for the quotas, one may have to put a 0 at least, or maybe 0:0:0:0 to indicate no limits. But that’s a good question and something one can test out and put in a chart.

I chose not to automatically create users, as you suggest to do by entering the number of user accounts, etc. Instead, I chose to use the import users list text file and compose on that text file the users individually one line at a time. Being that the manual says " Note: You can add up to 512 users to your device." I would assume that there is a register or some variable that can hold the numbers from 0 to 511, which is 111111111 in bits, or nine bits. Whatever. I am not going to reach that limit any time soon. At most I am going to need some 50 some lines of users/shares on my users list file. I am not using all those users as users, some will be for users to log in through, and some will function as shares, where no one will sign in through them, that’s why I give them names to distinguish their specific function, for example, alvaro_usr is a user, while alvaro_sh is a share.

Thank you Bennor for bringing up the user manual which is very good overall but defective or lacking in and around the subject of importing multiple users. For one, take a look at the sample given:

Can you tell me what’s wrong with it right away? Yes, the / will not work as a separator. What will work is a tab character.
Another place where you can download a .txt file that shows the format makes a mistake or my confusion of assuming it requires a # at the beginning of each line, when it means comment.

Here it is for reference:
#Input a user’s information in the following order and separate them by TAB, and the group and share must be created and existed.
#user_name password join_to_groups shared_name(rw) shared_name(ro) shared_name(deny) user_quota
#username pw g1:g2 share1:share2 share3:share4 share5:share6 0:0:0:0
#user quota settings: user quota not set or 0, quota = 0; user quota <= group quota, quota = user quota; user quota > group quota, quota = group quota

So I finally figured out what it meant by the last line, all about quotas:
if the user quota not set or 0, the quota = 0;
if the user quota <= group quota, then quota = user quota;
if the user quota > group quota, then quota = group quota.

Now it makes sense. Being that I am not such a sophisticated programmer, I wasn’t able to decipher it, until now. I wish they would considering rewriting using something closer to English versus mathematics.

Another thing that’s wrong with the documentation on the online user manual sample for an import file to create users is that the last parameter won’t work as given. What works for me is MB:0:0 so that 20000:0:0 will give me 20 GB. Trying to add a fourth parameter, for me, won’t work.
But the manual gives the following example with four numbers in the quotas parameter.

And I don’t know what the last line means by a quota of 0:0:0:2 , how much does that add up to? 2 KB?

Again, has anybody in this small world been using the import file method of creating users/shares, and has such a person gotten it to work as given in the user manual, and how does that person implement it for their needs?

Couple of comments. One is try a different text editor. Could be how the text file is being saved or its encoding format could introduce issues causing problems with how My Cloud treats tabs, slashes, etc. If using Windows Notepad, as a troubleshooting step try using Notepad++ ( And try putting an extra blank line (or carriage return) at the end of the file).

Second, contact WD Support directly through their Contact section ( if you haven’t done so already and see if you can get bumped up to a knowledgeable support person who can give a correct answer on how the import file should be structured. Otherwise one will have to do a lot of trial and error to figure things out due to what appears to be incorrect or missing information in WD’s Knowledge Base Articles and User Manual.

Thank you Bennor. I actually use Excel to compose the file, then I select the table from one corner to its opposite corner, then I do a control-C to copy, then I open the notepad, select all if I already had something there, then I do a control-V to paste, then I save the file. Then I go to my dashboard and upload it and apply it. I did one time many months ago use Notepad++ to see if it would help me with getting the tab character right. I also downloaded and installed a clipboard viewer to see what is there when I do a Control-C. But what best helped was the Excel Spreadsheet because when I copy the table from Excel into NotePad it automatically and correctly creates the tab character between the parameters.

And I keep bugging WD Support, more recently by reporting what I had done when importing the file while screen recording, then uploading to YouTube and describing in YouTube what I was trying to do. Here follows what I submitted to WD Support, minutes ago.
{I sent WD Support a link to part 01 of four parts, but I have all four parts in a playlist at }

  • Warranty & Returns
  • My Support

Welcome Jairo Moreno




Customer (Jairo Moreno)07-Jul-2022 06:05:00 PM

Dear WD Support,
I managed to make phone contact with someone a few days ago. And I was able to get them to co-browse. I showed them that I had learned how to upload and import the user list file to create users and through parameters where one may list the folders one is giving permission to the user, one may set what users get access to what folders and by how much.
I was having a stumbling block recently where I wasn’t getting beyond a certain number of users, and the file is so complex that I didn’t know how to explain what was happening. And I would have to start with a clean slate, that is, I would have to delete all the users and the shares and run the file that does work, and then attempt to run the next stage in complexity, a file containing the previous information but with one additional user and one additional sharable folder. But since it would take so long to manually delete the users and the shares showing in the dashboard under “Users” and “Shares” I decided to do this another day and record it using XSplit screen recorder. So I did so, and it took two hours, but I split it into four parts, and uploaded it to YouTube.
The part 01 of four parts is linked here: WD MyCloud OS5 NAS ImportUserList Stage07 part 01 2022 07 06 23 28 44 - YouTube

[from the description on YouTube:] This is a screen recording lasting some two hours that I broke up into four parts. This is part 01 [of four parts].
With the user list file that I create and upload, I am able to manage my users and shares and who gets what kind of permission to each share.
Each user is given seven parameters: username, password, group, read-write access to shares, read-only access to shares, denied access to shares, and quota of storage space.
When a user is created, there is also a share created of the same name. I sometimes prefer to use the word “folder” for “share”. So when I create user p_john, I am also creating a folder of the same name. And user john should get full access to such folder, that means read-write access. But I don’t want other users to gain access to john’s folder, so I have to specify through the text file to be imported in the Users section of the Dashboard that all other users are denied access to john’s folder. So john should expect that when he signs into his space with his user name p_john [and his password] that the name of his folder is also named p_john, and that nobody else can see what’s inside that folder. I name such folders with a prefix “p_” to suggest private. In this recording I started with the following private user folders:

Being that there were six users and their private folders, I call this a stage six file, eventually I get to a stage seven file by adding one more user and their private folder and sharable folders. So in part 04 of this recording I create a file which contains everything the same but where I add a seventh user p_ivan and their private folder p_ivan, plus their sharable folder q_ivan.

I want user alvaro to sign in with username p_alvaro and password “alvaros_password” and gain complete read-write access to folder p_alvaro, folder q_alvaro, folder r_ops, and folder s_ops. So I put in the parameter for read-write the following items separated by colon: p_alvaro:q_alvaro:r_ops:s_ops. The items are separated by “:” instead of a comma. There are a few folders that alvaro can only view, so I give read-only access to the following folders: q_camilo:q_carlos:q_christian:q_enrique:q_ivan:q_vladimir:s_fin:s_hr. And I want p_alvaro to be denied access to all other user’s folders, so I need to specify in the file that for user alvaro the following folders are not accessible: p_camilo:p_carlos:p_christian:p_vladimir:p_enrique.

For some folders, I will be using them across many users, so such a folder doesn’t need primary owner user, so the user associated with such a folder has its username, but I give it a dummy password, and assuming that someone signs in with that username and password, that person is denied access to all other folders, even its own namesake folder, and I even reduce the quota of storage to something close to zero bytes.

In addition to the above listed p_ users and same named private folders, I have created sharable folders distinguished by the q_ prefix but corresponding to the same users as the p_ folders.

So q_ in this scheme means a folder that the user can use to share files with others but others cannot edit.

There are also several other folders that work across several users which can be private or sharable. These are the following:

r_ means that only a group of users have access to such a folder. s_ means that such folder can be viewed by those outside the group, so such folder can contain content that can be shared to other users outside the group.

I added a seventh user ivan with username p_ivan and folders p_ivan and q_ivan, where p_ivan is private, but q_ivan is shared to other users. By adding a line for p_ivan and a line for q_ivan, I had to increase the file increased from 18 to 20 lines, or 11% increase in lines. The number of characters increase by 18% and the words, increased by 22%. I expect to have about twenty primary users, and that means about 40 lines of users/shares plus I will have about ten special folders, the ones with the r_ and the s_ prefix, for a total of 50 lines handled by one file. That would result in a 150% increase in lines, from 20 lines to 50 lines. That could add up to about a 200% increase in words, from a file 920 words, in stage seven, to a file of 2,760 words in stage twenty to handle twenty users and twenty sharable folders and ten special folders.

Staff Account (Sean T)05-Jul-2022 12:16:00 PM

Dear Jairo Moreno,

Thank you for contacting Western Digital Customer Service and Support. My name is Sean T.

If you experience any further issue or require any type of assistance, please feel free to reply to this email.

If you have any further questions, please reply to this email and we will be happy to assist you further.

Sean T
Western Digital Service and Support

Created Time

05-Jul-2022 12:16:04 PM

Updated Time

07-Jul-2022 06:05:04 PM


My Cloud PR4100