Must-Have Sanity Studio Plugins in 2026

The must-have Sanity Studio plugins in 2026 are a short list: @sanity/code-input for code blocks, @sanity/table for tabular data, sanity-plugin-media for organising assets, @sanity/orderable-document-list for drag-and-drop ordering, @sanity/document-internationalization or sanity-plugin-internationalized-array for translations, sanity-plugin-iframe-pane for simple previews and @sanity/dashboard for a landing page. Add @sanity/assist if you're on a paid plan and want AI help in the editor. Just as important is knowing what you no longer need a plugin for: Structure, Presentation, Vision, comments, tasks and scheduled drafts are all built in or shipped by default.

Plugins are how the Studio grows from a schema-driven form into a tool shaped around your content. But every plugin is a dependency that has to keep up with Studio releases, so a lean, well-chosen set beats a long one. This guide covers what's built in, the plugins worth installing by category with setup code, how to check a plugin is maintained, and how to keep your plugin list healthy over time.

What's Already Built In

Before installing anything, check whether the Studio already does it. Several features that used to need plugins are now part of the sanity package or included in new projects:

Feature	How you get it	Notes
Structure tool	structureTool() from sanity/structure	The main editing tool, customised with the Structure Builder
Presentation	presentationTool() from sanity/presentation	Visual editing with your live site beside the form
Vision	visionTool() from @sanity/vision	GROQ playground, installed by npm create sanity@latest
Comments and tasks	Enabled automatically on eligible plans	Growth plan and above
Scheduled drafts	Built into the Studio on eligible plans	Replaces the deprecated @sanity/scheduled-publishing plugin
Content Releases	Built in on eligible plans	Listed as an Enterprise feature on the pricing page

If an old tutorial tells you to install @sanity/scheduled-publishing or @sanity/desk-tool, skip it. The Studio walkthrough shows where each built-in feature appears, and the pricing guide covers which plans include which features.

How to Install Any Plugin

Every Studio plugin follows the same pattern: install the package, then add it to the plugins array.

npm install @sanity/code-input

// sanity.config.ts
import { defineConfig } from 'sanity'
import { structureTool } from 'sanity/structure'
import { visionTool } from '@sanity/vision'
import { codeInput } from '@sanity/code-input'
import { schemaTypes } from './schemaTypes'

export default defineConfig({
  name: 'default',
  title: 'Company Website',
  projectId: 'your-project-id',
  dataset: 'production',
  plugins: [structureTool(), codeInput(), visionTool()],
  schema: { types: schemaTypes },
})

Plugins that add schema types, like code or table, make those types available in your fields once registered. Tool plugins add an item to the Studio's top navigation, and the order of the array decides the order of the tools.

Content Input Plugins

These add field types editors use every day.

Code Input

@sanity/code-input adds a code type with syntax highlighting, a language picker and line highlighting. It's essential for technical blogs and documentation.

defineField({
  name: 'snippet',
  type: 'code',
  options: {
    language: 'typescript',
    languageAlternatives: [
      { title: 'TypeScript', value: 'typescript' },
      { title: 'GROQ', value: 'groq' },
      { title: 'Shell', value: 'sh' },
    ],
    withFilename: true,
  },
})

The code blocks guide covers adding it to Portable Text and rendering it on the front end.

Table

@sanity/table adds a table type for simple grids such as size charts, specifications or pricing. Register table() in plugins and use type: 'table' in a field. It stores rows of strings, so for rich content in cells, model a custom array of objects instead.

Colour Input

@sanity/color-input adds a color type with a picker that stores hex, HSL and RGB values. It's useful for campaign accents or category colours that editors control:

// plugins: [colorInput()]
defineField({ name: 'accent', type: 'color', options: { disableAlpha: true } })

Markdown

sanity-plugin-markdown adds a markdown type with a Markdown editor. Portable Text is usually the better choice for structured content, but Markdown makes sense when content is shared with Git-based docs or developers prefer it. Read what Portable Text is before deciding.

Google Maps

@sanity/google-maps-input replaces the default geopoint input with a map and place search. It needs a Google Maps API key restricted to your Studio's URLs, since the key is visible in the browser.

Organisation and Workflow Plugins

Orderable Document List

Documents in Sanity don't have a built-in manual order. @sanity/orderable-document-list adds a drag-and-drop list and stores the position in an orderRank field:

// schemaTypes/category.ts
import { defineType, defineField } from 'sanity'
import { orderRankField, orderRankOrdering } from '@sanity/orderable-document-list'

export const category = defineType({
  name: 'category',
  type: 'document',
  orderings: [orderRankOrdering],
  fields: [
    orderRankField({ type: 'category' }),
    defineField({ name: 'title', type: 'string' }),
  ],
})

// structure.ts
import type { StructureResolver } from 'sanity/structure'
import { orderableDocumentListDeskItem } from '@sanity/orderable-document-list'

export const structure: StructureResolver = (S, context) =>
  S.list()
    .title('Content')
    .items([
      orderableDocumentListDeskItem({ type: 'category', title: 'Categories', S, context }),
      ...S.documentTypeListItems().filter((item) => item.getId() !== 'category'),
    ])

