Library / SDK
wp-graphql/wp-graphql avatar
wp-graphql/wp-graphql

WPGraphQL keeps its core plugin, two extensions and its docs site in one npm workspace

:rocket: GraphQL API for WordPress

3,797 stars484 forksPHPGPL-3.0

At a glance

What is it?
What the wp-graphql monorepo shows about who releases what: a WordPress plugin that exposes a GraphQL schema, two official extensions, a Next.js documentation site, and a release pipeline that treats the schema itself as a reviewed contract.
Who is it for?
WPGraphQL earns a look if your front end needs WordPress data in shaped queries rather than fixed endpoints, and you can accept a plugin that owns your data contract. Skip it if the fields you need live in a plugin with no official extension, because WooCommerce, Yoast or translation add-ons are separate projects with their own maintainers.
Can I use it commercially?
Yes, with conditions. GPL-3.0 is a copyleft licence: if you distribute software that includes it, you must release that software's source code under the same licence. Running it internally without distributing it does not trigger that obligation.
Is it still maintained?
Yes. The repository last received commits 2 days ago.
What is it written in?
Mainly PHP, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • wp-graphql/wp-graphql3,797 ★ · +6
Star history
Repository2026-09-242026-11-15
wp-graphql/wp-graphql3.8k3.8k

6 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The repository is an npm workspace, not a single plugin

