WordPress Playground is often used as a one-off browser sandbox: open a link, test a pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party., close the tab.

That is useful, but plugin and theme development usually involves more than one sandbox. You may need a clean site for reproduction, a saved site for ongoing debugging, another site pinned to a different PHPPHP PHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used open source general-purpose scripting language that is especially suited for web development and can be embedded into HTML. https://www.php.net/manual/en/index.php version, and a way to inspect all of them without clicking through the interface.

Recent Playground updates make those workflows easier to automate. The Playground website now makes a site management object available to JavaScriptJavaScript JavaScript or JS is an object-oriented computer programming language commonly used to create interactive effects within web browsers. WordPress makes extensive use of JS for a better user experience. While PHP is executed on the server, JS executes within a user’s browser. https://www.javascript.com running on its top-level page. Code in the browser console or a browser automation tool can access it through window.playgroundSites to list and switch sites, save temporary sites, rename saved sites, change runtime settings, or get the active site’s PlaygroundClient.

This post shows how plugin and theme developers can use that APIAPI An API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. from the browser console to speed up real workflows.

One interface for site management

Before these updates, anything outside the Playground UIUI UI is an acronym for User Interface - the layout of the page the user interacts with. Think ‘how are they doing that’ and less about what they are doing. had to recreate site management behavior itself. MCP tools, browser-native WebMCP, DevTools experiments, and UI components all needed some way to list sites, save them, rename them, or switch the active site.

The new PlaygroundSitesAPI gives those workflows one shared interface. After the Playground website loads, JavaScript running on the page can call that interface through window.playgroundSites. This makes site management scriptable without relying on brittle UI automation.

In practical terms, you can now open DevTools and run:

window.playgroundSites.list();

The result is an array of site records:

[
  {
    slug: "quiet-river",
    name: "Quiet River",
    storage: "temporary",
    isActive: true,
  },
];

The storage field tells you whether the site is temporary, saved in browser storage, or saved to the local filesystem. Temporary sites disappear on reload unless you save them first.

The API at a glance

The workflows in this post use these coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. methods:

Method	What it does
list()	Lists all known Playground sites and marks the active one.
getClient()	Returns the PlaygroundClient for the active site, if it has booted.
isReady()	Resolves when the active site has booted and its client is ready.
rename(newName)	Renames the active saved site. Temporary sites must be saved first.
saveInBrowser(name?)	Saves the active temporary site to browser storage.
saveToLocalFileSystem(name?, handle?)	Saves the active temporary site to a local directory.
setPhpVersion(version)	Changes the PHP version for the active saved site.
setNetworking(enabled)	Enables or disables networking for the active saved site.
delete(siteSlug)	Deletes a saved site by slug. Temporary sites cannot be deleted this way.
setActiveSite(siteSlug)	Switches to another site and waits for it to boot.
createNewTemporarySite(siteSlug?, settings?)	Creates and activates a new temporary site.

The API is available after Playground loads its saved sites. If window.playgroundSites is undefined, wait until the Playground UI has finished loading. Then call await window.playgroundSites.isReady() before running commands that need the active site’s client.

See the Sites API documentation for the complete reference, including methods for autosaved and explicitly saved sites.

Run the examples on the Playground website

The examples below use the Sites API on playground.wordpress.net. Open the website, wait for the Playground UI to load, open your browser’s DevTools console, and run await window.playgroundSites.isReady(). You can then paste the examples into the console. A browser automation tool such as Playwright can run the same JavaScript while it controls a tab open to the Playground website.

This API belongs to the Playground website. It is not part of the @wp-playground/client package or the Playground CLICLI Command Line Interface. Terminal (Bash) in Mac, Command Prompt in Windows, or WP-CLI for WordPress., and it is not exposed by /remote.html when you embed Playground in another application. For embedded sites and test automation that starts its own Playground client, use the JavaScript API instead.

Scenario 1: Create a clean plugin test site

When debugging a plugin issue, start with a fresh site that matches the target environment. The example below creates a temporary site using PHP 8.4, the latest WordPress release, and networking enabled:

const slug = await window.playgroundSites.createNewTemporarySite(
  "plugin-test-php-84",
  {
    phpVersion: "8.4",
    wpVersion: "latest",
    networking: true,
  }
);

