Sets the value for all keys within the given table to nil. This causes the
`#` operator to return `0` for the given table. The allocated capacity of
the table's array portion is maintained, which allows for efficient re-use
of the space.

```lua
local grades = {95, 82, 71, 92, 100, 60}
print(grades[4], #grades) --> 92, 6
table.clear(grades)
print(grades[4], #grades) --> nil, 0
-- If grades is filled again with the same number of entries,
-- no potentially expensive array resizing will occur
-- because the capacity was maintained by table.clear.
```

This function does not delete/destroy the table provided to it. This
function is meant to be used specifically for tables that are to be
re-used.


table.clear

table

Sets all keys in the given table to nil.


Returns an unfrozen shallow copy of the provided table.


table.clone

Returns a shallow copy of the provided table.


Given an array where all elements are strings or numbers, returns the
string `t[i] ... sep ... t[i+1] ... sep ... t[j]`. The default value for
sep is an empty string, the default for `i` is 1, and the default for `j`
is #t. If i is greater than `j`, returns the empty string.


table.concat

The table that will be converted into a string.


The string that will be concatenated between each entry in the table.


The starting index of the table concatenation.


The ending index of the table concatenation.


Returns the given range of table elements as a string where each element
is separated by the given separator.


Creates a table with the array portion allocated to the given `number` of
elements, optionally filled with the given `value`.

```lua
local t = table.create(3, "Roblox")
print(table.concat(t)) --> RobloxRobloxRoblox
```

If you are inserting into large array-like tables and are certain of a
reasonable upper limit to the number of elements, it's recommended to use
this function to initialize the table. This ensures the table's array
portion of its memory is sufficiently sized, as resizing it can be
expensive. For small quantities this is typically not noticeable.


table.create

count

value

Returns a new table populated with many instances of the specified value.


Within the given array-like table `haystack`, find the first occurrence of
value `needle`, starting from index `init` or the beginning if not
provided. If the value is not found, `nil` is returned.

