> ## Documentation Index
> Fetch the complete documentation index at: https://developer.box.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Create a metadata template

export const MultiRelatedLinks = ({sections = []}) => {
  if (!sections || sections.length === 0) {
    return null;
  }
  return <div className="space-y-8">
      {sections.map((section, index) => <RelatedLinks key={index} title={section.title} items={section.items} />)}
    </div>;
};

export const RelatedLinks = ({title, items = []}) => {
  const getBadgeClass = badge => {
    if (!badge) return "badge-default";
    const badgeType = badge.toLowerCase().replace(/\s+/g, "-");
    return `badge-${badge === "ガイド" ? "guide" : badgeType}`;
  };
  if (!items || items.length === 0) {
    return null;
  }
  return <div className="my-8">
      {}
      <h3 className="text-sm font-bold uppercase tracking-wider mb-4">{title}</h3>

      {}
      <div className="flex flex-col gap-3">
        {items.map((item, index) => <a key={index} href={item.href} className="py-2 px-3 rounded related_link hover:bg-[#f2f2f2] dark:hover:bg-[#111827] flex items-center gap-3 group no-underline hover:no-underline border-b-0">
            {}
            <span className={`px-2 py-1 rounded-full text-xs font-semibold uppercase tracking-wide flex-shrink-0 ${getBadgeClass(item.badge)}`}>
              {item.badge}
            </span>

            {}
            <span className="text-base">{item.label}</span>
          </a>)}
      </div>
    </div>;
};

export const Link = ({href, children, className, ...props}) => {
  const localizedHref = localizeLink(href);
  return <a href={localizedHref} className={className} {...props}>
      {children}
    </a>;
};

<RelatedLinks
  title="REQUIRED GUIDES"
  items={[
{ label: translate("Metadata template scopes"), href: "/guides/metadata/scopes", badge: "GUIDE" }
]}
/>

To create a metadata template, pass a `scope`, `displayName` and an optional set
of `fields` to the <Link href="/reference/post-metadata-templates-schema">`POST /metadata_templates/schema`</Link> API.