The root package.json is called wpgraphql-monorepo and it is marked private, which tells you the directory is not itself something you install. Its workspaces field covers two globs, plugins/* and websites/*, so one npm install pulls every plugin in the tree and the documentation site together. Build, lint, zip, test, start and format all delegate to the same runner:

code
"build": "turbo run build",
"lint": "turbo run lint",
"zip": "turbo run zip"

Two version floors are declared up front: Node 22 or newer, and npm 10 or newer, with npm 10.8.2 pinned as the package manager. That is a real constraint for a WordPress plugin, because the classic shared-hosting stack often runs older Node, though it is only the contributor path that touches Node at all. Site owners never touch this file. WPGraphQL installs from WordPress.org, from Composer, or from the release zip, and the README says plainly that nothing changes for end users. So the monorepo layout is not a packaging decision for consumers. It is a decision about who maintains which plugin and in what order.

Contributors get a WordPress with every plugin switched on at once

The contributor path is two commands, and the comments next to them say what each one is for:

bash
npm install           # Install dependencies (uses workspaces)
npm run wp-env start  # Start WordPress environment with all plugins

The shared .wp-env.json at the top of the tree is what makes that second line honest. Starting the environment brings up WordPress with all four plugins already there, which means a change to the ACF extension can be checked against the core schema in a single browser session rather than in four installs. Three matching scripts wrap the lifecycle: npm run wp-env:stop, npm run wp-env:destroy, and the bare npm run wp-env passthrough. Destructive teardown is deliberately a separate verb from starting.

The install step has two hooks of its own. postinstall runs patch-package, and a patches/ directory sits at the top level to hold the result, so dependency patches are committed rather than applied by hand on each machine. prepare runs husky install, and .husky/ is present, which puts commit-time checks in front of every contributor rather than in front of reviewers.

Experiments are the only documented path into the core schema

The README splits proposed work into three buckets, and the split is more interesting than the feature list. Core takes GraphQL schema coverage for WordPress features such as posts, pages, users and taxonomies, performance work that benefits everyone, developer APIs for extending the schema, and the standards the ecosystem is meant to follow.

Experiments holds proposed features that need real-world validation before they are committed, breaking changes that need community feedback, and performance improvements that need testing at scale. The stated difference is sharp: an experiment may graduate to core or be removed outright.

Extensions are the third bucket, and the rule for them is different in kind. Plugin-specific integrations such as ACF, Yoast and WooCommerce belong here, as do opinionated workflows and anything tied to one framework. An extension lives independently, forever. That is a deliberate answer to the failure mode where a general-purpose API plugin accumulates a settings page per vendor, and it is why the same repository can hold a core plugin and still decline to own your SEO plugin's fields.

Smart Cache and ACF ship from this tree, but versioning them is a separate decision

Three of the four plugins under plugins/ exist because of the extension rule above. wp-graphql-ide is the GraphiQL IDE, wp-graphql-smart-cache handles network-level caching and cache invalidation, and wp-graphql-acf exposes Advanced Custom Fields data.

Their release lines are independent, and the tag names make that explicit. Core shipped wp-graphql/v2.23.0 on 2026-09-15 and wp-graphql/v2.23.1 on 2026-09-22, while the IDE's latest tag was wp-graphql-ide/v5.6.0 on 2026-09-16. Three tags, three dates, three version numbers, one repository. A consumer pinning a schema therefore has to decide per plugin which version it wants, because upgrading core does not drag the IDE or the cache layer along with it.

The caching point matters for expectations. Core's own performance story is about request shape, and the plugin's smart cache is where network-level caching and invalidation live. Reading the core README as though caching were included leads to a wrong deployment plan.

The extension surface is two PHP functions, guarded by a schema linter

Plugins add their own data through register_graphql_field and register_graphql_connection, and developer APIs for extending the schema are listed as in scope for core rather than left to third parties. The GraphiQL IDE plugin and the two extensions are cited as proof that the surface holds up.

What is more telling is that schema shape is checked on its own. Among the CI workflows at the top of the README are integration-tests, lint, schema-linter, js-e2e-tests and codeql-analysis, five separate jobs. A dedicated schema linter means the public GraphQL surface is treated as an artifact that can break, rather than as a side effect of PHP refactoring. That is the mechanism behind the Experiments route for breaking changes: a change to the schema can fail a check instead of passing silently.

Documentation for the extension surface is generated, not hand-kept. Separate scripts generate hook documentation, function documentation and recipe documentation, and one check reports legacy hook coverage. Generated docs plus a legacy check is a project telling you that deprecated signatures are tracked rather than deleted quietly.

The release version lives in several files, and a test script chain keeps them in agreement

The most concrete thing in the repository is how much machinery surrounds a version number. test:scripts runs ten test files in sequence with && between them:

bash
node scripts/extract-release-version-info.test.js && node scripts/update-upgrade-notice.test.js && node scripts/update-version-constants.test.js

The rest of the chain continues with readme changelog updates, release manifest reconciliation, hook documentation generation, legacy hook version replacement, function documentation generation, and two recipe tests. release-please-config.json and .release-please-manifest.json sit at the root, so automated releases are configured, and the plugin itself is packaged through a separate path:

bash
composer -d plugins/wp-graphql run-script build-plugin

Read together, these say the version is not a single constant. It has to be extracted, written into version constants, reflected in the README changelog and reconciled against a manifest, and PHP has its own packaging step. The README does not document the format of the upgrade notice or the shape of the manifest, so treat the scripts rather than the prose as the authority.

A WordPress plugin review badge suggests the schema contract is externally policed

Two badges outside the GitHub Actions set point at external checks. One links to codecov.io for this repository, the other to a project page on bestpractices.dev. The second is the more interesting one: it is a WordPress-specific review of plugin code quality, and it means a GPL-3.0 plugin exposing a GraphQL schema is still being measured against the standards WordPress plugin authors are held to, not against the conventions of the GraphQL world.

That combination is the honest description of the project. It sits on the WordPress side for packaging, security review and install path, and on the GraphQL side for the data contract. Core functionality runs on graphql-php from Webonyx, credited in the README as the library that powers it, which keeps the query engine out of the plugin's own code and the schema in it.

Maintenance status is easy to date here. The repository is not archived and the last push was on 2026-10-04, one day before this article. Both core releases in the recent tag list came within a week of each other, and the repository has 133 open issues against a code base of this size.

The performance claim is about round trips, and nothing claims latency

It is worth separating what the project promises from what it does not. The performance statement is that you query only the data you need and that you can collect multiple resources in one request, which reduces round trips. That is a claim about the shape of a request and the number of requests, not about how long any one of them takes.

Nothing in the README promises faster responses by default, and the caching story is delegated to the Smart Cache extension, which the README links as the place for enhanced performance and network-level caching and cache-invalidation. Frameworks named for integration are Next.js, Svelte and Astro, all headless or island-style front ends, so the target use case is a front end that owns rendering and lets WordPress own content.

Developer tooling is browser-side rather than a CLI. The GraphiQL IDE and a WordPress Playground preview link are how you inspect a schema before writing application code. If your workflow depends on inspecting the schema from a terminal, this repository does not document one.

Editorial conclusion

WPGraphQL earns a look if your front end needs WordPress data in shaped queries rather than fixed endpoints, and you can accept a plugin that owns your data contract. Skip it if the fields you need live in a plugin with no official extension, because WooCommerce, Yoast or translation add-ons are separate projects with their own maintainers. Before committing, check which extension covers your custom post types, decide whether Smart Cache is part of your plan, and read the version constants in the core plugin rather than trusting the README, since the release scripts exist precisely because that number lives in several files at once.

Frequently asked questions

Is GraphQL still worth choosing for a WordPress site in 2026?

WPGraphQL is not an experiment. The core plugin was at v2.23.1 on 2026-09-22, the repository is not archived, its last push was on 2026-10-04, and the project states a policy of semantic versioning with backward compatibility. It is GPL-3.0 licensed and its schema runs on the graphql-php library.

Is WPGraphQL a better fit than the WordPress REST API?

It adds a GraphQL layer on top of WordPress rather than replacing the REST API. The claim the project makes for itself is about request shape rather than speed: one query can collect several resources, which reduces the number of round trips. Network-level caching is a separate plugin, WPGraphQL Smart Cache.

Is WPGraphQL just an HTTP endpoint?

It is a WordPress plugin that exposes a GraphQL schema, and its core functionality runs on graphql-php from Webonyx. You install it with wp plugin install wp-graphql --activate, or from WordPress.org, from Composer, or from the release zip.

What does WPGraphQL actually add to a WordPress site?

An extendable GraphQL API over WordPress data, covering posts, pages, custom post types, taxonomies and users. Plugins extend it with register_graphql_field and register_graphql_connection, and field data from other plugins is exposed by separate extensions such as WPGraphQL for ACF.

Official sources

  1. License: GPL-3.0
  2. Project website
  3. README
  4. Releases
  5. wp-graphql/wp-graphql on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/wp-graphql-wp-graphql.svg)](https://hysenlabs.com/projects/wp-graphql-wp-graphql)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/wp-graphql-wp-graphql.svg)](https://hysenlabs.com/projects/wp-graphql-wp-graphql)

Was this useful?