console.log(`Active test site: ${slug}`);

Use this when you need a clean environment before installing a plugin or reproducing a report. The site is temporary at this point, so changes will not survive a reload.

Scenario 2: Save and rename a reproducible bug report

Once you reproduce a bug, save the site before making more changes. Saving turns a temporary site into a browser-stored site:

const saved = await window.playgroundSites.saveInBrowser(
  "Plugin compatibility test"
);

console.log(saved);

The returned object includes the site slug and storage type:

{
  slug: "plugin-test-php-84",
  storage: "opfs",
}

After saving, you can rename the active site:

await window.playgroundSites.rename(
  "Plugin compatibility test - PHP 8.4"
);

That sequence matters. rename() only works on saved sites. If you call it on a temporary site, Playground throws:

Cannot rename a temporary site. Save it first.

Scenario 3: Switch between saved test sites

When you keep separate sites for different reproduction cases, list them and switch by slug:

const sites = window.playgroundSites.list();

console.table(
  sites.map((site) => ({
    slug: site.slug,
    name: site.name,
    storage: site.storage,
    active: site.isActive,
  }))
);

To activate one:

const target = window.playgroundSites
  .list()
  .find((site) => site.name.includes("Plugin compatibility"));

if (target) {
  await window.playgroundSites.setActiveSite(target.slug);
}

setActiveSite() waits for the selected site to boot before resolving, so follow-up commands can safely assume the active site is ready.

Scenario 4: Inspect plugin state with PHP

The site management API gives you access to the active site’s PlaygroundClient. That client can run PHP inside the WordPress environment.

function phpResponseText(response) {
  return "text" in response
    ? response.text
    : new TextDecoder().decode(response.bytes);
}

await window.playgroundSites.isReady();
const client = window.playgroundSites.getClient();

if (!client) {
  throw new Error("The active Playground site has not booted yet.");
}

const response = await client.run({
  code: `<?php
require_once "/wordpress/wp-load.php";

echo json_encode([
  "php" => phpversion(),
  "wp" => get_bloginfo("version"),
  "active_plugins" => get_option("active_plugins"),
]);
`,
});

console.log(phpResponseText(response));

This lets you query plugin data in the WordPress database directly, without navigating through wp-admin. You can replace the PHP with targeted checks for options, active theme data, custom post types, or plugin-specific database rows.

For example, to inspect one option:

const response = await client.run({
  code: `<?php
require_once "/wordpress/wp-load.php";
echo wp_json_encode(get_option("woocommerce_currency"));
`,
});

console.log(phpResponseText(response));

Playground uses SQLite for WordPress storage, so prefer WordPress APIs like get_option() and $wpdb over database-specific SQL behavior.

Scenario 5: Change runtime settings for a saved site

Sometimes a bug only appears with a specific PHP version or with networking enabled. Once the active site is saved, you can update runtime settings directly:

await window.playgroundSites.setPhpVersion("8.3");
await window.playgroundSites.setNetworking(true);

These methods require a saved site. If the active site is temporary, save it first:

await window.playgroundSites.saveInBrowser("Network test");
await window.playgroundSites.setNetworking(true);

This is a good workflow for compatibility testing:

1. Create a clean site.
2. Install and configure the plugin.
3. Save the site.
4. Switch PHP versions.
5. Re-run the same plugin checks.

Scenario 6: Create a small compatibility checklist

You can combine the API calls into a manual checklist from DevTools. This example creates a site, saves it, gathers basic version information, and leaves the result in the console:

async function prepareCompatibilitySite() {
  function phpResponseText(response) {
    return "text" in response
      ? response.text
      : new TextDecoder().decode(response.bytes);
  }

  const slug = await window.playgroundSites.createNewTemporarySite(
    "compatibility-check",
    {
      phpVersion: "8.4",
      wpVersion: "latest",
      networking: true,
    }
  );

  await window.playgroundSites.saveInBrowser(
    "Compatibility check - PHP 8.4"
  );

  await window.playgroundSites.isReady();
  const client = window.playgroundSites.getClient();
  if (!client) {
    throw new Error("The compatibility site has not booted yet.");
  }

  const response = await client.run({
    code: `<?php
require_once "/wordpress/wp-load.php";
echo wp_json_encode([
  "site_url" => get_site_url(),
  "php" => phpversion(),
  "wp" => get_bloginfo("version"),
  "theme" => wp_get_theme()->get("Name"),
]);
`,
  });

  return {
    site: window.playgroundSites
      .list()
      .find((site) => site.slug === slug),
    info: JSON.parse(phpResponseText(response)),
  };
}