<CodeGroup>
  ```sh cURL theme={null}
  curl -i -X POST "https://api.box.com/2.0/metadata_templates/schema" \
       -H "authorization: Bearer <ACCESS_TOKEN>" \
       -H "content-type: application/json" \
       -d '{
        "scope": "enterprise",
        "displayName": "Customer",
        "fields": [
          {
            "type": "string",
            "key": "name",
            "displayName": "Name",
            "description": "The customer name",
            "hidden": false
          },
          {
            "type": "date",
            "key": "last_contacted_at",
            "displayName": "Last Contacted At",
            "description": "When this customer was last contacted at",
            "hidden": false
          },
          {
            "type": "enum",
            "key": "industry",
            "displayName": "Industry",
            "options": [
              {"key": "Technology"},
              {"key": "Healthcare"},
              {"key": "Legal"}
            ]
          },
          {
            "type": "multiSelect",
            "key": "role",
            "displayName": "Contact Role",
            "options": [
              {"key": "Developer"},
              {"key": "Business Owner"},
              {"key": "Marketing"},
              {"key": "Legal"},
              {"key": "Sales"}
            ]
          }
        ]
      }'
  ```

  ```typescript Node/TypeScript v10 theme={null}
  await client.metadataTemplates.createMetadataTemplate({
    scope: 'enterprise',
    displayName: templateKey,
    templateKey: templateKey,
    fields: [
      {
        type: 'string' as CreateMetadataTemplateRequestBodyFieldsTypeField,
        key: 'testName',
        displayName: 'testName',
      } satisfies CreateMetadataTemplateRequestBodyFieldsField,
      {
        type: 'float' as CreateMetadataTemplateRequestBodyFieldsTypeField,
        key: 'age',
        displayName: 'age',
      } satisfies CreateMetadataTemplateRequestBodyFieldsField,
      {
        type: 'date' as CreateMetadataTemplateRequestBodyFieldsTypeField,
        key: 'birthDate',
        displayName: 'birthDate',
      } satisfies CreateMetadataTemplateRequestBodyFieldsField,
      {
        type: 'enum' as CreateMetadataTemplateRequestBodyFieldsTypeField,
        key: 'countryCode',
        displayName: 'countryCode',
        options: [
          {
            key: 'US',
          } satisfies CreateMetadataTemplateRequestBodyFieldsOptionsField,
          {
            key: 'CA',
          } satisfies CreateMetadataTemplateRequestBodyFieldsOptionsField,
        ],
      } satisfies CreateMetadataTemplateRequestBodyFieldsField,
      {
        type: 'multiSelect' as CreateMetadataTemplateRequestBodyFieldsTypeField,
        key: 'sports',
        displayName: 'sports',
        options: [
          {
            key: 'basketball',
          } satisfies CreateMetadataTemplateRequestBodyFieldsOptionsField,
          {
            key: 'football',
          } satisfies CreateMetadataTemplateRequestBodyFieldsOptionsField,
          {
            key: 'tennis',
          } satisfies CreateMetadataTemplateRequestBodyFieldsOptionsField,
        ],
      } satisfies CreateMetadataTemplateRequestBodyFieldsField,
    ],
  } satisfies CreateMetadataTemplateRequestBody);
  ```

  ```python Python v10 theme={null}
  client.metadata_templates.create_metadata_template(
      "enterprise",
      template_key,
      template_key=template_key,
      fields=[
          CreateMetadataTemplateFields(
              type=CreateMetadataTemplateFieldsTypeField.STRING,
              key="testName",
              display_name="testName",
          ),
          CreateMetadataTemplateFields(
              type=CreateMetadataTemplateFieldsTypeField.FLOAT,
              key="age",
              display_name="age",
          ),
          CreateMetadataTemplateFields(
              type=CreateMetadataTemplateFieldsTypeField.DATE,
              key="birthDate",
              display_name="birthDate",
          ),
          CreateMetadataTemplateFields(
              type=CreateMetadataTemplateFieldsTypeField.ENUM,
              key="countryCode",
              display_name="countryCode",
              options=[
                  CreateMetadataTemplateFieldsOptionsField(key="US"),
                  CreateMetadataTemplateFieldsOptionsField(key="CA"),
              ],
          ),
          CreateMetadataTemplateFields(
              type=CreateMetadataTemplateFieldsTypeField.MULTISELECT,
              key="sports",
              display_name="sports",
              options=[
                  CreateMetadataTemplateFieldsOptionsField(key="basketball"),
                  CreateMetadataTemplateFieldsOptionsField(key="football"),
                  CreateMetadataTemplateFieldsOptionsField(key="tennis"),
              ],
          ),
      ],
  )
  ```

  ```csharp .NET v10 theme={null}
  await client.MetadataTemplates.CreateMetadataTemplateAsync(requestBody: new CreateMetadataTemplateRequestBody(scope: "enterprise", displayName: templateKey) { TemplateKey = templateKey, Fields = Array.AsReadOnly(new [] {new CreateMetadataTemplateRequestBodyFieldsField(type: CreateMetadataTemplateRequestBodyFieldsTypeField.String, key: "testName", displayName: "testName"),new CreateMetadataTemplateRequestBodyFieldsField(type: CreateMetadataTemplateRequestBodyFieldsTypeField.Float, key: "age", displayName: "age"),new CreateMetadataTemplateRequestBodyFieldsField(type: CreateMetadataTemplateRequestBodyFieldsTypeField.Date, key: "birthDate", displayName: "birthDate"),new CreateMetadataTemplateRequestBodyFieldsField(type: CreateMetadataTemplateRequestBodyFieldsTypeField.Enum, key: "countryCode", displayName: "countryCode") { Options = Array.AsReadOnly(new [] {new CreateMetadataTemplateRequestBodyFieldsOptionsField(key: "US"),new CreateMetadataTemplateRequestBodyFieldsOptionsField(key: "CA")}) },new CreateMetadataTemplateRequestBodyFieldsField(type: CreateMetadataTemplateRequestBodyFieldsTypeField.MultiSelect, key: "sports", displayName: "sports") { Options = Array.AsReadOnly(new [] {new CreateMetadataTemplateRequestBodyFieldsOptionsField(key: "basketball"),new CreateMetadataTemplateRequestBodyFieldsOptionsField(key: "football"),new CreateMetadataTemplateRequestBodyFieldsOptionsField(key: "tennis")}) }}) });
  ```

  ```swift Swift v10 theme={null}
  try await client.metadataTemplates.createMetadataTemplate(requestBody: CreateMetadataTemplateRequestBody(scope: "enterprise", displayName: templateKey, templateKey: templateKey, fields: [CreateMetadataTemplateRequestBodyFieldsField(type: CreateMetadataTemplateRequestBodyFieldsTypeField.string, key: "testName", displayName: "testName"), CreateMetadataTemplateRequestBodyFieldsField(type: CreateMetadataTemplateRequestBodyFieldsTypeField.float, key: "age", displayName: "age"), CreateMetadataTemplateRequestBodyFieldsField(type: CreateMetadataTemplateRequestBodyFieldsTypeField.date, key: "birthDate", displayName: "birthDate"), CreateMetadataTemplateRequestBodyFieldsField(type: CreateMetadataTemplateRequestBodyFieldsTypeField.enum_, key: "countryCode", displayName: "countryCode", options: [CreateMetadataTemplateRequestBodyFieldsOptionsField(key: "US"), CreateMetadataTemplateRequestBodyFieldsOptionsField(key: "CA")]), CreateMetadataTemplateRequestBodyFieldsField(type: CreateMetadataTemplateRequestBodyFieldsTypeField.multiSelect, key: "sports", displayName: "sports", options: [CreateMetadataTemplateRequestBodyFieldsOptionsField(key: "basketball"), CreateMetadataTemplateRequestBodyFieldsOptionsField(key: "football"), CreateMetadataTemplateRequestBodyFieldsOptionsField(key: "tennis")])]))
  ```

  ```java Java v10 theme={null}
  client.getMetadataTemplates().createMetadataTemplate(new CreateMetadataTemplateRequestBody.Builder("enterprise", templateKey).templateKey(templateKey).fields(Arrays.asList(new CreateMetadataTemplateRequestBodyFieldsField(CreateMetadataTemplateRequestBodyFieldsTypeField.STRING, "testName", "testName"), new CreateMetadataTemplateRequestBodyFieldsField(CreateMetadataTemplateRequestBodyFieldsTypeField.FLOAT, "age", "age"), new CreateMetadataTemplateRequestBodyFieldsField(CreateMetadataTemplateRequestBodyFieldsTypeField.DATE, "birthDate", "birthDate"), new CreateMetadataTemplateRequestBodyFieldsField.Builder(CreateMetadataTemplateRequestBodyFieldsTypeField.ENUM, "countryCode", "countryCode").options(Arrays.asList(new CreateMetadataTemplateRequestBodyFieldsOptionsField("US"), new CreateMetadataTemplateRequestBodyFieldsOptionsField("CA"))).build(), new CreateMetadataTemplateRequestBodyFieldsField.Builder(CreateMetadataTemplateRequestBodyFieldsTypeField.MULTISELECT, "sports", "sports").options(Arrays.asList(new CreateMetadataTemplateRequestBodyFieldsOptionsField("basketball"), new CreateMetadataTemplateRequestBodyFieldsOptionsField("football"), new CreateMetadataTemplateRequestBodyFieldsOptionsField("tennis"))).build())).build())
  ```

  ```java Java v5 theme={null}
  MetadataTemplate.Field metadataField = new MetadataTemplate.Field();
  metadataField.setType("string");
  metadataField.setKey("text");
  metadataField.setDisplayName("Text");

  List<MetadataTemplate.Field> fields = new ArrayList<MetadataTemplate.Field>();
  fields.add(metadataField);

  MetadataTemplate template = MetadataTemplate.createMetadataTemplate(api, "enterprise", "CustomField", "Custom Field", false, fields);

  final JsonObject jsonObject = new JsonObject();
  jsonObject.add("text", "This is a test text");

  Metadata metadata = new Metadata(jsonObject);
  boxFile.createMetadata("CustomField", metadata);
  ```

  ```py Python v4 theme={null}
  from boxsdk.object.metadata_template import MetadataField, MetadataFieldType

  fields = [
      MetadataField(MetadataFieldType.STRING, 'Name'),
      MetadataField(MetadataFieldType.DATE, 'Birthday', 'bday'),
      MetadataField(MetadataFieldType.ENUM, 'State', options=['CA', 'TX', 'NY'])
  ]
  template = client.create_metadata_template('Employee Record', fields, hidden=True)
  print(f'Metadata template ID {template.scope}/{template.templateKey} created!')
  ```

  ```csharp .NET v6 theme={null}
  var templateParams = new BoxMetadataTemplate()
  {
      TemplateKey = "marketingCollateral",
      DisplayName = "Marketing Collateral",
      Scope = "enterprise",
      Fields = new List<BoxMetadataTemplateField>()
      {
          new BoxMetadataTemplateField()
          {
              Type = "enum",
              Key = "audience",
              DisplayName = "Audience",
              Options = new List<BoxMetadataTemplateFieldOption>()
              {
                  new BoxMetadataTemplateFieldOption() { Key = "internal" },
                  new BoxMetadataTemplateFieldOption() { Key = "external" }
              }
          },
          new BoxMetadataTemplateField()
          {
              Type = "string",
              Key = "author",
              DisplayName = "Author"
          }
      }
  };
  BoxMetadataTemplate template = await client.MetadataManager.CreateMetadataTemplate(templateParams);
  ```

  ```js Node v4 theme={null}
  // Create a new template, but hide it for now until it's ready for use
  client.metadata.createTemplate(
    'Vendor Contract',
    [
     {
      type: 'date',
      key: 'signed',
      displayName: 'Date Signed'
     },
     {
      type: 'string',
      key: 'vendor',
      displayName: 'Vendor'
     },
     {
      type: 'enum',
      key: 'fy',
      displayName: 'Fiscal Year',
      options: [
       {key: 'FY17'},
       {key: 'FY18'},
       {key: 'FY19'}
      ]
     }
    ],
    {
     hidden: true,
     templateKey: 'vcontract',
     copyInstanceOnItemCopy: false
    }
   )
   .then(template => {
    /* template -> {
     id: '17f2d715-6acb-45f2-b96a-28b15efc9faa',
     templateKey: 'vcontract',
     scope: 'enterprise_12345',
     displayName: 'Vendor Contract',
     hidden: true,
     copyInstanceOnItemCopy: false,
     fields: 
     [ { type: 'date',
      key: 'signed',
      displayName: 'Date Signed',
      hidden: false },
      { type: 'string',
      key: 'vendor',
      displayName: 'Vendor',
      hidden: false },
      { type: 'enum',
      key: 'fy',
      displayName: 'Fiscal Year',
      options: 
       [ { key: 'FY17' },
       { key: 'FY18' },
       { key: 'FY19' } ],
      hidden: false } ] }
    */
   });
  ```
