Simplify your stack and build anything. Or everything.
Build tomorrow’s web with a modern solution you truly own.
Code-based nature means you can build on top of it to power anything.
It’s time to take back your content infrastructure.

Swap in your own React components

The Payload Admin Panel is designed to be as minimal and straightforward as possible to allow for easy customization and full control over the UI. In order for Payload to support this level of customization, Payload provides a pattern for you to supply your own React components through your Payload Config.

All Custom Components in Payload are React Server Components by default, with the exception of Custom Providers. This enables the use of the Local API directly on the front-end. Custom Components are available for nearly every part of the Admin Panel for extreme granularity and control.

There are four main types of Custom Components in Payload:

To swap in your own Custom Component, first consult the list of available components, determine the scope that corresponds to what you are trying to accomplish, then author your React component(s) accordingly.

Defining Custom Components

As Payload compiles the Admin Panel, it checks your config for Custom Components. When detected, Payload either replaces its own default component with yours, or if none exists by default, renders yours outright. While are many places where Custom Components are supported in Payload, each is defined in the same way using Component Paths.

To add a Custom Component, point to its file path in your Payload Config:

1
import { buildConfig } from 'payload'
2
3
const config = buildConfig({
4
// ...
5
admin: {
6
components: {
7
logout: {
8
Button: '/src/components/Logout#MyComponent'
9
}
10
}
11
},
12
})

Component Paths

In order to ensure the Payload Config is fully Node.js compatible and as lightweight as possible, components are not directly imported into your config. Instead, they are identified by their file path for the Admin Panel to resolve on its own.

Component Paths, by default, are relative to your project's base directory. This is either your current working directory, or the directory specified in config.admin.baseDir. To simplify Component Paths, you can also configure the base directory using the admin.importMap.baseDir property.

Components using named exports are identified either by appending # followed by the export name, or using the exportName property. If the component is the default export, this can be omitted.

1
import { buildConfig } from 'payload'
2
import { fileURLToPath } from 'node:url'
3
import path from 'path'
4
const filename = fileURLToPath(import.meta.url)
5
const dirname = path.dirname(filename)
6
7
const config = buildConfig({
8
// ...
9
admin: {
10
importMap: {
11
baseDir: path.resolve(dirname, 'src'),
12
},
13
components: {
14
logout: {
15
Button: '/components/Logout#MyComponent'
16
}
17
}
18
},
19
})

In this example, we set the base directory to the src directory, and omit the /src/ part of our component path string.

Config Options

While Custom Components are usually defined as a string, you can also pass in an object with additional options:

1
import { buildConfig } from 'payload'
2
3
const config = buildConfig({
4
// ...
5
admin: {
6
components: {
7
logout: {
8
Button: {
9
path: '/src/components/Logout',
10
exportName: 'MyComponent',
11
}
12
}
13
}
14
},
15
})

The following options are available:

PropertyDescription
clientPropsProps to be passed to the Custom Components if it's a Client Component. More details.
exportNameInstead of declaring named exports using # in the component path, you can also omit them from path and pass them in here.
pathFile path to the Custom Component. Named exports can be appended to the end of the path, separated by a #.
serverPropsProps to be passed to the Custom Component if it's a Server Component. More details.

For more details on how to build Custom Components, see Building Custom Components.

Import Map

In order for Payload to make use of Component Paths, an "Import Map" is automatically generated at app/(payload)/admin/importMap.js. This file contains every Custom Component in your config, keyed to their respective paths. When Payload needs to lookup a component, it uses this file to find the correct import.

The Import Map is automatically regenerated at startup and whenever Hot Module Replacement (HMR) runs, or you can run payload generate:importmap to manually regenerate it.

Custom Imports

If needed, custom items can be appended onto the Import Map. This is mostly only relevant for plugin authors who need to add a custom import that is not referenced in a known location.

To add a custom import to the Import Map, use the admin.dependencies property in your Payload Config:

