The Sanity App SDK is one of the latest features from Sanity, released in their Spring Release 2025. It lets developers easily create full applications that feel and function like Sanity’s own tools.
The App SDK provides a simple interface to a powerful tool, with built-in support for real-time collaboration, optimistic updates, permissions, and deep integration with Sanity APIs. This reduces what developers need to write and maintain, giving a massive boost to velocity. It’s ideal for creating tailored tools across teams, surfaces, or business units.
The Spring Release 2025 was Sanity’s biggest release in their history. It brought so many exciting features, focused heavily on improving the developer experience and reducing the glue work between your content operations. With it, Sanity have realised their vision of being a full Content Operating System. Learn about the whole release in our Sanity Spring Release 2025 article.
Why the App SDK?
Developers already have access to the Sanity Client and the Sanity UI packages. While they could use these to build experiences outside of the studio, developers were met with common challenges, such as ensuring it’s fully multiplayer, with real-time, optimistic updates, and live synchronisation.
Building this into their apps was added complexity, reducing velocity and requiring ongoing maintenance. It was a headache that had already been solved by Sanity in the Studio.
With the Spring Release 2025, the App SDK has been created as a means of extracting that functionality into modular, easy-to-use hooks and helpers, that let you tap into this powerful functionality through simple imports.
It’s another thing off of Developers plates that stood in the way of working solely on use-case specific features and functionality.
And with the new Sanity Dashboard, developers can embed these custom apps directly in Sanity alongside their Studio, making it effortless for users to switch between experiences.
App SDK Use Cases
The App SDK lets you rapidly build brand new content experiences, so the best use cases are where you want to access or manage your content in a different way to the Studio.
For example, a worldwide charity may expose a custom app to let workers on the ground upload candid videos of the work they’re doing so that the charity can better communicate exactly where its donations are being spent, and connect donors with to-the-minute updates, for a powerful, emotional connection.
Using a custom app for this removes the burden of CMS training, and gives a use-case specific interface that’s still backed by the powerful Content Lake and Live Content API from Sanity.
Alternatively, a financial organisation with a large set of informational articles may want to periodically ensure those articles are up-to-date. A custom app could display content freshness, flagging articles that need a review, and alerting the owner of that article to do so. It would allow for workflows such as moving all articles to someone else if someone left, and other helpful utility.
Lastly, a hard-hitting news publisher may want to view analytics on their content across all channels, with their journalists being able to dig into their top performing articles and other metrics, without leaving their Studio. Custom apps are able to easily support this with integrations to other analytics platforms, and pull in the needed data with a use-case specific UI.
How does the App SDK work?
The App SDK has an agnostic backbone written in TypeScript, as well as a React App SDK. Sanity are currently focused on the React version of the SDK, but the TypeScript backbone allows the creation of future SDKs focused on other libraries, such as Vue or Svelte.
From the React SDK, developers can import hooks and helpers to handle common functionality in their custom apps. These hooks work across multiple projects and datasets, giving you complete control.
For example, you can retrieve all your Sanity projects with the useProjects() hook. As this hook suspends, you can show custom loading UI. And if the inner component is using useProject(), you can suspend these individual project components too:
import Suspense from 'react';
import {useProjects} from '@sanity/sdk-react';
import ProjectListItem from './ProjectListItem';
import LoadingSkeleton from './LoadingSkeleton';
function ProjectsList() {
const projects = useProjects();
return (
<ul>
{projects.map((project) => (
<li key={project.id}>
<Suspense fallback={'Loading project…'}>
<ProjectListItem projectId={project.id} />
</Suspense>
</li>
))}
</ul>
);
}
function ProjectsPanel() {
return (
<Suspense fallback={<LoadingSkeleton />}>
<ProjectsList />
</Suspense>
)
}
As another example, you can retrieve documents using the useDocuments() hook, passing in a document type, and other common keys like filters or orderings, and the App SDK will return an index of document handles for these documents.
You could then pass this data to other hooks, such as useDocumentProjection() to resolve projections on reference fields:
const {data: movies} = useDocuments({
documentType: 'movie',
orderings: [{field: 'releaseDate', direction: 'desc'}],
});
const ref = useRef(null);
const {
data: {title, cast, posterImage},
}: ProjectionResults = useDocumentProjection({
...movies[0],
ref,
projection: `{
title,
'cast': array::join(castMembers[0..1].person->name, ', '),
'posterImage': poster.asset->url,
}`,
});
These hooks may look simple, but they’re handling a lot of complexity behind the scenes, ensuring your data will be optimistically updated, synchronised with the Live Content API so that it updates in real-time, and fully supported with multiplayer editing.
As it’s all Sanity, you also get built-in support for Sanity permissions without any extra steps, so you don’t need to worry about authenticating in your apps either. And any content lifecycle events you have are fully integrated out-of-the-box as well.
There are many other hooks are available, and you can see the full, documented list here.
The App SDK doesn’t provide a UI layer, but it does work well with the Sanity UI library. You can also bring your own UI library, such as Tailwind, shadcn, React Aria, or any other library you like.
App SDK Examples
Sanity have released several examples of common functionality using their App SDK, such as data-fetching and live synchronisation.
What’s more, some of the other new features from Sanity are already built using the App SDK, such as Sanity Canvas, Sanity Insights and the new Media Library.
Conclusion
The App SDK is a game changer for creating custom, use-case specific experiences in Sanity, that really feel interconnected. It’s a massive step up for developers that want to build bespoke experiences without the headache of managing real-time collaboration or authentication.
It’s a key piece in the realisation of Sanity’s vision of a full Content Operating System. If you’re still using just a Headless CMS, you should seriously consider why that is.
And if you’re ready to find out more about Sanity, email us for a chat at hello@hexdigital.com.