# 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> |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

\\


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.vngcloud.vn/vng-cloud-document/vstorage/object-storage/vstorage-hcm03/features-of-vstorage/working-with-directories-and-objects/search-directories-and-objects.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