On the front end, sort with | order(orderRank) in GROQ. It needs a custom structure, so read customising the desk structure first if you haven't built one.

Dashboard

@sanity/dashboard adds a dashboard tool with widgets for project info, document lists and deployments. It's a good home for review queues and quick links. See building custom dashboard widgets.

Iframe Preview Pane

sanity-plugin-iframe-pane adds a "Preview" tab next to the form that loads your site in an iframe. It's the quickest way to give editors a preview if you're not ready for the Presentation tool:

import { Iframe } from 'sanity-plugin-iframe-pane'

// inside a defaultDocumentNode resolver
S.view
  .component(Iframe)
  .options({ url: (doc: any) => `https://example.com/api/preview?slug=${doc?.slug?.current}` })
  .title('Preview')

For click-to-edit overlays and live updates, move to Presentation; see visual editing in Next.js.

Media Plugins

Media Browser

sanity-plugin-media adds a Media tool for browsing, searching, tagging and organising assets, and replaces the default picker on image and file fields. It's the first plugin most content teams ask for:

import { media } from 'sanity-plugin-media'

// plugins: [structureTool(), media()]

External Asset Sources

Asset source plugins let editors pull images from elsewhere without downloading and re-uploading. sanity-plugin-asset-source-unsplash adds an Unsplash search to image fields with unsplashImageAsset().

Video

sanity-plugin-mux-input adds a mux.video type that uploads to Mux and stores a reference to the stream. Video files are large, so hosting them with a dedicated video service is usually better than storing them as Sanity file assets.

All of these, along with Sanity's Enterprise Media Library, are compared in media library plugins.

Internationalisation Plugins

There are two official approaches, and which plugin you need depends on your model:

Plugin	Model	Best for
@sanity/document-internationalization	One document per language, linked by translation metadata	Pages and posts that differ per market
sanity-plugin-internationalized-array	One document, with fields holding an array of values per language	Short fields like product names or labels
@sanity/language-filter	Hides fields for languages an editor doesn't work in	Field-level translation with many languages

import { documentInternationalization } from '@sanity/document-internationalization'

documentInternationalization({
  supportedLanguages: [
    { id: 'en', title: 'English' },
    { id: 'de', title: 'German' },
  ],
  schemaTypes: ['post', 'page'],
})

The trade-offs are covered in modelling multilingual content.

AI Assist

@sanity/assist adds AI-powered instructions to fields and documents: translate a field, summarise the body into an excerpt, generate alt text and so on, with instructions you define and reuse. It's available on the Growth plan and above.

import { assist } from '@sanity/assist'

// plugins: [structureTool(), assist()]

Treat it as a writing aid rather than a publishing pipeline. Editors should review what it generates, especially for factual content and alt text.

Developer Utilities

• sanity-plugin-utils: hooks like useListeningQuery and useProjectUsers for building your own tools and widgets.
• @sanity/cross-dataset-duplicator: copies documents and their assets between datasets from inside the Studio, handy for moving content from staging to production. The dataset migration guide covers the command-line options too.
• @sanity/vision: keep it, but consider loading it only in development or for developer roles, as described in the Vision plugin guide.

How to Judge a Plugin

The plugin directory lists hundreds of community plugins, and some haven't been updated in years. Before adding one, check:

1. Peer dependencies: run npm view <package> peerDependencies and confirm it supports your major version of sanity. Most maintained plugins currently list ^5 || ^6.0.0-0.
2. Recent releases: npm view <package> time.modified shows when it was last published.
3. Who maintains it: plugins in Sanity's official plugins repository are updated alongside the Studio.
4. Bundle impact: a plugin that pulls in a large editor or map library adds to the Studio's load time for every editor.
5. What it stores: plugins that add schema types write data in their own shape. Removing them later means migrating that data.

For example:

npm view sanity-plugin-media peerDependencies

{ react: '^19.2', sanity: '^5 || ^6.0.0-0', 'react-dom': '^19.2', 'styled-components': '^6.1' }

If nothing fits, writing your own is often simpler than it sounds. A plugin is just a config object created with definePlugin; see how to create a custom Sanity plugin.

Keeping Your Plugin List Healthy

• Update together: upgrade sanity and its plugins in the same change, then run npm run dev and click through the affected inputs.
• Watch for duplicates: two plugins that both replace the image input will conflict. Use one.
• Remove unused plugins: if no field uses a plugin's type any more, uninstall it.
• Document why: a one-line comment next to each plugin in sanity.config.ts saves the next developer from guessing.
• Prefer built-ins: when the Studio gains a feature a plugin provided, plan the switch rather than running both.

---

FAQ: Sanity Studio Plugins

---

Conclusion

In 2026, the Studio does more out of the box than ever, so the must-have plugin list is shorter than it used to be. Start with the built-ins, then add plugins for real gaps: code and table inputs for technical content, the media browser for growing asset libraries, orderable lists for manual sorting, an internationalisation plugin that matches your model, and a preview pane or dashboard for editors.

Check peer dependencies and maintenance before installing, update plugins alongside the Studio, and remove anything you no longer use. A small, maintained set of plugins keeps the Studio fast and upgrades painless, and when nothing fits, a custom plugin is only a definePlugin call away.