</CodeGroup>

<Note>
  Metadata templates can only be created for the `enterprise` scope. Templates
  can not be created for the `global` scope.
</Note>

<Warning>
  **Admin permissions required**

  Creating metadata templates is restricted to users with admin permission. This
  means that only admins, or co-admins who have been granted rights to **Create
  and edit metadata templates for your company** by the admin can use the web
  app or the API to manage templates.
</Warning>

## Template Fields

The `fields` attribute represents the set of individual fields that a user can
fill in on a template. For example, a `customer` template might have a `name`
field of type `string`.

Template fields can be of `string`, `enum`, `float`, `date`, `enum` or
`multiSelect` type. Each field requires at least a `type`, `displayName` and `key`.

```json theme={null}
{
  "scope": "enterprise",
  "displayName": "Customer",
  "fields": [
    {
      "type": "string",
      "key": "name",
      "displayName": "Name"
    }
  ]
}
```

The `enum` and `multiSelect` field types represent a dropdown list where a user
can select respectively one or many options from a list of items.

```json theme={null}
{
  "scope": "enterprise",
  "displayName": "Customer",
  "fields": [
    {
      "type": "enum",
      "key": "industry",
      "displayName": "Industry",
      "options": [
        {"key": "Technology"},
        {"key": "Healthcare"},
        {"key": "Legal"}
      ]
    }
  ]
}
```

<Card href={localizeLink("/guides/metadata/fields")} arrow title="Learn more about Metadata Template Fields" />

## Template Keys

When a metadata template is created, a `templateKey` is automatically generated
from the `displayName` of the template unless a `templateKey` is explicitly
provided. When creating the template key, any spaces and irregular
characters in the name are removed, and the string is transformed to camel case.

For example, a metadata template that is named
`Test Name (with-special_) Characters` will have a `templateKey` of
`testNameWithspecialCharacters`.

This template key is then used when making any API requests to get the
template's information or assign it to an item.

[user-types]: /platform/user-types

<RelatedLinks
  title="RELATED APIS"
  items={[
{ label: translate("Create metadata template"), href: "/reference/post-metadata-templates-schema", badge: "POST" }
]}
/>

<RelatedLinks
  title="RELATED GUIDES"
  items={[
{ label: translate("Metadata template scopes"), href: "/guides/metadata/scopes", badge: "GUIDE" },
{ label: translate("List all metadata templates"), href: "/guides/metadata/templates/list", badge: "GUIDE" },
{ label: translate("Update a metadata template"), href: "/guides/metadata/templates/update", badge: "GUIDE" }
]}
/>