console.log(await prepareCompatibilitySite());

This is not a replacement for a full test suite. It is a fast way to prepare and inspect a browser-based testing site when you are triaging a report.

How this fits recent Playground updates

Recent Playground work also added deeper AI and browser automation hooksHooks In WordPress theme and development, hooks are functions that can be applied to an action or a Filter in WordPress. Actions are functions performed when a certain event occurs in WordPress. Filters allow you to modify certain functions. Arguments used to hook both filters and actions look the same. through MCP and WebMCP. The same centralized site management API supports those integrations, so AI agents and browser-native tools can manage Playground sites through explicit operations instead of clicking through menus.

For example:

• list() maps naturally to “show me my Playground sites.”
• setActiveSite(slug) maps to “open the site named Plugin compatibility test.”
• saveInBrowser(name) maps to “save this reproduction so I can come back later.”
• getClient() gives tool layers access to PHP execution, HTTPHTTP HTTP is an acronym for Hyper Text Transfer Protocol. HTTP is the underlying protocol used by the World Wide Web and this protocol defines how messages are formatted and transmitted, and what actions Web servers and browsers should take in response to various commands. requests, and filesystem operations.

The result is a cleaner foundation for agent workflows. A coding agent can keep one site for investigation, another for a clean reproduction, and another for verifying a fix, all without depending on visual UI state.

For setup instructions, see Connect AI coding agents to WordPress Playground with MCP. For URLURL A specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org-based configuration options such as php, wp, networking, and site-slug, see the Query API documentation.

Practical limits

There are a few details to remember:

• window.playgroundSites is only available after Playground finishes loading saved sites.
• Temporary sites must be saved before you can rename them, delete them, or update their PHP/networking settings.
• Call isReady() before getClient() when the active site may still be booting. Until the site is ready, getClient() can return undefined.
• saveToLocalFileSystem() may open a browser directory picker when you do not pass a directory handle.
• Browser storage is still browser storage. Clearing site data can remove saved Playground sites.

Try it

Open playground.wordpress.net, wait for the site to finish loading, then open DevTools and run:

await window.playgroundSites.isReady();
window.playgroundSites.list();

From there, create a temporary site, save it, switch between saved sites, and use getClient() to inspect WordPress state with PHP. For plugin and theme developers, this turns Playground from a single sandbox into a small fleet of browser-based test environments.

The playground team has been working on a brand-new interface for WordPress Playground, and we would love your help testing it before it officially launches. Whether you are using a laptop or a mobile phone, we want to know how the new UIUI UI is an acronym for User Interface - the layout of the page the user interacts with. Think ‘how are they doing that’ and less about what they are doing. feels, responds to, and works with your clicks and taps.

You do not have to test everything. Pick one or two modules below, explore them, and tell us what worked well or what could be improved.

🔗 Test environment: Open the new Playground UI

What We Are Looking For

While testing, please pay attention to:

• Clear text: Are buttons, labels, descriptions, and instructions easy to understand?
• Logical mechanics: Do workflows behave as you expect? Is it clear what each action will do?
• Design issues: Do you see overlapping text, clipped content, missing controls, or broken layouts?
• Helpful feedback: What feature or small change would make the experience smoother?

Testing on Desktop and Mobile

If possible, try the UI in both a desktop browser and a mobile browser.

On mobile:

• Swipe the bottom toolbar horizontally to find tools that are not currently visible, such as Files, Logs, or Export.
• Tool panels open over the site. Use the X button to close a panel.
• In the Files panel, tap Browse files to open the file tree.
• Use the file upload control instead of drag and drop.

Please do not upload private files, passwords, APIAPI An API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. keys, or other sensitive information while testing.

Choose Your Testing Adventure

Module 1: Create and Manage Playgrounds