A [linear search](https://en.wikipedia.org/wiki/Linear_search) algorithm
is performed.

```lua
local t = {"a", "b", "c", "d", "e"}
print(table.find(t, "d")) --> 4
print(table.find(t, "z")) --> nil, because z is not in the table
print(table.find(t, "b", 3)) --> nil, because b appears before index 3
```


table.find

haystack

needle

init

Returns the index of the first occurrence of `needle` within `haystack`
starting from `init`.


Iterates over the provided table, passing the key and value of each
iteration over to the provided function.


table.foreach

The function that will be used for the iteration. This function will
receive 2 arguments for each iteration, where the 1st argument is the
key, and the 2nd argument is the value.


This is similar to table.foreach() except that index-value pairs are
passed, not key-value pairs.


table.foreachi

The function that will be used for the iteration. This function will
receive 2 arguments for each iteration, where the 1st argument is the
index, and the 2nd argument is the value.


Similar to table.foreach() except index-value pairs are passed instead of
key-value pairs.


This function makes the given table read-only, effectively "freezing" it
in its current state. Attempting to modify a frozen table throws an error.

This freezing effect is shallow, which means that you can write to a table
within a frozen table. To deep freeze a table, call this function
recursively on all of the descending tables.


table.freeze

Returns the number of elements in the table passed.


table.getn

Inserts the provided value to the target position of the array.


table.insert

The position at which the value will be inserted.


The value that will be appended to the table.


Appends the provided value to the end of the array.


This function returns `true` if the given table is frozen and `false` if
it isn't frozen. You can freeze tables using `Library.table.freeze()`.


table.isfrozen

Whether the table is frozen from `Library.table.freeze()`.


Returns `true` if the given table is frozen and `false` if it isn't
frozen.


Returns the maximum numeric key of the provided table, or zero if the
table has no numeric keys. Gaps in the table are ignored.


table.maxn

Returns the maximum numeric key of the provided table, or zero if the
table has no numeric keys.


Copies elements from table `src` into table `dst`. Is equivalent to the
multiple assignment statement: `dst[t], ... = src[a], ..., src[b]`.

The default for `dst` is `src`. The destination range may overlap with the
source range.

Returns `dst` for convenience.


table.move

Copies the specified range of elements from one table to another.


Returns a new table with all arguments stored into keys 1, 2, etc. and
with a field "n" with the total number of arguments. Note that the
resulting table may not be a sequence.

```lua
local t = table.pack(1, 2, 3)
print(table.concat(t, ", ")) --> 1, 2, 3
```


table.pack

values...

Returns a new table containing the provided values.


Removes from array t the element at position pos, returning the value of
the removed element. When pos is an integer between `1` and `#t`, it
shifts down the elements `t[pos+1], t[pos+2], ..., t[#t]` and erases
element `t[#t]`. The index `pos` can also be `0` when `#t` is `0` or
`#t+1`; in those cases, the function erases the element `t[pos]``.


table.remove

The table that is having an element removed.


Removes the specified element from the array, shifting later elements down
to fill in the empty space if possible.


Sorts elements of array t in a given order, from `t[1]` to `t[#t]`. If
`comp` is given, then it must be a function that receives two elements and
returns true when the first element must come before the second in the
final order (so that not `comp(t[i+1],t[i])` will be true after the sort).
If `comp` is not given, then the standard Lua operator `<` is used
instead.


table.sort

comp

An optional comparison function to be used when comparing elements in
the table. This function receives two elements, `a` and `b`, and
should return true if `a < b`.


Sorts table elements using the provided comparison function or the `<`
operator.


Returns the elements from the given list. This function is equivalent to:

```lua
return list[i], list[i+1], ..., list[j]
```

By default, `i` is 1 and `j` is the length of `list`.

```lua
local t = {1, 2, 3}
local one, two, three = table.unpack(t)
print(one, two, three) -- 1 2 3
```

This same functionality is also provided by the built-in `unpack`
function.


table.unpack

list

Returns all elements from the given list as a tuple.


Overview

Guides

Tutorials

Reference

Resources

Design

Engine

Avatar

Cloud

Per API Key: {maxInPeriod} requests every {periodInSeconds} seconds per IP Address

The following API key permissions are required to call this endpoint. For more
information on generating proper keys, see [Managing API Keys]({apiKeyReferenceDocLink}).

The following endpoints are available at paths relative to the base URL.

A JSON value can be `null`, `boolean`, `string`, `number`, `array`, or `object`.

The following scopes are required for your OAuth 2.0 application to use this endpoint. For more information on how to register an OAuth 2.0 application, see [App Registration and Review]({oauth2ReferenceDocLink}).

The following objects describe payloads that are accepted or returned. See each individual endpoint for more information on when these objects are used.

This allows viewing information about your assets.

This allows uploading and updating assets to Roblox.

This allows viewing information about your groups.

This allows you to manage group join requests for your account.

This allows viewing information about your inventory.

This grants the ability to publish messages on behalf of users.

This allows listing secrets associated with your experience.

This allows creating and updating secrets associated with your experience.

Grants the ability to read place information.

Grants the ability to edit place information.

This operation grants access to publish new versions of experiences to Roblox.

Grants the ability to read experience information.

Grants the ability to edit experience information.

Grants the ability to read user's premium and verified status.

This allows you to view a user's social accounts.

This enables Single Sign-On functionality

This grants access to read your profile information

Default Value: {defaultValueStart}{defaultValueEnd}

This function returns immediately if possible, but can yield the thread that called it until it can return a value.

This member doesn’t appear in the object browser and is not intended for widespread use.

This member is only accessible only through the command bar. Attempting to access this member from scripts causes an error.

This function can’t pause the Lua thread that called it.

Attempting to access this member in scripts causes an error. You might be able to access this member from Roblox Studio's property window.

This member doesn’t appear in Roblox Studio’s Object Browser.

You can’t create an instance of this class with the Instance.new constructor.

Roblox does not replicate this member across its server-client boundary.

Lua code can’t access this member. You might be able to change its value from the property window in Roblox Studio.

This object’s replication behavior is dependent on the player who owns it.

This member is accessible only through the command bar and plugins only. Attempting to access this member from scripts causes an error.

This property is read-only and is safe to read in unsynchronized threads. Attempting to write to it causes an error.

This member is read only. Attempting to write to this member causes an error.

This member is accessible only in CoreScripts.

Only Roblox CoreScripts can access this member, and it isn’t usable by Players.

You can read and write to this property safely from multiple threads.

This class is a top-level singleton. Retrieve an instance of this class with the GetService function.

Multiple threads can potentially write to this property, so it’s unsafe to read from unsynchronized threads.

This function pauses the Lua thread that called it until it returns a result. This doesn’t interrupt other scripts.

Learn how to create successful content on Roblox with comprehensive guides, code samples, reference, and tutorials.


{pageTitle} | {SiteName}

title

Unable to add to inventory

The code sample {title} has been added to your Inventory.

Version {versionNumber} includes general performance improvements and bug fixes. Check our other release notes for status on specific improvements and bugs.

Please don't include private or personal information. Maximum {maxDescriptionLength} words.

Minimum {minDescriptionLength} words required in the description.

Release Notes for Roblox Studio Version {versionNumber}

We’re making things more awesome. Thanks for your patience.

By clicking "Continue", you will be directed to {redirectLinkStart}{redirectLinkEnd}

This site is not owned or operated by Roblox. They may have different terms and privacy policies.