1
import { buildConfig } from 'payload'
2
3
export default buildConfig({
4
// ...
5
admin: {
6
// ...
7
dependencies: {
8
myTestComponent: { // myTestComponent is the key - can be anything
9
path: '/components/TestComponent.js#TestComponent',
10
type: 'component',
11
clientProps: {
12
test: 'hello',
13
},
14
},
15
},
16
}
17
}

Building Custom Components

All Custom Components in Payload are React Server Components by default, with the exception of Custom Providers. This enables the use of the Local API directly on the front-end, among other things.

Default Props

To make building Custom Components as easy as possible, Payload automatically provides common props, such as the payload class and the i18n object. This means that when building Custom Components within the Admin Panel, you do not have to get these yourself.

Here is an example:

1
import React from 'react'
2
3
const MyServerComponent = async ({
4
payload
5
}) => {
6
const page = await payload.findByID({
7
collection: 'pages',
8
id: '123',
9
})
10
11
return (
12
<p>{page.title}</p>
13
)
14
}

Each Custom Component receives the following props by default:

PropDescription
payloadThe Payload class.
i18nThe i18n object.

Custom Props

To pass in custom props from the config, you can use either the clientProps or serverProps properties depending on whether your prop is serializable, and whether your component is a Server or Client Component.

1
import { buildConfig } from 'payload'
2
3
const config = buildConfig({
4
// ...
5
admin: {
6
components: {
7
logout: {
8
Button: {
9
path: '/src/components/Logout#MyComponent',
10
clientProps: {
11
myCustomProp: 'Hello, World!'
12
},
13
}
14
}
15
}
16
},
17
})
1
'use client'
2
import React from 'react'
3
4
export const MyComponent = ({ myCustomProp }: { myCustomProp: string }) => {
5
return (
6
<button>{myCustomProp}</button>
7
)
8
}

Client Components

When Building Custom Components, it's still possible to use client-side code such as useState or the window object. To do this, simply add the use client directive at the top of your file. Payload will automatically detect and remove all default, non-serializable props before rendering your component.

1
'use client'
2
import React, { useState } from 'react'
3
4
export const MyClientComponent: React.FC = () => {
5
const [count, setCount] = useState(0)
6
7
return (
8
<button onClick={() => setCount(count + 1)}>
9
Clicked {count} times
10
</button>
11
)
12
}

Accessing the Payload Config

From any Server Component, the Payload Config can be accessed directly from the payload prop:

1
import React from 'react'
2
3
export default async function MyServerComponent({
4
payload: {
5
config
6
}
7
}) {
8
return (
9
<Link href={config.serverURL}>
10
Go Home
11
</Link>
12
)
13
}

But, the Payload Config is non-serializable by design. It is full of custom validation functions, React components, etc. This means that the Payload Config, in its entirety, cannot be passed directly to Client Components.

For this reason, Payload creates a Client Config and passes it into the Config Provider. This is a serializable version of the Payload Config that can be accessed from any Client Component via the useConfig hook:

1
'use client'
2
import React from 'react'
3
import { useConfig } from '@payloadcms/ui'
4
5
export const MyClientComponent: React.FC = () => {
6
const { config: { serverURL } } = useConfig()
7
8
return (
9
<Link href={serverURL}>
10
Go Home
11
</Link>
12
)
13
}

All Field Components automatically receive their respective Field Config through props.

1
import React from 'react'
2
import type { TextFieldServerComponent } from 'payload'
3
4
export const MyClientFieldComponent: TextFieldServerComponent = ({ field: { name } }) => {
5
return (
6
<p>
7
{`This field's name is ${name}`}
8
</p>
9
)
10
}

Getting the Current Language

All Custom Components can support multiple languages to be consistent with Payload's Internationalization. To do this, first add your translation resources to the I18n Config.

From any Server Component, you can translate resources using the getTranslation function from @payloadcms/translations. All Server Components automatically receive the i18n object as a prop by default.

1
import React from 'react'
2
import { getTranslation } from '@payloadcms/translations'
3
4
export default async function MyServerComponent({ i18n }) {
5
const translatedTitle = getTranslation(myTranslation, i18n)
6
7
return (
8
<p>{translatedTitle}</p>
9
)
10
}

The best way to do this within a Client Component is to import the useTranslation hook from @payloadcms/ui:

1
'use client'
2
import React from 'react'
3
import { useTranslation } from '@payloadcms/ui'
4
5
export const MyClientComponent: React.FC = () => {
6
const { t, i18n } = useTranslation()
7
8
return (
9
<ul>
10
<li>{t('namespace1:key', { variable: 'value' })}</li>
11
<li>{t('namespace2:key', { variable: 'value' })}</li>
12
<li>{i18n.language}</li>
13
</ul>
14
)
15
}

Getting the Current Locale

All Custom Views can support multiple locales to be consistent with Payload's Localization. They automatically receive the locale object as a prop by default. This can be used to scope API requests, etc.:

1
import React from 'react'
2
3
export default async function MyServerComponent({ payload, locale }) {
4
const localizedPage = await payload.findByID({
5
collection: 'pages',
6
id: '123',
7
locale,
8
})
9
10
return (
11
<p>{localizedPage.title}</p>
12
)
13
}

The best way to do this within a Client Component is to import the useLocale hook from @payloadcms/ui:

1
'use client'
2
import React from 'react'
3
import { useLocale } from '@payloadcms/ui'
4
5
const Greeting: React.FC = () => {
6
const locale = useLocale()
7
8
const trans = {
9
en: 'Hello',
10
es: 'Hola',
11
}
12
13
return (
14
<span>{trans[locale.code]}</span>
15
)
16
}

Using Hooks

To make it easier to build your Custom Components, you can use Payload's built-in React Hooks in any Client Component. For example, you might want to interact with one of Payload's many React Contexts. To do this, you can one of the many hooks available depending on your needs.

1
'use client'
2
import React from 'react'
3
import { useDocumentInfo } from '@payloadcms/ui'
4
5
export const MyClientComponent: React.FC = () => {
6
const { slug } = useDocumentInfo()
7
8
return (
9
<p>{`Entity slug: ${slug}`}</p>
10
)
11
}

Adding Styles

Payload has a robust CSS Library that you can use to style your Custom Components similarly to Payload's built-in styling. This will ensure that your Custom Components match the existing design system, and so that they automatically adapt to any theme changes that might occur.

To apply custom styles, simply import your own .css or .scss file into your Custom Component:

1
import './index.scss'
2
3
export const MyComponent: React.FC = () => {
4
return (
5
<div className="my-component">
6
My Custom Component
7
</div>
8
)
9
}

Then to colorize your Custom Component's background, for example, you can use the following CSS:

1
.my-component {
2
background-color: var(--theme-elevation-500);
3
}

Payload also exports its SCSS library for reuse which includes mixins, etc. To use this, simply import it as follows into your .scss file:

1
@import '~payload/scss';
2
3
.my-component {
4
@include mid-break {
5
background-color: var(--theme-elevation-900);
6
}
7
}

Root Components

Root Components are those that effect the Admin Panel generally, such as the logo or the main nav.

To override Root Components, use the admin.components property in your Payload Config:

1
import { buildConfig } from 'payload'
2
3
export default buildConfig({
4
// ...
5
admin: {
6
components: {
7
// ...
8
},
9
},
10
})

For details on how to build Custom Components, see Building Custom Components.

The following options are available:

PathDescription
NavContains the sidebar / mobile menu in its entirety.
beforeNavLinksAn array of Custom Components to inject into the built-in Nav, before the links themselves.
afterNavLinksAn array of Custom Components to inject into the built-in Nav, after the links.
beforeDashboardAn array of Custom Components to inject into the built-in Dashboard, before the default dashboard contents.
afterDashboardAn array of Custom Components to inject into the built-in Dashboard, after the default dashboard contents.
beforeLoginAn array of Custom Components to inject into the built-in Login, before the default login form.
afterLoginAn array of Custom Components to inject into the built-in Login, after the default login form.
logout.ButtonThe button displayed in the sidebar that logs the user out.
graphics.IconThe simplified logo used in contexts like the the Nav component.
graphics.LogoThe full logo used in contexts like the Login view.
providersCustom React Context providers that will wrap the entire Admin Panel. More details.
actionsAn array of Custom Components to be rendered within the header of the Admin Panel, providing additional interactivity and functionality.
headerAn array of Custom Components to be injected above the Payload header.
viewsOverride or create new views within the Admin Panel. More details.

Custom Providers

As you add more and more Custom Components to your Admin Panel, you may find it helpful to add additional React Context(s). Payload allows you to inject your own context providers in your app so you can export your own custom hooks, etc.

To add a Custom Provider, use the admin.components.providers property in your Payload Config:

1
import { buildConfig } from 'payload'
2
3
export default buildConfig({
4
// ...
5
admin: {
6
components: {
7
providers: ['/path/to/MyProvider'],
8
},
9
},
10
})

Then build your Custom Provider as follows:

1
'use client'
2
import React, { createContext, useContext } from 'react'
3
4
const MyCustomContext = React.createContext(myCustomValue)
5
6
export const MyProvider: React.FC = ({ children }) => {
7
return (
8
<MyCustomContext.Provider value={myCustomValue}>
9
{children}
10
</MyCustomContext.Provider>
11
)
12
}
13
14
export const useMyCustomContext = () => useContext(MyCustomContext)
Next

Customizing Views