A good starting point for a five-minute test.

1. Open the test environment and wait for the initial Playground to finish loading. A Playground is created automatically when the page opens.
2. Select New in the bottom toolbar.
3. In the Blueprint gallery, select Vanilla WordPress. Selecting the card immediately creates a fresh Playground.
4. Open Site details. Change the WordPress version or PHPPHP PHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used open source general-purpose scripting language that is especially suited for web development and can be embedded into HTML. https://www.php.net/manual/en/index.php version, then select Create a fresh Playground. Verify that the new Playground uses the selected versions.
5. In Site details, select Rename Playground and give it a recognizable name. You can also rename it from Playgrounds → Actions (⋮) → Rename.
6. Open Playgrounds, open the current Playground’s Actions (⋮) menu, and select Save in browser storage. Confirm that its status changes from an autosave to a permanently saved Playground.
7. Refresh the browser. Open Playgrounds, find the site under Saved, and open it again. Saved Playgrounds and Recent autosaves are listed separately.
8. Open the saved Playground’s Actions (⋮) menu, select Delete, and confirm the deletion.

Note: Autosaves are periodic snapshots and may not include every recent change. Use Save in browser storage when you want to keep a Playground.

What to look out for:

• Did the initial and fresh Playgrounds load successfully?
• Was it clear that changing a version creates a fresh Playground?
• Were rename, save, restore, and delete actions easy to find?
• After refreshing, was the difference between Recent autosaves and
  Saved clear?
• Could you reach every action comfortably on mobile?

Module 2: The Blueprint Experience

Test the different ways to start and inspect a custom setup.

1. Select New → Blueprint gallery.
2. Search or browse the gallery and read the descriptions shown on the cards.
3. Select a Blueprint card. The card launches a fresh Playground immediately, so there is no separate details screen.
4. After it loads, open Blueprint in the bottom toolbar to inspect its blueprint.json file.
5. Select New → Blueprint URLURL A specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org, enter a publicly accessible Blueprint URL, and select Create Playground.
6. Select New → Write a Blueprint, edit the example JSONJSON JSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML., and select Create Playground.
7. To keep the resulting site, use Playgrounds → Actions (⋮) → Save in browser storage. To download the Blueprint itself, open Blueprint and select Export.

Be careful: In an editable autosaved Playground, Run Blueprint and reset site recreates the Playground and replaces its files. In a permanently saved Playground, the Blueprint editor is read-only.

What to look out for:

• Was the gallery easy to browse and search?
• Was it clear that selecting a card would immediately create a Playground?
• Did the Blueprint URL and raw JSON workflows show useful validation and error messages?
• Was the difference between saving a Playground and exporting a Blueprint clear?
• Did the selected Blueprint finish without crashing?

Module 3: Files, Database, and Logs

Test the developer tools.

1. Launch a Playground and open Files.
2. On mobile, select Browse files to reveal the file tree.
3. Try Create new folder and Create new file. Enter a name, confirm it, and verify that the item remains visible after you select something else.
4. Open a harmless file such as readme.html, or use the test file you just created. Add a short comment, select Save file, reopen the file, and confirm that the change remains. Avoid editing wp-config.php for this test.
5. Use Upload files to upload a small, non-sensitive test file. On desktop, you may also try dragging a test file into the file manager and report whether that works.
6. Open Database. Select Open Adminer or Open phpMyAdmin, then browse a table without changing its data. If the viewer cannot install or reports a download/fetch error, include the exact error in your feedback.
7. Open Logs. Confirm that you see either a clear Nothing logged yet state or relevant PHP, WordPress, and Playground messages. If you are comfortable doing so, trigger a harmless warning in a test file and check whether it appears.

What to look out for:

• Did newly created files and folders persist after focus moved elsewhere?
• Was the editor comfortable to use with a mobile keyboard?
• Were save and upload results clearly communicated?
• Did Adminer or phpMyAdmin open successfully? Were installation errors useful?
• Did the Logs panel clearly explain an empty state and distinguish message types?

Module 4: Import, Export, and Sharing

Test how Playground data moves between environments.

