.default})
+
+**Entry points** act as a router that organizes your app across different view modes. Each entry point specifies the initial HTML file for the specific context. A user might experience your app inline, when it’s embedded in a post, or launch it in expanded mode for a larger, full-screen mobile experience.
diff --git a/versioned_docs/version-0.13/capabilities/server/launch_screen_and_entry_points/launch_screen_customization.md b/versioned_docs/version-0.13/capabilities/server/launch_screen_and_entry_points/launch_screen_customization.md
new file mode 100644
index 00000000..eaaa1616
--- /dev/null
+++ b/versioned_docs/version-0.13/capabilities/server/launch_screen_and_entry_points/launch_screen_customization.md
@@ -0,0 +1,168 @@
+# Launch Screen Customization
+
+## Creating Your Launch (Preview) Screen
+
+Create an HTML file that serves as your app's launch screen in inline mode. This is what users see immediately when they encounter your post. Templates include a performant and compliant preview screen.
+
+```html title="preview.html"
+
+
+
+
+
+
+
+
+```
+
+```tsx title="preview.js"
+import { requestExpandedMode } from '@devvit/web/client';
+
+document.addEventListener('DOMContentLoaded', () => {
+ const playButton = document.getElementById('play-button');
+
+ playButton.addEventListener('click', async (event) => {
+ try {
+ await requestExpandedMode(event, 'game');
+ } catch (error) {
+ console.error('Failed to enter expanded mode:', error);
+ }
+ });
+});
+```
+
+## API Reference
+
+### requestExpandedMode()
+
+Requests expanded mode for the web view. This displays the web view in a larger modal presentation on web and full screen on mobile.
+
+```tsx
+import { requestExpandedMode } from '@devvit/web/client';
+
+// Must be called from a trusted event (click, touch, etc.)
+await requestExpandedMode(event, 'game');
+```
+
+**Parameters**
+
+- `event` (PointerEvent): The gesture that triggered the request, must be a trusted event
+- `entry` (string): The destination URI name (e.g., `splash` or `game`). Entry names are the `devvit.json post.entrypoints` keys
+
+### getWebViewMode()
+
+Get the current web view mode state.
+
+```tsx
+import { getWebViewMode } from '@devvit/web/client';
+
+const currentMode = getWebViewMode(); // Returns 'inline' | 'expanded'
+
+if (currentMode === 'expanded') {
+ // Show expanded UI
+} else {
+ // Show inline UI
+}
+```
+
+### Mode Change Events
+
+Listen for mode changes to update your UI.
+
+```tsx
+import { addWebViewModeListener, removeWebViewModeListener } from '@devvit/web/client';
+
+function useWebViewMode() {
+ const [mode, setMode] = useState(getWebViewMode());
+
+ useEffect(() => {
+ const handleModeChange = (newMode: 'inline' | 'expanded') => {
+ setMode(newMode);
+ };
+
+ addWebViewModeListener(handleModeChange);
+ return () => removeWebViewModeListener(handleModeChange);
+ }, []);
+
+ return mode;
+}
+```
+
+## Complete Example
+
+```tsx title="game.tsx"
+import React, { useState, useEffect } from 'react';
+import {
+ getWebViewMode,
+ requestExpandedMode,
+ exitExpandedMode,
+ addWebViewModeListener,
+ removeWebViewModeListener,
+} from '@devvit/web/client';
+
+export function GameApp() {
+ const [mode, setMode] = useState(getWebViewMode());
+ const [gameStarted, setGameStarted] = useState(false);
+
+ useEffect(() => {
+ const handleModeChange = (newMode: 'inline' | 'expanded') => {
+ setMode(newMode);
+
+ // Pause game when exiting expanded mode
+ if (newMode === 'inline' && gameStarted) {
+ pauseGame();
+ }
+ };
+
+ addWebViewModeListener(handleModeChange);
+ return () => removeWebViewModeListener(handleModeChange);
+ }, [gameStarted]);
+
+ const handlePlayClick = async (event: React.MouseEvent) => {
+ try {
+ await requestExpandedMode(event.nativeEvent, 'game');
+ setGameStarted(true);
+ } catch (error) {
+ console.error('Could not enter expanded mode:', error);
+ // Fallback: start game inline
+ setGameStarted(true);
+ }
+ };
+
+ const handleExitClick = async (event: React.MouseEvent) => {
+ try {
+ await exitExpandedMode(event.nativeEvent);
+ } catch (error) {
+ console.error('Could not exit expanded mode:', error);
+ }
+ };
+
+ if (mode === 'inline') {
+ return (
+ Adventure Game
+Tap to play in fullscreen
+ +
+
+ );
+ }
+
+ return (
+ Adventure Game
+Tap to play in fullscreen
+ +
+
+
+ );
+}
+```
diff --git a/versioned_docs/version-0.13/capabilities/server/launch_screen_and_entry_points/splash_migration.mdx b/versioned_docs/version-0.13/capabilities/server/launch_screen_and_entry_points/splash_migration.mdx
new file mode 100644
index 00000000..79091a16
--- /dev/null
+++ b/versioned_docs/version-0.13/capabilities/server/launch_screen_and_entry_points/splash_migration.mdx
@@ -0,0 +1,119 @@
+# Migrating from Splash Screens
+
+If you're updating an existing app that used the deprecated splash parameter in `submitCustomPost()`, you'll need to migrate to HTML-based launch screens with multiple entry points.
+
+
+
+**The old splash parameter (deprecated)**
+
+```tsx
+await reddit.submitCustomPost({
+ subredditName: context.subredditName,
+ title: 'My Game',
+ splash: {
+ appDisplayName: 'My Game',
+ backgroundUri: 'background.png',
+ buttonLabel: 'Play Now',
+ description: 'An exciting game',
+ heading: 'Welcome!',
+ },
+});
+```
+
+**The new launch screen (current)**
+
+```tsx
+await reddit.submitCustomPost({ title: 'Tennis Match #37' }); // implicitly default entry
+await reddit.submitCustomPost({ title: 'Tennis Leaderboard', entry: 'leaderboard' }); // not a URI, an entry name.
+```
+
+**Migration instructions**
+
+1. Update your `devvit.json` to define both preview and game entry points.
+
+```tsx title="devvit.json"
+{
+ "post": {
+ "dir": "dist/client",
+ "entrypoints": {
+ "default": {
+ "entry": "splash.html",
+ "height": "regular",
+ "inline": true
+ },
+ "game": {
+ "entry": "index.html",
+ "height": "tall"
+ }
+ }
+ }
+}
+```
+
+Esbuild would probably be simpler and add fewer dependencies, but you can also use Vite.
+
+```tsx
+{
+ ...all your normal vite nonsense...
+ build: {
+ input: ['splash.html', 'game.html'], <-- add your entrypoints
+ ...
+ }
+}
+```
+
+2. Create a `splash.html` file with a button to launch into the game.
+
+```html title="splash.html"
+
+
+
+
+
+
+
+
+```
+
+```tsx title="preview.js"
+import { requestExpandedMode } from '@devvit/web/client';
+
+document.addEventListener('DOMContentLoaded', () => {
+ const playButton = document.getElementById('play-button');
+
+ playButton.addEventListener('click', async (event) => {
+ try {
+ await requestExpandedMode(event, 'game');
+ } catch (error) {
+ console.error('Failed to enter expanded mode:', error);
+ }
+ });
+});
+```
+
+3. Update your post creation to use the default (preview) entry point.
+
+```tsx
+await reddit.submitCustomPost({
+ subredditName: context.subredditName,
+ title: 'My Game',
+ entry: 'default',
+});
+```
+
+Now your app will load the launch screen in inline mode. When users click "Play Now", the game will transition to expanded mode (`index.html`).
diff --git a/versioned_docs/version-0.13/capabilities/server/launch_screen_and_entry_points/view_modes_entry_points.md b/versioned_docs/version-0.13/capabilities/server/launch_screen_and_entry_points/view_modes_entry_points.md
new file mode 100644
index 00000000..d43dc440
--- /dev/null
+++ b/versioned_docs/version-0.13/capabilities/server/launch_screen_and_entry_points/view_modes_entry_points.md
@@ -0,0 +1,180 @@
+# Setting up view modes and entry points
+
+## View modes
+
+Devvit apps support two view modes:
+
+**Inline Mode**
+
+- **What it is**: Your app loads directly within the post unit
+- **User experience**: Users see your app content immediately without clicking
+- **Use case**: Preview screens, game menus, leaderboards, or any content that works well in a post-sized container
+- **Requirements**: Only respond to taps and clicks, load quickly, and respect post boundaries
+
+**Expanded Mode**
+
+- **What it is**: Your app displays in a larger modal (web) or full screen (mobile)
+- **User experience**: Users click to enter a dedicated experience
+- **Use case**: Full games, longer load times, detailed interfaces, or any content that needs more space or full gesture support
+- **Trigger**: User-initiated only (button click, gesture, etc.)
+
+## Multiple entry points
+
+Multiple entry points let the user start the game from different contexts or states. For example, you can have a button that launches into a leaderboard view and another for a specific game mode, each of these would be configured as an entry point for your app. Define multiple entry points in your `devvit.json`. If you use the [Devvit Vite plugin](../../../guides/tools/vite), it automatically infers the client build inputs from these entrypoints, so you don't need to maintain a custom Rollup `input` list.
+
+```js title="devvit.json"
+{
+ "post": {
+ "dir": "dist/client",
+ "entrypoints": {
+ "default": {
+ "entry": "src/client/preview.html",
+ "height": "regular",
+ "inline": true
+ },
+ "game": {
+ "entry": "src/client/game.html"
+ },
+ "leaderboard": {
+ "entry": "src/client/leaderboard.html"
+ }
+ }
+ }
+}
+```
+
+```ts title="vite.config.ts"
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import tailwind from "@tailwindcss/vite";
+import { devvit } from "@devvit/start/vite";
+
+export default defineConfig({
+ plugins: [react(), tailwind(), devvit()],
+});
+```
+
+**File Structure Example**
+
+```tsx
+your-app/
+├── devvit.json
+├── vite.config.ts
+├── src/
+│ ├── server/
+│ │ └── index.ts
+│ └── client/
+│ ├── preview.html
+│ ├── game.html
+│ ├── leaderboard.html
+│ └── styles.css
+└── dist/ // Built files after compilation
+ └── client/ // This is what "dir" points to
+ ├── preview.html
+ ├── game.html
+ ├── leaderboard.html
+ └── styles.css
+```
+
+The `dir` property specifies where your built client files are located. With the Devvit Vite plugin, the `entry` values point at your source HTML files (for example `src/client/preview.html`), and the plugin outputs the matching files into `dist/client` during `vite build`.
+
+### Creating posts with specific entry points
+
+Use the `entry` parameter when creating posts to specify which entry point from your `devvit.json` configuration to use. The entry value must match one of the keys defined in `post.entrypoints`.
+
+```tsx title="server/index.ts"
+import { reddit } from '@devvit/web/server';
+
+// Create a post using the default entrypoint
+async function createDefaultPost(context: any) {
+ return await reddit.submitCustomPost({
+ subredditName: context.subredditName!,
+ title: 'Adventure Game',
+ entry: 'default',
+ postData: {
+ gameState: 'menu',
+ },
+ });
+}
+
+// Create a post using a specific entrypoint
+async function createGamePost(context: any) {
+ return await reddit.submitCustomPost({
+ subredditName: context.subredditName!,
+ title: 'Adventure Game',
+ entry: 'game', // Must match a key in devvit.json entrypoints
+ postData: {
+ gameState: 'active',
+ initialized: true,
+ },
+ });
+}
+```
+
+**How it works**
+
+- If `entry` is not specified, the `default` entry point is used automatically.
+- The `entry` value must match a key defined in your `devvit.json post.entrypoints` object.
+- Each entry point can have its own HTML file and height setting.
+- Invalid entry point names will cause an error.
+
+### Switching between view modes
+
+You can transition from inline mode to expanded mode with a different entry point, like this:
+
+```tsx
+import { requestExpandedMode } from '@devvit/web/client';
+
+// Switch to the 'game' entrypoint in expanded mode
+const handleStartGame = async (event: React.MouseEvent) => {
+ try {
+ await requestExpandedMode(event.nativeEvent, 'game');
+ } catch (error) {
+ console.error('Failed to enter expanded mode:', error);
+ }
+};
+```
+
+## Inline mode requirements
+
+All Devvit web view apps load in inline mode by default. Your app loads directly in the post unit without requiring users to click to expand.
+
+Apps must meet these requirements for approval and featuring:
+
+1. **Performance**
+
+- Optimize for mobile devices and slower connections
+- Load initial content in under 1 second
+- Achieve a [Lighthouse](https://developer.chrome.com/docs/lighthouse/overview) score >80.
+ - To find your Lighthouse score you can follow these steps:
+ 1. Open your inline post
+ 2. Open Developer Tools in Chrome and navigate to the elements tab
+ 3. Find the Devvit web view element in the DOM and open it in a new tab
+ 4. Open Developer Tools in the new tab and navigate to Lighthouse
+ 5. Ensure you have mobile selected and select Analyze Page Load
+
+
+
+2. **Gesture compliance**
+
+- **Only tap or click input is allowed**
+- No scroll traps or scroll hijacking
+- No zoom or pan interference
+- Users must be able to scroll past your post naturally
+
+3. **Responsive design**
+
+- Content must work across all viewport sizes (use chrome devtools to test your app's responsiveness)
+- Keep in mind that the majority of users are on mobile devices
+
+4. **User-initiated expanded mode**
+
+- Apps cannot auto-launch into expanded mode or auto-close without a user action
+- Must have explicit user interaction (clearly labeled button or action)
+- Default view should respect standard post boundaries
+
+5. **Safe use of sound**
+
+- Audio should not play unless there is a user interaction
+- Include a button to mute in your game
+- Use the visibilityChange handler to mute any sounds if a user scrolls away
diff --git a/versioned_docs/version-0.13/capabilities/server/media-uploads.mdx b/versioned_docs/version-0.13/capabilities/server/media-uploads.mdx
new file mode 100644
index 00000000..72841273
--- /dev/null
+++ b/versioned_docs/version-0.13/capabilities/server/media-uploads.mdx
@@ -0,0 +1,206 @@
+# Media Uploads
+
+:::warning
+Apps can only display media hosted on Reddit
+:::
+
+You can upload media to Reddit at runtime using the `media` capability. This is different than static images, which you bundle with your app's client assets.
+
+Runtime media is useful for embedding media in RTJSON (Posts and Comments) as well as displaying it within an interactive post app.
+
+## Enabling media uploads
+Enable the `media` permission in your `devvit.json` file.
+```json title="devvit.json"
+{
+ "permissions": {
+ "media": true
+ }
+}
+```
+
+## Media uploads
+On the server, pass a remote URL or data URL to `media.upload()` to upload an image, GIF, or video and get a Reddit-hosted asset you can safely render in posts, comments, and rich text.
+
+### Response type
+`media.upload()` returns:
+
+```ts
+type MediaAsset = {
+ mediaId: string;
+ mediaUrl: string;
+};
+```
+
+- `mediaId`: Reddit media asset ID.
+- `mediaUrl`: Reddit CDN URL (use this in rich text or UI).
+
+### `media.upload()` input
+`media.upload()` expects an object with:
+
+- `url`: The media URL (remote URL or data URL).
+- `type`: The media kind (`'image'`, `'gif'`, or `'video'`).
+
+```ts
+type UploadMediaOptions = {
+ url: string; // remote URL or data URL
+ type: 'image' | 'gif' | 'video';
+};
+```
+
+Use `type: 'image'` for PNG, JPEG, and WEBP uploads.
+
+### Basic server usage
+```ts title="server/index.ts"
+import { media } from '@devvit/web/server';
+
+const uploaded = await media.upload({
+ url: 'https://example.com/my-image.png',
+ type: 'image',
+});
+
+// uploaded.mediaId
+// uploaded.mediaUrl
+```
+
+### Example: API endpoint returning upload response
+```ts title="server/index.ts"
+import { media } from '@devvit/web/server';
+
+app.post('/api/upload', async (c) => {
+ const { url, type } = await c.req.json<{
+ url: string;
+ type: 'image' | 'gif' | 'video';
+ }>();
+
+ const uploaded = await media.upload({ url, type });
+
+ return c.json({
+ mediaId: uploaded.mediaId,
+ mediaUrl: uploaded.mediaUrl,
+ });
+});
+```
+
+### Example: submit a post with uploaded media using RichTextBuilder
+```ts title="server/index.ts"
+import { media } from '@devvit/web/server';
+import { reddit, RichTextBuilder } from '@devvit/reddit';
+
+const uploaded = await media.upload({
+ url: 'https://example.com/cover.png',
+ type: 'image',
+});
+
+const richtext = new RichTextBuilder()
+ .paragraph((p) => {
+ p.text({ text: 'Uploaded image:' });
+ })
+ .paragraph((p) => {
+ p.image({
+ mediaUrl: uploaded.mediaUrl,
+ caption: 'Rendered from media.upload()',
+ });
+ });
+
+await reddit.submitPost({
+ subredditName: 'my_subreddit',
+ title: 'Post with uploaded media',
+ richtext,
+});
+```
+
+### Example: submit a comment with uploaded media using RichTextBuilder
+```ts title="server/index.ts"
+import { media } from '@devvit/web/server';
+import { reddit, RichTextBuilder } from '@devvit/reddit';
+
+// Parent can be a post id (t3_...) or comment id (t1_...)
+const parentId = 't3_abc123';
+
+const uploaded = await media.upload({
+ url: 'https://example.com/reply-image.png',
+ type: 'image',
+});
+
+const commentRichtext = new RichTextBuilder()
+ .paragraph((p) => {
+ p.text({ text: 'Here is the image:' });
+ })
+ .paragraph((p) => {
+ p.image({ mediaUrl: uploaded.mediaUrl });
+ });
+
+await reddit.submitComment({
+ id: parentId,
+ richtext: commentRichtext,
+});
+```
+
+### Example: raw RTJSON (without RichTextBuilder)
+If you prefer raw RTJSON, pass an object directly to `richtext`:
+
+```ts title="server/index.ts"
+import { media } from '@devvit/web/server';
+import { reddit } from '@devvit/reddit';
+
+const uploaded = await media.upload({
+ url: 'https://example.com/raw-rtjson.png',
+ type: 'image',
+});
+
+await reddit.submitComment({
+ id: 't3_abc123',
+ richtext: {
+ document: [
+ {
+ e: 'par',
+ c: [{ e: 'text', t: 'Raw RTJSON image:' }],
+ },
+ {
+ e: 'par',
+ c: [{ e: 'img', mediaUrl: uploaded.mediaUrl, c: 'RTJSON image node' }],
+ },
+ ],
+ },
+});
+```
+
+
+## Canvas screenshots
+
+The Canvas API is fully supported by Devvit. You can use it to capture screenshots of your app's current state and upload them using the media API.
+
+This is useful for letting users share their progress, achievements, or creations as image posts. Sharing screenshots is an effective way to build community engagement and increase visibility for your app.
+
+```ts title="client/screenshot.ts"
+// Capture the canvas as a data URL
+const canvas = document.querySelector('canvas');
+const dataUrl = canvas.toDataURL('image/png');
+
+// Send to server endpoint for upload
+const response = await fetch('/api/upload-screenshot', {
+ method: 'POST',
+ body: JSON.stringify({ image: dataUrl }),
+});
+```
+
+```ts title="server/index.ts"
+import { media } from '@devvit/web/server';
+
+app.post('/api/upload-screenshot', async (c) => {
+ const { image } = await c.req.json();
+
+ const response = await media.upload({
+ url: image, // data URL from canvas
+ type: 'image',
+ });
+
+ return c.json({ url: response.mediaUrl });
+});
+```
+
+## Notes and limits
+
+- Supported image upload formats: PNG, JPEG, WEBP, and GIF.
+- Maximum upload size: 20 MB.
+- WEBP uploads may be converted to JPEG in the returned Reddit URL.
diff --git a/versioned_docs/version-0.13/capabilities/server/overview.md b/versioned_docs/version-0.13/capabilities/server/overview.md
new file mode 100644
index 00000000..fdd17182
--- /dev/null
+++ b/versioned_docs/version-0.13/capabilities/server/overview.md
@@ -0,0 +1,45 @@
+# Server Overview
+
+Devvit offers a wide variety of features that help you integrate your app with Reddit's APIs, scale your app free of charge using Reddit's backend, and more. The features in this section are executed on the server side. They can be imported in [Devvit Web](../devvit-web/devvit_web_overview.mdx) applications, as well as Mod Tools.
+
+Below is a brief explanation of all features in this section:
+
+## [HTTP fetch](./http-fetch.mdx)
+
+Allows you to make HTTP requests to external servers, subject to a review of the specific domains you are requesting from.
+
+## [Media uploads](./media-uploads.mdx)
+
+Allows you to build apps where the end user can upload custom images to Reddit's CDN. Uploaded media is subject to the same safety checks as every other media content uploaded to Reddit, ensuring community safety.
+
+## [Reddit API](./reddit-api.mdx)
+
+Allows you to query information from Reddit such as comments, posts and upvotes. Limited to installation scope of the application.
+
+## [Data storage (Redis)](./redis.mdx)
+
+Allows you to store app data in a key-value database, free of charge. Limited to the installation scope of the application.
+
+## [Scheduler](./scheduler.mdx)
+
+Allows you to run automated server-side tasks on a schedule, for example, checking for updates every hour.
+
+## [Secrets storage](./settings-and-secrets.mdx)
+
+Allows you to build an app where the moderator can store secret keys in a safe and scalable way. For example, if your app needs the installing moderator to provide their own keys to an external API.
+
+## [Triggers](./triggers.mdx)
+
+Allows you to run automated server-side tasks when certain events happen on Reddit, for example: when a new post is created, or when a new comment is created.
+
+## [User actions](./userActions.mdx)
+
+Allows you to execute some actions, like posting or commenting, on behalf of the user. This means that these new posts or comments will not show up as created by the app, but by the user that is currently using the app. Access to this feature is subject to review by Admins.
+
+## [Text fallback](./text_fallback.mdx)
+
+Allows you to specify how your interactive post is displayed on platforms that don't support Devvit, for example old.reddit.com
+
+## [Cache helper](./cache-helper.mdx)
+
+Allows you to cache fetch requests on the server side, reducing the number of requests made to external APIs and improving performance.
diff --git a/versioned_docs/version-0.13/capabilities/server/post-data.mdx b/versioned_docs/version-0.13/capabilities/server/post-data.mdx
new file mode 100644
index 00000000..dfcc117c
--- /dev/null
+++ b/versioned_docs/version-0.13/capabilities/server/post-data.mdx
@@ -0,0 +1,298 @@
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# Post data
+
+You can attach small amounts of data (2KB) to a post when creating it and update this data using the `postData` capability. This enables dynamic, stateful experiences available on posts without a server call. Post data is scoped to the post, not users.
+
+Post data is useful for storing game state, scores, or any other information that needs to persist with the post and be shared across all users.
+
+Post data is set when you submitPost and apps can access from the context object or do a server side call to update the post data on a Post object. For larger data, use [redis](./redis.mdx).
+
+:::note
+Post data is sent to the client. Never store secrets or sensitive information.
+:::
+
+## Creating posts with data
+When creating a post, include the `postData` parameter with your custom data object.
+
+My Game
+An exciting game
+ +
+
+ );
+}
+```
+
+## Limitations
+Post data supports:
+- JSON-serializable objects only
+- Maximum size of 2KB
+- Data persists with the post lifecycle (deleted when post is deleted)
+- Updates to post data don't trigger automatic re-renders. Implement polling or refresh mechanisms as needed
diff --git a/versioned_docs/version-0.13/capabilities/server/reddit-api.mdx b/versioned_docs/version-0.13/capabilities/server/reddit-api.mdx
new file mode 100644
index 00000000..a2b32781
--- /dev/null
+++ b/versioned_docs/version-0.13/capabilities/server/reddit-api.mdx
@@ -0,0 +1,107 @@
+# Reddit API Overview
+
+The Reddit API allows you to read and write Reddit content such as posts / comments / upvotes, in order to integrate your app's behavior with the content of the community it's installed in.
+
+:::note
+Unlike traditional Reddit API usage, you don't need to create an app at [reddit.com/prefs/apps](https://www.reddit.com/prefs/apps) or manage API keys. Devvit handles authentication automatically when you enable the `reddit` permission in your app.
+:::
+
+## Private user data
+
+Devvit apps cannot access certain private user data. This data is private to the logged-in user and is not exposed through the Devvit platform:
+
+- **Subscribed subreddits** - The list of subreddits a user is subscribed to
+- **Upvoted and downvoted content** - Posts and comments the user has voted on
+- **Saved content** - Posts and comments the user has saved
+- **Recently viewed posts** - The user's browsing history
+- **Private profile information** - Any profile data that is not publicly visible
+- **Follows and friends** - The list of users someone follows (on reddit.com) or has friended (on Old Reddit)
+
+## The Reddit client
+
+Here's how to obtain a reference to the Reddit client
+
+```json title="devvit.json"
+{
+ "permissions": {
+ "reddit": true
+ }
+}
+```
+
+```ts title="server/index.ts"
+import { reddit } from '@devvit/reddit';
+```
+
+## Reddit Thing IDs
+
+Reddit uses prefixed IDs (called "things") to identify different types of content:
+
+| Prefix | Type | Example | Description |
+| ------ | ---- | ------- | ----------- |
+| `t1_` | Comment | `t1_abc123` | A comment on a post or reply to another comment |
+| `t2_` | User | `t2_xyz789` | A Reddit user account |
+| `t3_` | Post | `t3_def456` | A post |
+| `t4_` | Message | `t4_ghi012` | A private message |
+| `t5_` | Subreddit | `t5_jkl345` | A subreddit community |
+
+These IDs are returned by API methods and used when referencing specific content:
+
+```ts
+// Get a post by its full ID
+const post = await reddit.getPostById('t3_abc123');
+
+// Get a comment by its full ID
+const comment = await reddit.getCommentById('t1_xyz789');
+
+// A comment's parentId can be either a post (t3_) or another comment (t1_)
+const parentId = comment.parentId; // 't3_abc123' or 't1_def456'
+```
+
+## Example usage
+
+### Submitting a post
+```ts
+import { Devvit } from '@devvit/public-api';
+import { context, reddit } from '@devvit/web/server';
+
+export const createPost = async () => {
+ const { subredditName } = context;
+ if (!subredditName) {
+ throw new Error('subredditName is required');
+ }
+
+ return await reddit.submitCustomPost({
+ userGeneratedContent: {
+ text: 'Hello there! This is a post from a Devvit app',
+ },
+ subredditName: subredditName,
+ title: 'New Post',
+ entry: 'default',
+ });
+};
+```
+
+### Submitting a comment
+
+:::note
+Auto-comments should be used to spark conversation in the post comments, but you should avoid lower-signal updates (e.g., level/progress pings).
+:::
+
+
+```ts
+import { context, reddit } from '@devvit/web/server';
+
+export const createComment = async () => {
+ const { subredditName } = context;
+ if (!subredditName) {
+ throw new Error('subredditName is required');
+ }
+
+ reddit.submitComment({
+ postId: 't3_123456', // Replace with the actual post ID
+ text: 'This is a comment from a Devvit app',
+ runAs: 'USER' // Optional: specify the user to run as
+ });
+};
+```
diff --git a/versioned_docs/version-0.13/capabilities/server/redis.mdx b/versioned_docs/version-0.13/capabilities/server/redis.mdx
new file mode 100644
index 00000000..61a62107
--- /dev/null
+++ b/versioned_docs/version-0.13/capabilities/server/redis.mdx
@@ -0,0 +1,1289 @@
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# Redis
+
+You can add a database to your app to store and retrieve data. The Redis plugin is designed to be fast, scalable, and secure. It supports a subset of the full Redis API, including:
+
+- [Transactions](#transactions) for things like counting votes atomically in polls
+- [String operations](#strings) for persisting information
+- [Number operations](#numbers) for incrementing numbers
+- [Sorted sets](#sorted-set) for creating leaderboards
+- [Hashes](#hash) for managing a collection of key-value pairs
+- [Bitfields](#bitfield) for efficient operation on sequences of bits
+
+Each installation of an app is uniquely name-spaced, which means Redis data is siloed by subreddit. Keep in mind that there won’t be a single source of truth for all installations of your app, since each app installation can only access the data that it has stored in the Redis database.
+
+## Limits and quotas
+
+- Max commands per second: 40000
+- Max request size: 5 MB
+- Max storage: 500 MB
+- [Pipelining](https://redis.io/docs/latest/develop/using-commands/pipelining/) is not supported
+- [Sets](https://redis.io/docs/latest/commands/set/) - only sorted sets are supported
+- No support for listing keys
+- No support for lua scripts to execute custom logic on redis server
+
+All limits are applied at a per-installation granularity.
+
+## Examples
+
+### Menu actions
+
+```js title="devvit.json"
+ {
+ "menuActions": [
+ {
+ "label": "Redis Test",
+ "endpoint": "/internal/menu/redis-test",
+ "forUserType": "moderator",
+ "location": "subreddit"
+ }
+ ]
+ }
+ ```
+ Post Data:
+ {JSON.stringify(context.postData, null, 2) ?? 'undefined'}
+
+
+
+### Batch read/write
+
+| **Command** | **Action** | **Limits** |
+| -------------------------------------- | ----------------------------------------------- | ---------- |
+| [mGet](https://redis.io/commands/mget) | Returns the values of all specified keys. | None |
+| [mSet](https://redis.io/commands/mset) | Sets the given keys to their respective values. | Subject to storage quota gating (writes may be blocked if quota exceeded) |
+
++ Code Example +
+ +```tsx +async function simpleReadWriteExample() { + // Set a key + await redis.set('color', 'red'); + + // Check if a key exists + console.log('Key exists: ' + (await redis.exists('color'))); + + // Get a key + console.log('Color: ' + (await redis.get('color'))); + + // Get the type of a key + console.log('Type: ' + (await redis.type('color'))); + + // Delete a key + await redis.del('color'); +} +``` + +```bash +Color: red +Type: string +``` + +
+
+
+### Strings
+
+| **Command** | **Action** | **Limits** |
+| ---------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- | ---------- |
+| [getRange](https://redis.io/commands/getrange) | Returns the substring of the string value stored at key, determined by the offsets start and end (both are inclusive). | None |
+| [setRange](https://redis.io/commands/setrange) | Overwrites part of the string stored at key, starting at the specified offset, for the entire length of value. | Subject to storage quota gating (writes may be blocked if quota exceeded) |
+| [strLen](https://redis.io/commands/strlen) | Returns the length of the string value stored at key. | None |
+
++ Code Example +
+ +```tsx +async function batchReadWriteExample() { + // Set multiple keys at once + await redis.mSet({ + name: 'Devvit', + occupation: 'Developer', + yearsOfExperience: '9000', + }); + + // Get multiple keys + console.log('Result: ' + (await redis.mGet(['name', 'occupation']))); +} +``` + +```bash +Result: Devvit,Developer +``` + +
+
+
+### Hash
+
+Redis hashes can store up to ~ 4.2 billion key-value pairs. We recommend using hash for managing collections of key-value pairs whenever possible and iterating over it using a combination of `hscan`, `hkeys` and `hgetall`.
+
+| **Command** | **Action** | **Limits** |
+| --------------------------------------------- | --------------------------------------------------------------------------------- | ---------- |
+| [hGet](https://redis.io/commands/hget) | Returns the value associated with field in the hash stored at key. | None |
+| [hMGet](https://redis.io/commands/hmget) | Returns the value of all specified field in the hash stored at multiple keys. | May be disabled for your app (allowlisted feature) |
+| [hSet](https://redis.io/commands/hset/) | Sets the specified fields to their respective values in the hash stored at key. | Subject to storage quota gating (writes may be blocked if quota exceeded) |
+| [hSetNX](https://redis.io/commands/hsetnx/) | Sets field in the hash stored at key to value, only if field does not yet exist.ƒ | Subject to storage quota gating (writes may be blocked if quota exceeded) |
+| [hDel](https://redis.io/commands/hdel/) | Removes the specified fields from the hash stored at key. | None |
+| [hGetAll](https://redis.io/commands/hgetall/) | Returns a map of fields and their values stored in the hash. | None |
+| [hKeys](https://redis.io/commands/hkeys/) | Returns all field names in the hash stored at key. | None |
+| [hScan](https://redis.io/commands/hscan/) | Iterates fields of Hash types and their associated values. | No server-side cap; uses requested count |
+| [hIncrBy](https://redis.io/commands/hincrby/) | Increments the score of member in the sorted set stored at key by value. | Subject to storage quota gating (writes may be blocked if quota exceeded) |
+| [hLen](https://redis.io/commands/hlen/) | Returns the number of fields contained in the hash stored at key. | None |
+
++ Code Example +
+ +```tsx +async function stringsExample() { + // First, set 'word' to 'tacocat' + await redis.set('word', 'tacocat'); + + // Use getRange() to get the letters in 'word' between index 0 to 3, inclusive + console.log('Range from index 0 to 3: ' + (await redis.getRange('word', 0, 3))); + + // Use setRange() to insert 'blue' at index 0 + await redis.setRange('word', 0, 'blue'); + + console.log('Word after using setRange(): ' + (await redis.get('word'))); + + // Use strLen() to verify the word length + console.log('Word length: ' + (await redis.strLen('word'))); +} +``` + +```bash +Range from index 0 to 3: taco +Word after using setRange(): bluecat +Word length: 7 +``` + +
+
+
+### Numbers
+
+| **Command** | **Action** | **Limits** |
+| ------------------------------------------ | ------------------------------------------------- | ---------- |
+| [incrBy](https://redis.io/commands/incrby) | Increments the number stored at key by increment. | Subject to storage quota gating (writes may be blocked if quota exceeded) |
+
++ Code Examples +
+ +**Example 1** + +```tsx +// Example using hGet(), hSet(), and hDel() +async function hashExample1() { + // Set 'inventory' with multiple fields and values + await redis.hSet('inventory', { + sword: '1', + potion: '4', + shield: '2', + stones: '8', + }); + + // Get the value of 'shield' from 'inventory' + console.log('Shield count: ' + await redis.hGet('inventory', 'shield')); + + // Get the values of both of 'shield' and 'potion' from 'inventory' + console.log('Shield and potion count: ' + await redis.hMGet('inventory', ['shield', 'potion'])); + + // Delete some fields from 'inventory' + console.log( + 'Number of fields deleted: ' + + await redis.hDel('inventory', ['sword', 'shield', 'stones']); + ); +} +``` + +```bash +Shield count: 2 +Shield and potion count: 2,4 +Number of fields deleted: 3 +``` + +--- + +**Example 2** + +```tsx +// Example using hGetAll() +async function hashExample2() { + // Set 'groceryList' to fields containing products with quantities + await redis.hSet('groceryList', { + eggs: '12', + apples: '3', + milk: '1', + }); + + // Get the groceryList record + const record = await redis.hGetAll('groceryList'); + + if (record != undefined) { + console.log('Eggs: ' + record.eggs + ', Apples: ' + record.apples + ', Milk: ' + record.milk); + } +} +``` + +```bash +Eggs: 12, Apples: 3, Milk: 1 +``` + +--- + +**Example 3** + +```tsx +// Example using hKeys() +async function hashExample3() { + await redis.hSet('prices', { + chair: '48', + desk: '95', + whiteboard: '23', + }); + + console.log('Keys: ' + (await redis.hKeys('prices'))); +} +``` + +```bash +Keys: chair,desk,whiteboard +``` + +--- + +**Example 4** + +```tsx +// Example using hScan() +async function hashExample4() { + await redis.hSet('userInfo', { + name: 'Bob', + startDate: '01-05-20', + totalAwards: '12', + }); + + // Scan and interate over all the fields within 'userInfo' + const hScanResponse = await redis.hScan('userInfo', 0); + + hScanResponse.fieldValues.forEach((x) => { + console.log("Field: '" + x.field + "', Value: '" + x.value + "'"); + }); +} +``` + +```bash +Field: 'name', Value: 'Bob' +Field: 'totalAwards', Value: '12' +Field: 'startDate', Value: '01-05-20' +``` + +--- + +**Example 5** + +```tsx +// Example using hIncrBy() +async function hashExample5() { + // Set user123's karma to 100 + await redis.hSet('user123', { karma: '100' }); + + // Increase user123's karma by 5 + console.log('Updated karma: ' + (await redis.hIncrBy('user123', 'karma', 5))); +} +``` + +```bash +Updated karma: 105 +``` + +--- + +**Example 6** + +```tsx +// Example using hLen() +async function hashExample6() { + await redis.hSet('supplies', { + paperclips: '25', + pencils: '10', + erasers: '5', + pens: '7', + }); + + console.log('Number of fields: ' + (await redis.hLen('supplies'))); +} +``` + +```bash +Number of fields: 4 +``` + +
+
+
+### Key expiration
+
+| **Command** | **Action** | **Limits** |
+| --------------------------------------------------- | ----------------------------------------------------------------- | ---------- |
+| [expire](https://redis.io/commands/expire/) | Sets a timeout on key. | None |
+| [expireTime](https://redis.io/commands/expiretime/) | Returns the remaining seconds at which the given key will expire. | None |
+
++ Code Example +
+ +```tsx +async function numbersExample() { + await redis.set('totalPoints', '53'); + + console.log('Updated points: ' + (await redis.incrBy('totalPoints', 100))); +} +``` + +```bash +Updated points: 153 +``` + +
+
+
+### [Transactions](https://redis.io/topics/transactions)
+
+Redis transactions allow a group of commands to be executed in a single isolated step. For example, to implement voting action in a polls app, these three actions need to happen together:
+
+- Store the selected option for the user.
+- Increment the count for selected option.
+- Add the user to voted user list.
+
+The `watch` command provides an entrypoint for transactions. It returns a [TxClientLike](https://developers.reddit.com/docs/api/public-api/#-txclientlike) which can be used to call `multi`, `exec`, `discard`, `unwatch`, and all other Redis commands to be executed within a transaction.
+
+You can sequence all of the above steps in a single transaction using `multi` and `exec` to ensure that either all of the steps happen together or none at all.
+
+If an error occurs inside a transaction before `exec` is called, Redis discards the transaction automatically. See the Redis docs: [Errors inside a transaction](https://redis.io/docs/latest/develop/interact/transactions/#errors-inside-a-transaction) for more info.
+
+| **Command** | **Action** | **Limits** |
+| --------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| [multi](https://redis.io/commands/multi/) | Marks the start of a transaction block. | Max concurrent transactions per installation: 20 (default) |
+| [exec](https://redis.io/commands/exec/) | Executes all previously queued commands in a transaction and restores the connection state to normal. | Transaction execution timeout: 5 seconds |
+| [discard](https://redis.io/commands/discard/) | Flushes all previously queued commands in a transaction and restores the connection state to normal. | None |
+| [watch](https://redis.io/commands/watch/) | Marks the given keys to be watched for conditional execution of a transaction. `watch` returns a [TxClientLike](https://developers.reddit.com/docs/api/public-api/#-txclientlike) which should be used to call Redis commands in a transaction. | None |
+| [unwatch](https://redis.io/commands/unwatch/) | Flushes all the previously watched keys for a transaction. | None |
+
++ Code Example +
+ +```tsx +async function keyExpirationExample() { + // Set a key 'product' with value 'milk' + await redis.set('product', 'milk'); + + // Get the current expireTime for the product + console.log('Expire time: ' + (await redis.expireTime('product'))); + + // Set the product to expire in 60 seconds + await redis.expire('product', 60); + + // Get the updated expireTime for the product + console.log('Updated expire time: ' + (await redis.expireTime('product'))); +} +``` + +```bash +Expire time: 0 +Updated expire time: 60 +``` + +
+
+
+### Sorted set
+
+| **Command** | **Action** | **Limits** |
+| --------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| [zAdd](https://redis.io/commands/zadd/) | Adds all the specified members with the specified scores to the sorted set stored at key. | Subject to storage quota gating (writes may be blocked if quota exceeded) |
+| [zCard](https://redis.io/commands/zcard) | Returns the sorted set cardinality (number of elements) of the sorted set stored at key. | None |
+| [zRange](https://redis.io/commands/zrange/) | Returns the specified range of elements in the sorted set stored at key. + Code Examples +
+ +**Example 1** + +```tsx +// Example using exec() +async function transactionsExample1() { + await redis.mSet({ quantity: '5', karma: '32' }); + + const txn = await redis.watch('quantity'); + + await txn.multi(); // Begin a transaction + await txn.incrBy('karma', 10); + await txn.set('name', 'Devvit'); + await txn.exec(); // Execute the commands in the transaction + + console.log( + 'Keys after completing transaction: ' + + (await redis.mGet(['quantity', 'karma', 'name'])) + ); +} +``` + +```bash +Keys after completing transaction: 5,42,Devvit +``` + +--- + +**Example 2** + +```tsx +// Example using discard() +async function transactionsExample2() { + await redis.set('price', '25'); + + const txn = await redis.watch('price'); + + await txn.multi(); // Begin a transaction + await txn.incrBy('price', 5); + await txn.discard(); // Discard the commands in the transaction + + console.log('Price value: ' + (await redis.get('price'))); // 'price' should still be '25' +} +``` + +```bash +Price value: 25 +``` + +--- + +**Example 3** + +```tsx +// Example using unwatch() +async function transactionsExample3() { + await redis.set('gold', '50'); + + const txn = await redis.watch('gold'); + + await txn.multi(); // Begin a transaction + await txn.incrBy('gold', 30); + await txn.unwatch(); // Unwatch "gold" + + // Now that "gold" has been unwatched, we can increment its value + // outside the transaction without canceling the transaction + await redis.incrBy('gold', -20); + + await txn.exec(); // Execute the commands in the transaction + + console.log('Gold value: ' + (await redis.get('gold'))); // The value of 'gold' should be 50 + 30 - 20 = 60 +} +``` + +```bash +Gold value: 60 +``` + +When using `by: 'lex'`, the start and stop inputs will be prepended with `[` by default, unless they already begin with `[`, `(` or are one of the special values `+` or `-`. | BYSCORE/BYLEX: LIMIT count capped to 1000 per call (server default). RANK: no server cap. Client default for by: 'score'/'lex' is count=1000 when no limit is provided. | +| [zRem](https://redis.io/commands/zrem/) | Removes the specified members from the sorted set stored at key. | None | +| [zScore](https://redis.io/commands/zscore/) | Returns the score of member in the sorted set at key. | None | +| [zRank](https://redis.io/commands/zrank/) | Returns the rank of member in the sorted set stored at key. | None | +| [zIncrBy](https://redis.io/commands/zincrby/) | Increments the score of member in the sorted set stored at key by value. | Subject to storage quota gating (writes may be blocked if quota exceeded) | +| [zScan](https://redis.io/commands/zscan/) | Iterates elements of sorted set types and their associated scores. Note that there is no guaranteed ordering of elements in the result. | No server-side cap; uses requested count | +| [zRemRangeByLex](https://redis.io/commands/zremrangebylex/) | When all elements in a sorted set are inserted with the same score, this command removes the elements at key between the lexicographical range specified by min and max. | None | +| [zRemRangeByRank](https://redis.io/commands/zremrangebyrank/) | Removes all elements in the sorted set stored at key with rank between start and stop. | None | +| [zRemRangeByScore](https://redis.io/commands/zremrangebyscore/) | Removes all elements in the sorted set stored at key with a score between min and max (inclusive). | None | + +
+
+
+### Bitfield
+
+| **Command** | **Action** | **Limits** |
+| ----------------------------------------------------------- | ------------------------------------------------- | ---------- |
+| [bitfield](https://redis.io/docs/latest/commands/bitfield/) | Performs a sequence of operations on a bit string | Subject to storage quota gating (writes may be blocked if quota exceeded) |
+
++ Code Examples +
+ +**Example 1** + +```tsx +// Example using zRange() with by 'score' +async function sortedSetExample1() { + await redis.zAdd( + 'leaderboard', + { member: 'louis', score: 37 }, + { member: 'fernando', score: 10 }, + { member: 'caesar', score: 20 }, + { member: 'alexander', score: 25 } + ); + + // Cardinality should be '4' as there are 4 elements in the leaderboard set + console.log('Cardinality: ' + (await redis.zCard('leaderboard'))); + + // View elements with scores between 0 and 30 inclusive, sorted by score + let scores = await redis.zRange('leaderboard', 0, 30, { by: 'score' }); + console.log('Scores: ' + JSON.stringify(scores)); + + // Remove 'fernando' from the leaderboard + await redis.zRem('leaderboard', ['fernando']); + + // View the elements sorted by score again. This time 'fernando' should not appear in the output + scores = await redis.zRange('leaderboard', 0, 30, { by: 'score' }); + console.log('Updated scores: ' + JSON.stringify(scores)); + + // View caesar's score + console.log("Caesar's score: " + (await redis.zScore('leaderboard', 'caesar'))); +} +``` + +```bash +Cardinality: 4 +Scores: [{"score":10,"member":"fernando"},{"score":20,"member":"caesar"},{"score":25,"member":"alexander"}] +Updated scores: [{"score":20,"member":"caesar"},{"score":25,"member":"alexander"}] +Caesar's score: 20 +``` + +--- + +**Example 2** + +```tsx +// Example using zRange() with by 'lex' +async function sortedSetExample2() { + await redis.zAdd( + 'checkpoints', + { member: 'delta', score: 0 }, + { member: 'omega', score: 0 }, + { member: 'alpha', score: 0 }, + { member: 'charlie', score: 0 } + ); + + // View elements between the words 'alpha' and 'fox' inclusive, sorted lexicographically + // Note that 'by: "lex"' only works if all elements have the same score + const members = await redis.zRange('checkpoints', 'alpha', 'fox', { by: 'lex' }); + console.log('Members: ' + JSON.stringify(members)); +} +``` + +```bash +Members: [{"score":0,"member":"alpha"},{"score":0,"member":"charlie"},{"score":0,"member":"delta"}] +``` + +--- + +**Example 3** + +```tsx +// Example using zRange() with by 'rank' +async function sortedSetExample3() { + await redis.zAdd( + 'grades', + { member: 'sam', score: 80 }, + { member: 'norma', score: 95 }, + { member: 'alex', score: 77 }, + { member: 'don', score: 84 }, + { member: 'zeek', score: 92 } + ); + + // View elements with a rank between 2 and 4 inclusive. Note that ranks start at index 0. + const members = await redis.zRange('grades', 2, 4, { by: 'rank' }); + console.log('Members: ' + JSON.stringify(members)); +} +``` + +```bash +Members: [{"score":84,"member":"don"},{"score":92,"member":"zeek"},{"score":95,"member":"norma"}] +``` + +--- + +**Example 4** + +```tsx +// Example using zRank() and zIncrBy() +async function sortedSetExample4() { + await redis.zAdd( + 'animals', + { member: 'zebra', score: 92 }, + { member: 'cat', score: 100 }, + { member: 'dog', score: 95 }, + { member: 'elephant', score: 97 } + ); + + // View the rank of 'dog' in the animals set + // Rank should be '1' since 'dog' has the second lowest score. Note that ranks start at index 0. + console.log("Dog's rank: " + (await redis.zRank('animals', 'dog'))); + + // View the rank of 'zebra' + console.log("Zebra's rank: " + (await redis.zRank('animals', 'zebra'))); + + // Increase the score of 'dog' by 10 + await redis.zIncrBy('animals', 'dog', 10); + + // View the rank of 'dog' again. This time it should be '3' because dog has the highest score. + console.log( + "Dog's rank after incrementing score: " + (await redis.zRank('animals', 'dog')) + ); +} +``` + +```bash +Dog's rank: 1 +Zebra's rank: 0 +Dog's rank after incrementing score: 3 +``` + +--- + +**Example 5** + +```tsx +// Example using zRemRangeByLex() +async function sortedSetExample5() { + await redis.zAdd( + 'fruits', + { member: 'kiwi', score: 0 }, + { member: 'mango', score: 0 }, + { member: 'banana', score: 0 }, + { member: 'orange', score: 0 }, + { member: 'apple', score: 0 } + ); + + // Remove fruits alphabetically ordered between 'kiwi' inclusive and 'orange' exclusive + // Note: The symbols '[' and '(' indicate inclusive or exclusive, respectively. These must be included in the call to zRemRangeByLex(). + await redis.zRemRangeByLex('fruits', '[kiwi', '(orange'); + + // Only 'apple', 'banana', and 'orange' should remain in the set + const zScanResponse = await redis.zScan('fruits', 0); + console.log('zScanResponse: ' + JSON.stringify(zScanResponse)); +} +``` + +```bash +zScanResponse: {"cursor":0,"members":[{"score":0,"member":"apple"},{"score":0,"member":"banana"},{"score":0,"member":"orange"}]} +``` + +--- + +**Example 6** + +```tsx +// Example using zRemRangeByRank() +async function sortedSetExample6() { + await redis.zAdd( + 'fruits', + { member: 'kiwi', score: 10 }, + { member: 'mango', score: 20 }, + { member: 'banana', score: 30 }, + { member: 'orange', score: 40 }, + { member: 'apple', score: 50 } + ); + + // Remove fruits ranked 1 through 3 inclusive + await redis.zRemRangeByRank('fruits', 1, 3); + + // Only 'kiwi' and 'apple' should remain in the set + const zScanResponse = await redis.zScan('fruits', 0); + console.log('zScanResponse: ' + JSON.stringify(zScanResponse)); +} +``` + +```bash +zScanResponse: {"cursor":0,"members":[{"score":10,"member":"kiwi"},{"score":50,"member":"apple"}]} +``` + +--- + +**Example 7** + +```tsx +// Example using zRemRangeByScore() example +async function sortedSetExample7() { + await redis.zAdd( + 'fruits', + { member: 'kiwi', score: 10 }, + { member: 'mango', score: 20 }, + { member: 'banana', score: 30 }, + { member: 'orange', score: 40 }, + { member: 'apple', score: 50 } + ); + + // Remove fruits scored between 30 and 50 inclusive + await redis.zRemRangeByScore('fruits', 30, 50); + + // Only 'kiwi' and 'mango' should remain in the set + const zScanResponse = await redis.zScan('fruits', 0); + console.log('zScanResponse: ' + JSON.stringify(zScanResponse)); +} +``` + +```bash +zScanResponse: {"cursor":0,"members":[{"score":10,"member":"kiwi"},{"score":20,"member":"mango"}]} +``` + +
+
+
+## Compression (Experimental)
+
+The Redis package includes a `redisCompressed` client that transparently handles compression and decompression of values. This is useful for storing large strings or JSON objects that exceed the Redis storage limits or to optimize storage usage.
+
+To use it, update your import:
+
+```ts
+// import { redis } from '@devvit/redis';
+import { redisCompressed as redis } from '@devvit/redis';
+```
+
+:::warning
+**One-Way Migration**: Once you start using `redisCompressed` and writing compressed data, switching back to the standard `redis` client will result in errors when reading that data, as the standard client does not know how to decompress the values.
+:::
+
+The `redisCompressed` client automatically:
+- Compresses values on write (`set`, `hSet`, `mSet`, `hSetNX`) if it saves space.
+- Decompresses values on read (`get`, `hGet`, `mGet`, `hMGet`, `hGetAll`).
+
+**Note:** Existing uncompressed data is **not** automatically compressed when read. It is only compressed when you write it back. To migrate existing large datasets, you need to read and re-write the data.
+
+### Migration Example
+
+Migrating large datasets can take time. To avoid the 30-second execution timeout, we recommend using a scheduled job that processes data in chunks and "daisy chains" itself until completion.
+
+Here is an example of how to implement a migration tool using a Menu Item and the Scheduler.
+
+Register your form handler, menu trigger, and scheduler endpoint here.
+
+```json
+{
+ "forms": {
+ "migrateExampleForm": "/internal/form/ops/migrate-example"
+ },
+ "menu": {
+ "items": [
+ {
+ "label": "[ops] Migrate Data to Compression",
+ "location": "subreddit",
+ "forUserType": "moderator",
+ "endpoint": "/internal/menu/ops/migrate-example"
+ }
+ ]
+ },
+ "scheduler": {
+ "tasks": {
+ "migrate-example-data": {
+ "endpoint": "/internal/scheduler/migrate-example-data"
+ }
+ }
+ }
+}
+```
+
+Add these route handlers to your server.
+
+