Published October 7, 2026 · altengine team

What Happened to App Engine's Legacy Bundled Services (and What Replaces Them)

App Engine's bundled services didn't disappear in one event. A few were switched off outright — Channel is the famous one. Most were never switched off at all, but were cut loose from the second-generation runtimes and only partially restored. And one, Search, is the awkward case: still callable from inside an App Engine app, never offered as a product you can call from anywhere else. This is the service-by-service map of what happened and what you can actually use instead.

Three different fates, often confused for one

"App Engine legacy services" gets used as if it named a single deprecation. It names at least three:

• Shut off. Channel was deprecated in 2016 and stopped serving traffic in 2017. The same happened earlier to Prospective Search, the Conversion API, and XMPP. There is no flag to turn these back on.
• Dropped, then partly restored. When the second-generation runtimes arrived (Python 3, Java 11/17, Go 1.12+, PHP 7+), they shipped with none of the bundled APIs — google.appengine.* simply wasn't there. Google later walked that back and made a subset reachable again from the newer runtimes: Memcache, Task Queue, Blobstore, Images, Mail, Users, App Identity, Modules, Deferred, and Search. Anything already shut off, like Channel, was obviously not on that list.
• Never retired, just awkward. Datastore is still a live, supported product. It is the one bundled service you can keep using indefinitely.

The practical consequence is that the restored list is a bridge, not a destination. Those APIs are reachable from inside an App Engine app. The moment your plan involves containers, another provider, or a local dev loop that isn't the App Engine SDK, the bridge ends and you are writing a replacement.

The map

Why Search and Channel left the biggest hole

Most of the bundled APIs were thin wrappers over something generic. URL Fetch was HTTP. Blobstore was object storage with a nicer handle. Memcache was Memcached. When those were cut loose, the replacement was a library swap and some plumbing, and the thing you were replacing them with was cheap and widely available.

Search and Channel weren't like that. Both were real managed services that happened to be billed as a line item on an app platform, and both were priced for apps that were small.

Search gave you an inverted index, a boolean query language with fielded terms and ranges, facets, stemming, sorting, and ranking — and you paid cents. The nearest standalone equivalents are a cluster you size, pay for hourly, and operate, or a hosted search product whose economics are built around larger catalogs and higher query volumes. Neither is wrong; both are a different shape from "I have 4,000 documents and I want title:jacket AND price < 150 to work."

Channel gave you server-to-client push without owning a socket tier. After the shutdown, the options were a realtime database you'd adopt whether or not you wanted its data model, a hosted pub/sub vendor, or building and operating WebSocket infrastructure yourself. For an app whose realtime need was "show the order status when it changes," all three are heavy.

That gap is the reason plenty of first-generation apps are still first-generation apps. Freezing on an old runtime was cheaper than rewriting around a bigger system.

What altengine covers

altengine's first services are rebuilds of exactly those two, plus a Datastore-shaped document store, reached over one REST/JSON API at https://api.altengine.net with an organization API key as a bearer token. (altengine is an independent project and is not affiliated with Google.)

Search — the semantics, over HTTP

Structured documents with text, html, atom, number, date, geo, and prefix field types; the App Engine query syntax including fielded terms, ranges, OR/NOT, grouping, phrases, ~ stemming, and distance(); facets; sorting; and cursor pagination.

POST /v1/search/catalog/ns/_default/idx/films/search

{ "query": "genre:comedy rating > 3",
  "limit": 20,
  "facets": ["genre"],
  "sort": [{ "expr": "rating", "desc": true, "default": 0 }] }

One thing to know going in, because it bites: facets are not fields. A document's fields make a value searchable and its facets make it countable, and faceting on something written only as a field returns an empty result rather than an error. Write it in both places. The rest of the surface — snippets, field collapsing, synonyms, merchandising rules — is in the Search API reference.

Channel — publish over HTTP, subscribe over one socket

Your server mints a short-lived, channel-scoped subscriber token; the client opens a WebSocket with it; a publish fans out to everyone connected. One socket carries many channels, and the client can add or drop channels live with control frames, within what its token authorized.

POST /v1/channel/live/publish

{ "channel": "room-42", "data": { "text": "hello" } }
# → { "delivered": 3 }

Delivery is at-most-once: a message reaches the subscribers connected at publish time, with no backlog or replay. If you need history or moderation, publish server-side and record it yourself.

Datastore — the model, with the sharp edges filed off

Datastore is the odd entry here, since it was never retired. altengine keeps the document model and the bounded query engine but loosens the contract: documents are arbitrary JSON with no declared property types, queries can join a referenced document from another collection by key, grouped aggregates (count, sum, avg, min, max) run server-side, and reads are strongly consistent with no entity groups to design around. The bound that stays is the one that earns its keep — a query must be index-served — and auto-indexing is on by default so a missing index doesn't fail you mid-build. Turn it off per instance in production and you get 400 INDEX_REQUIRED instead.

What migrating actually involves

Be clear-eyed about this: it is not a base-URL change. App Engine's Search and Channel were language SDKs, and altengine is REST/JSON. What carries over is the semantics — your query strings, field types, facet definitions, document schemas, and channel topology. What you rewrite is the call layer — the code that constructed an SDK object now constructs a request body. That's a mechanical change, usually isolated to one module, and it's a smaller job than redesigning a search index or standing up a socket tier. But it is a change, and anyone telling you a revival is "drop-in" is selling you something.

The cost shape

The thing that made the bundled services viable for small apps was that idle cost nothing. altengine keeps that: there is no cluster to keep running, so a search index you aren't querying costs only its storage, and a channel with no open connections costs nothing at all. Billing is usage-based — Search on queries, reads, writes and stored data; Channel on message deliveries and connection time; Datastore on reads, writes and stored data.

There's one pay-as-you-go plan, the first $3.00 of usage each month is free for every organization and shared across every service, and no card is needed to start. Rates are on the pricing page.

Where this goes

App Engine's services are the starting point, not the boundary. Auth, Blob, Functions, Containers, Static and Automation already sit alongside Search, Channel and Datastore, and more managed services get added as demand shows up. If there's an API from the old lineup you still miss, or one that never existed and should have, tell us — it's how we prioritize.

For the longer version of why we built the first three, see the launch post. For endpoints, grants and errors, start at the API documentation.

Start free in the console