1. In an active Playground, open Export.
2. Under Download a copy, select Download as .zip. The ZIP should contain the current files, database, and edits.
3. Select New → Import zip → Choose a .zip file… and import the ZIP you just downloaded.
4. After the imported Playground loads, check that its pages, settings, files, and content were restored.
5. Open Export and select Copy link. Paste the result somewhere safe and verify that it is a usable URL. Important: This link recreates the original Blueprint setup only. It does not include later edits to files or content.
6. Optionally, test Export to GitHubGitHub GitHub is a website that offers online implementation of git repositories that can easily be shared, copied and modified by other developers. Public repositories are free to host, private repositories require a paid subscription. GitHub introduced the concept of the ‘pull request’ where code changes done in branches by contributors can be reviewed and discussed before being merged by the repository owner. https://github.com/ using a disposable repository you can modify safely. Connect your GitHub account and try exporting a pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party., theme, or wp-content directory. The GitHub connection is not retained after a browser refresh.

👀 What to look out for:

• Did ZIP creation finish in a reasonable time?
• Did importing the ZIP restore the current site accurately?
• Did the UI clearly explain what the copied link includes and excludes?
• Were clipboard permission errors understandable?
• Was the scope of the GitHub export clear before anything was pushed?
• Were success, progress, and error messages helpful?

How to Share Your Feedback

Found a bug or have an idea for a better workflow? Please include:

• Your device, operating system, and browser.
• The module and step you tested.
• The steps needed to reproduce the problem.
• What you expected to happen and what actually happened.
• Your thoughts on text clarity, mechanics, and visual design.
• Screenshots or short screen recordings, when possible.

Remove private information, access tokens, repository secrets, and personal files from screenshots or recordings before posting them.

👉 Share feedback, bugs, and ideas in the official GitHub issue:

New Dock UI review — Issue #4092

You will need to sign in to GitHub to post a comment.

Thank you for helping us make WordPress Playground better for everyone. Happy testing! 🚀

WordPress Playground now loads GutenbergGutenberg The Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/ development branches directly in your browser. Test the latest trunk changes or explore feature branches without creating a pull request or setting up a local environment.

This solves a common challenge: testing bleeding-edge Gutenberg development typically requires cloning repositories, running build scripts, and managing local installations. Now you can skip all that.

Why does this matter?

New features land trunk daily, and experimental work occurs in feature branches before being merged into pull requests. Previously, you could only preview specific PRs in Playground, and now you can preview any branch related to a pull request.

This opens new possibilities:

• Test the Gutenberg trunk branch to catch issues before they reach release.
• Explore Gutenberg experimental features and fixes before they’re merged.

How do you preview branches?

Playground introduces two new Query API parameters gutenberg-branch. Add them to your Playground URLURL A specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org to load specific branches.

Preview Gutenberg trunk or a specific feature branch:

https://playground.wordpress.net/?gutenberg-branch=trunk

Other branches:

https://playground.wordpress.net/?gutenberg-branch=add/new-feature

What about pull requests?

Pull request previewing still works exactly as before for Gutenberg and WordPress coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress.. If you know the PR number, use:

https://playground.wordpress.net/?core-pr=9500
https://playground.wordpress.net/?gutenberg-pr=73010

What should you know?

When you preview a branch, Playground loads the latest available build artifact from GitHubGitHub GitHub is a website that offers online implementation of git repositories that can easily be shared, copied and modified by other developers. Public repositories are free to host, private repositories require a paid subscription. GitHub introduced the concept of the ‘pull request’ where code changes done in branches by contributors can be reviewed and discussed before being merged by the repository owner. https://github.com/ Actions. If GitHub Actions is still building the most recent commit, Playground uses the next available build. This means you might see changes from a few commits back, not the absolute latest code. This approach strikes a balance between freshness and reliability.

This feature works anywhere you use the Playground Query APIAPI An API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways., ideally, for testing and bug reporting. The playground can be embedded for educational purposes in future releases. For example, if you’re documenting a new Gutenberg feature still in trunk, link directly to a Playground instance that demonstrates it.

Start testing today

The WordPress and Gutenberg teams constantly ship improvements. With branch previewing, you can explore these changes the moment they merge, report issues early, and contribute to WordPress development—all from your browser.

Try it now and learn more about Query API documentation.