# Search directories and objects

After creating a container and uploading files to that container, you can search for objects/directories through:

| <p><br></p> |
| ----------- |

1. Login into <https://vstorage.console.vngcloud.vn>
2. Select the **project** and **container** for which you want to search the object/ directory.
3. In the **Search directories and objects** box, you can search for objects/ directories in the following ways:
   1. Search by Name match by prefix:
      1. Choose Search by **Name match by prefix.**
      2. Enter the character string that is the prefix you want to search for.
      3. Press **Enter** or click the icon ![](http://docs.vngcloud.vn/download/thumbnails/67994205/image2023-9-15_15-53-6.png?version=1\&modificationDate=1701055987000\&api=v2)
   2. Search by Name match phrase:
      1. Choose Search by **Name match phrase**.
      2. Enter the character string that is part of the name you want to search for.
      3. Press **Enter** or click the icon ![](http://docs.vngcloud.vn/download/thumbnails/67994205/image2023-9-15_15-53-6.png?version=1\&modificationDate=1701055987000\&api=v2)
   3. Search by Name match all:
      1. Choose Search by **Name match all**.
      2. Enter the character string that is the full name you want to search for.
      3. Press Enter or click the icon ![](http://docs.vngcloud.vn/download/thumbnails/67994205/image2023-9-15_15-53-6.png?version=1\&modificationDate=1701055987000\&api=v2)
   4. Search by Tags:
      1. Choose Search by **Tags**.
      2. Enter the character string related to tags you want to search for.
      3. Press **Enter** or click the icon
      4. ![](http://docs.vngcloud.vn/download/thumbnails/67994205/image2023-9-15_15-53-6.png?version=1\&modificationDate=1701055987000\&api=v2)

Example: If you want to search for objects with the common prefix **file** in the object name:\
\- Choose Search by **Name match by prefix**.\
\- Enter the prefix **file**.\
\- Press **Enter** or click the icon![](http://docs.vngcloud.vn/download/thumbnails/67994205/image2023-9-15_15-53-6.png?version=1\&modificationDate=1701055987000\&api=v2)

You can learn more about how we search for results using each method in the table below:

| **Number**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | **Search by**                                                                                                                                                                                                                                              | **Example syntax**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Search result                                                                                                                                                                                                                                                                                                                                                                  | Description                                                                                                                                                                                                                                                                |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Name match all                                                                                                                                                                                                                                             | <p>Name match all <strong>abc.txt</strong> (object in the container)</p><p>Name match all <strong>directoryA/abc.txt</strong> (object in the directoryA)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | **abc.txt** distinguish between lower case and lower case.                                                                                                                                                                                                                                                                                                                     | Search by comparing the input string with the entire object name.                                                                                                                                                                                                          |
| 2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Name match by prefix                                                                                                                                                                                                                                       | <p>Name match by prefix <strong>abc</strong> (object in the container)</p><p>Name match by prefix <strong>directoryA/abc</strong> (object in the directoryA)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | **abc1, abc2**,…distinguish between lower case and lower case.                                                                                                                                                                                                                                                                                                                 | Search by comparing the input string with the prefix of the object name.                                                                                                                                                                                                   |
| 3                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Name match phase                                                                                                                                                                                                                                           | <p>Name match phase <strong>abc</strong> (object in the container)</p><p>Name match phase <strong>directoryA/abc</strong> (object in the directoryA)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | **abc1.exe, xabce.ill, 1abc.gif,**…distinguish between lower case and lower case.                                                                                                                                                                                                                                                                                              | Search by comparing whether the input string is contained in the object name.                                                                                                                                                                                              |
| 4                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | <p>Name match by wildcard</p><p><strong>(Comming soon)</strong></p>                                                                                                                                                                                        | <p>Name match by wildcard <strong>ab</strong><em><strong>c</strong> (object in the container)</em></p><p><em>Name match by wildcard <strong>?abc?</strong> (object in the container)</em></p><p><em>Name match by wildcard <strong>abc</strong></em><strong>.?xt</strong> (object in the container)</p><p>Name match by wildcard <strong>ab</strong><em><strong>c.txt</strong> (object in the container)</em></p><p><em>Name match by wildcard <strong>directoryA/abc</strong> (object in the directoryA)</em></p><p><em>Name match by wildcard <strong>directoryA/?abc?</strong> (object in the directoryA)</em></p><p><em>Name match by wildcard <strong>directoryA/abc.?xt</strong> (object in the directoryA)</em></p><p><em>Name match by wildcard <strong>directoryA/ab</strong></em><strong>c.txt</strong> (object in the directoryA)</p> | <p><strong>abc, abdc, ab)c, abUUc, ab&-Bc</strong>…distinguish between lower case and lower case.</p><p><strong>1abcx, -abc\*, 1abcD,…</strong> distinguish between lower case and lower case.</p><p><strong>abc.txt, abc123.^xt,</strong>… distinguish between lower case and lower case.</p><p><strong>ab\*c.txt</strong> distinguish between lower case and lower case.</p> | <p><em>: Matches any characters.</em></p><p><em><strong>?</strong>: Match one character.</em></p><p><em><strong>\</strong></strong></em><strong>, \</strong>?: characters \*, ? are considered as a normal character, not a wildcard operator used to search.</strong></p> |
| 5                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | <p>Name match by regex</p><p><strong>(Comming soon)</strong></p><p><br></p>                                                                                                                                                                                | <p>Name match by regex <strong>ab.</strong> (object in the container)</p><p>Name match by regex <strong>directoryA/ab.</strong> (object in the directoryA)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | **ab1,ab2,ab3, abx, ab\*,**… distinguish between lower case and lower case.                                                                                                                                                                                                                                                                                                    | **.**: Matches any character                                                                                                                                                                                                                                               |
| <p>Name match by regex <strong>abc?</strong> (object in the container)</p><p>Name match by regex <strong>directoryA/abc?</strong> (object in the directoryA)</p>                                                                                                                                                                                                                                                                                                                                                    | **ab, abc** distinguish between lower case and lower case.                                                                                                                                                                                                 | **?**: Repeat the preceding character zero or one times. Often used to make the preceding character optional.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                            |
| <p>Name match by regex <strong>ab+</strong> (object in the container)</p><p>Name match by regex <strong>directoryA/ab+</strong> (object in the directoryA)</p>                                                                                                                                                                                                                                                                                                                                                      | **ab, abb, abbb**,… distinguish between lower case and lower case.                                                                                                                                                                                         | **+**: Repeat the preceding character one or more times.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                            |
| <p>Name match by regex <strong>ab\*</strong> (object in the container)</p><p>Name match by regex <strong>directoryA/ab\*</strong> (object in the directoryA)</p>                                                                                                                                                                                                                                                                                                                                                    | **a, ab, abb, abbb**,… distinguish between lower case and lower case.                                                                                                                                                                                      | **\***: Repeat the preceding character zero or more times.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                            |
| <p>Name match by regex <strong>a{2}</strong> (object in the container)</p><p>Name match by regex <strong>directoryA/a{2}</strong> (object in the directoryA)</p><p>Name match by regex <strong>a{2,4}</strong> (object in the container)</p><p>Name match by regex <strong>directoryA/a{2,4}</strong> (object in the directoryA)</p><p>Name match by regex <strong>a{2,}</strong> (object in the container)</p><p>Name match by regex <strong>directoryA/a{2,}</strong> (object in the directoryA)</p>              | <p><strong>aa</strong> distinguish between lower case and lower case.</p><p><strong>aa, aaa, aaaa</strong> distinguish between lower case and lower case.</p><p><strong>aa, aaa, aaaa, aaaaa,</strong>… distinguish between lower case and lower case.</p> | {}: Minimum and maximum number of times the preceding character can repeat.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                            |
| Name match by regex **abc**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | <p>xyz (object in the container)</p><p>Name match by regex <strong>directoryA/abc</strong></p>                                                                                                                                                             | xyz (object in the directoryA)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | **abc, xyz** distinguish between lower case and lower case.                                                                                                                                                                                                                                                                                                                    | \|: OR operator. The match will succeed if the longest pattern on either the left side OR the right side matches.                                                                                                                                                          |
| <p>Name match by regex</p><p>Name match by regex <strong>abc(xyz)</strong> (object in the container)</p><p>Name match by regex <strong>directoryA/abc(xyz)</strong> (object in the directoryA)</p>                                                                                                                                                                                                                                                                                                                  | **abc, abcxyz** distinguish between lower case and lower case.                                                                                                                                                                                             | (): Forms a group. You can use a group to treat part of the expression as a single character.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                            |
| <p>Name match by regex <strong>\[abc]</strong> (object in the container)</p><p>Name match by regex <strong>directoryA/ \[abc]</strong> (object in the directoryA)</p><p>Name match by regex <strong>\[a-d]</strong> (object in the container)</p><p>Name match by regex <strong>directoryA/ \[a-d]</strong> (object in the directoryA)</p><p>Name match by regex <strong>\[^abc-]</strong> (object in the container)</p><p>Name match by regex <strong>directoryA/ \[^abc-]</strong> (object in the directoryA)</p> | <p><strong>a, b, c</strong> distinguish between lower case and lower case.</p><p><strong>a, b, c, d</strong> distinguish between lower case and lower case.</p><p><strong>khác a, b, c, hoặc -</strong> distinguish between lower case and lower case.</p> | <p>\[ ]: Match one of the characters in the brackets.</p><p>A <code>^</code> before a character in the brackets negates the character or range</p><p>: OR</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                            |
| <p>Name match by regex <strong>a{2,6}+d?</strong></p><p><em>Name match by regex <strong>directoryA/ a{2,6}+d?</strong></em></p><p>Name match by regex <strong>directoryA{2,6}+d?</strong><em><strong>/ a{2,6}+d?</strong></em><strong>/ a{2,6}+d?\*</strong></p>                                                                                                                                                                                                                                                    | **aaaaaaa, aaaaaaaaaaaaddddd,**… distinguish between lower case and lower case.                                                                                                                                                                            | Use nested operators within a regex search syntax.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                            |
| 6                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Tags                                                                                                                                                                                                                                                       | Tags **abc**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | Object, directory has the exact tags abc.                                                                                                                                                                                                                                                                                                                                      | Search by tags set on the object.                                                                                                                                                                                                                                          |

***

| <p>In addition to the traditional management interface, we also provide an API that allows you to integrate with your user-facing applications and tools with vStorage for data storage.</p><p>To search for objects/directories via the vStorage API, please refer to the <a href="http://docs.vngcloud.vn/display/VSEN/API+developers">API developers</a>.</p> |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

***

| <p>vStorage is also compatible with user-facing tools that use the S3 protocol. You can easily use familiar tools such as Rclone, s3cmd, Cyberduck, and more.</p><p>To search for objects/directories via the 3rd party software, please refer to the <a href="http://docs.vngcloud.vn/display/VSEN/3rd+Party+Softwares">3rd Party Softwares</a>.</p> |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

\\
