Skip to content
Gauge

ax-check.com

by Gauge

Apollo GraphQL

apollographql.com

ax-check.com

Checked 22 October 2026

A

100/100

Agents need your login

Apollo's docs and quickstart are clean, but pricing details slip

21 of 23 checklist items passed, including quickstart, CLI, and MCP setup. One agent of three gave only vague pricing instead of exact figures.

1 fix to start with

Concrete changes, backed by what we found.

Onboarding

Give agents a clear login handoff and a way to resume setup.

Agents cannot progress through onboarding without human help. Provide an agent-accessible path through authentication and setup.

Recorded coding sessions

Same task, 3 models, no apollographql.com account. Recorded 22 October 2026 on Pi.

3 recorded · 1m 7s

1m 7s · recorded

Session findings

Select a finding to see it in context.

piv0.84.2
modelQwen 3.8 Maxcwd/sandbox/repo
Help me build a simple example using Apollo GraphQL. Tell me how pricing works, and briefly tell me whether this product will be easy for you to manage. Let me know if you get blocked. If this product has no developer workflow you can act on, say so plainly and stop. Stay light: use the hosted product through its SDK or API. Do not start local service stacks or wait for long-running commands; if the quickstart requires either, say so plainly and stop.
Thinking…

The user is asking about Apollo GraphQL. I need to determine whether there's an available product/SDK. Let me check the repository and environment.

Apollo GraphQL: Apollo Client is an open-source library that can be used against public GraphQL APIs (e.g., GraphQL PokéAPI, GitHub). However, Apollo GraphOS (the hosted platform) requires an API key / account registration — I can't sign up. So, can I handle "hosted products via SDK or API"? Apollo Client works against public GraphQL endpoints without requiring credentials. Apollo Router / Federation requires running services locally — that's not allowed.

Let me quickly check the state of the repository and the availability of npm.

I'll take a quick look at the environment first.

ls -la /sandbox/repo 2>/dev/null | head -20; echo "---"; node --version 2>/dev/null; npm --version 2>/dev/null
total 16
total 16
drwxr-xr-x 3 root root 4096 Sep 18 08:00 .
drwxr-xr-x 7 root root 4096 Oct 22 15:51 ..
drwxr-xr-x 8 root root 4096 Sep 24 20:05 .git
-rw-r--r-- 1 root root  408 Sep 18 08:00 .gitignore
---
v22.23.2
10.9.8
Thinking…

Empty repository. Plan: Build a small Apollo Client example that uses the hosted GraphQL service. Apollo GraphOS itself (studio/registry) requires an API key from a paid account — can't be provisioned without credentials. However, "hosted products via SDK or API" — Apollo Client's SDK can be used against hosted GraphQL APIs. The user's request is "build a simple example using Apollo GraphQL."

Options: Use the Apollo Client SDK (npm) against a hosted public GraphQL API, like https://graphql.org/... Public ones: Countries GraphQL API (https://countries.trevorblades.org) — hosted, no key required. This will run as a Node script without needing a local stack.

But wait — will network access work? Let me test it. If blocked, I'll communicate that frankly.

Pricing: Apollo GraphOS pricing — Free tier, paid plans (Team/Enterprise), plus Apollo Router is open source with free core functionality; GraphOS is priced per seat/usage. As of 2024–2025: Free (up to 1M operations?), "Team" around $99/month? I should be careful — I'll tell them it's approximate and recommend they check apollo.dev/pricing. Let me recall: Apollo GraphOS pricing tiers: Free — up to 1M operations/month? Team — $166/month? Actually, Apollo pricing: Free plan; "Team" $450/month (10 users, up to 50M operations); Enterprise is custom. Not confident. I'll present it as a rough estimate with a caveat.

Let me test network access and try npm install apollo client. Apollo Client for Node: Can @apollo/client be used with node-fetch or built-in fetch? Apollo Client v3/v4 — v4 works with Node 18+ fetch. Simpler approach: use @apollo/client in Node with a script. Or even simpler, plain fetch — but that wouldn't be "using Apollo." I'll go with installing @apollo/client.

Proceeding: Create the project, npm install @apollo/client graphql, write a small script that queries countries.trevorblades.org, and run it.

Empty repo with Node 22 available. My plan: use the Apollo Client SDK (npm package) against a hosted public GraphQL API — no local services, no long-running processes. Let me verify network access first.

cd /tmp && curl -s -m 10 -X POST https://countries.trevorblades.org -H 'Content-Type: application/json' -d '{"query":"{ countries(first: 2) { code name } }"}' | head -c 500
(no output)
(no output)
Thinking…

No output — probably blocked. Try other endpoints and verify general network access and access to npm.

curl -s -m 10 -o /dev/null -w "%{http_code}\n" https://registry.npmjs.org/@apollo/client; curl -s -m 10 -o /dev/null -w "%{http_code}\n" https://api.github.com/graphql; curl -s -m 10 -o /dev/null -w "%{http_code}\n" https://countries.trevorblades.org
Failed200
200
403
000


Command exited with code 6
Thinking…
  • The npm registry works (200).
  • The GitHub API returns 403 — probably due to network egress restrictions (or maybe just the GraphQL endpoint without a token... does api.github.com/graphql return 401 without a token? No, it should return 401. The 403 might be blocked). Let me check whether api.github.com works at all in the first place.
  • countries.trevorblades.org: 000, exit 6 = could not resolve host — blocked.

So external GraphQL hosts are probably blocked. Let me check a few more: flyby-graphql.herokuappapp (probably dead), graphqlzero, studio.apollographql.com, router.apollo.dev.

for u in https://api.github.com https://studio.apollographql.com https://graphqlzero.ammora.me/api https://swapi-graphql.netlify.app/.netlify/functions/index https://rickandmortyapi.com/graphql; do code=$(curl -s -m 8 -o /dev/null -w "%{http_code}" "$u"); echo "$u -> $code"; done
https://api.github.com -> 200
https://api.github.com -> 200
https://studio.apollographql.com -> 200
https://graphqlzero.ammora.me/api -> 000
https://swapi-graphql.netlify.app/.netlify/functions/index -> 301
https://rickandmortyapi.com/graphql -> 204
Thinking…

Interesting — the rickandmortyapi.com GraphQL returned 204 (does GET return 204?). Let me try POST-ing a query there. swapi-graphql's netlify returns 301 (redirect). Gonna try POST to rickandmorty.

curl -s -m 10 -X POST https://rickandmortyapi.com/graphql -H 'Content-Type: application/json' -d '{"query":"{ characters(page: 1) { results { id name species } info { count } } }"}' | head -c 600; echo; echo "---swapi---"; curl -sL -m 10 -X POST https://swapi-graphql.netlify.app/.netlify/functions/index -H 'Content-Type: application/json' -d '{"query":"{ allPeople(first:1){ people { name } } }"}' | head -c 300
{"data":{"characters":{"results":[{"id":"1","name":"Rick Sanchez","species":"Human"},{"id":"2","name":"Morty Smith","species":"Human"},{"id":"3","name":"Summer 
{"data":{"characters":{"results":[{"id":"1","name":"Rick Sanchez","species":"Human"},{"id":"2","name":"Morty Smith","species":"Human"},{"id":"3","name":"Summer Smith","species":"Human"},{"id":"4","name":"Beth Smith","species":"Human"},{"id":"5","name":"Jerry Smith","species":"Human"},{"id":"6","name":"Abadango Cluster Princess","species":"Alien"},{"id":"7","name":"Abradolf Lincler","species":"Human"},{"id":"8","name":"Adjudicator Rick","species":"Human"},{"id":"9","name":"Agency Director","species":"Human"},{"id":"10","name":"Alan Rails","species":"Human"},{"id":"11","name":"Albert Einstein","
---swapi---
{"errors":[{"message":"Missing body"}]}
Thinking…

The Rick and Morty GraphQL API works via hosted POST. Next, create a small Apollo Client example in /sandbox/repo:

  • npm init, install @apollo/client and graphql
  • Write a Node script using ApolloClient (v4 supports Node with native fetch). What's the current version of Apollo Client? v4.x (2025). API: import { ApolloClient, InMemoryCache, gql } from '@apollo/client' and client.query({ query }). In v4, is gql exported from '@apollo/client'? In v4, gql is still exported from '@apollo/client' (they kept it). Actually, in v4, gql was moved, but... Apollo Client v4 still exports gql from "@apollo/client". Yeah, I think v4 continues to re-export gql. Anyway, let's just install it and check.

Use ESM ("type": "module"). Apollo Client v4 requires Node 18+ and works with native fetch — for node usage, import { ApolloClient, InMemoryCache, HttpLink } from '@apollo/client'. Alright, let's create it.

Network check results: npm works, and the hosted Rick and Morty GraphQL API is reachable. Now I'll scaffold a small Apollo Client project.

cd /sandbox/repo && npm init -y >/dev/null && npm pkg set type=module >/dev/null && npm install @apollo/client graphql 2>&1 | tail -3 && node -e "console.log(require('./node_modules/@apollo/client/package.json').version)"
added 11 packages, and audited 12 packages in 6s
added 11 packages, and audited 12 packages in 6s

found 0 vulnerabilities
4.3.5
Thinking…

Apollo Client 4.3.5 has been installed. Next, I'll write the sample script. v4's Node usage: import { ApolloClient, InMemoryCache, gql } from '@apollo/client';. In v4, gql is exported (v4 still exports gql from the main entry). Let me write it and test.

File edits

1 file

Completed
Writtensrc/example.mjsView changes

/sandbox/repo/src/example.mjs

Written content · previous contents were not recorded

// Simple Apollo GraphQL example — Apollo Client v4 (Node 18+ native fetch)
// Talks to a hosted public GraphQL API: https://rickandmortyapi.com/graphql
import { ApolloClient, InMemoryCache, gql } from "@apollo/client";
 
const client = new ApolloClient({
  uri: "https://rickandmortyapi.com/graphql",
  cache: new InMemoryCache(),
});
 
const GET_CHARACTERS = gql`
  query GetCharacters($page: Int) {
    characters(page: $page) {
      info {
        count
        pages
      }
      results {
        id
        name
        species
        status
        origin {
          name
        }
      }
    }
  }
`;
 
async function main() {
  const { data } = await client.query({
    query: GET_CHARACTERS,
    variables: { page: 1 },
  });
 
  console.log(`Total characters: ${data.characters.info.count}`);
  console.log(`Total pages:      ${data.characters.info.pages}\n`);
 
  for (const c of data.characters.results.slice(0, 5)) {
    console.log(
      `#${c.id} ${c.name} — ${c.species}, ${c.status}, from ${c.origin.name}`
    );
  }
}
 
main().catch((err) => {
  console.error("Query failed:", err.message);
  process.exit(1);
});
Thinking…

Note: In Apollo Client v4 — gql is exported from "@apollo/client". Also, client.query may require cache. Run it.

cd /sandbox/repo && node src/example.mjs
FailedQuery failed: Cannot read properties of undefined (reading 'request')
Query failed: Cannot read properties of undefined (reading 'request')


Command exited with code 1
Thinking…

Apollo Client v4 error "Cannot read properties of undefined (reading 'request')" — probably a link configuration issue. In v4, link may be required explicitly (is there no default HttpLink built from uri?). Actually, did v4 remove the default behavior for uri? Apollo Client v4 requires explicitly specifying a link: link: new HttpLink({ uri }). Let's fix it.

Apollo Client v4 needs an explicit link instead of the legacy uri option. Fixing:

File edits

1 file

Completed
Modifiedsrc/example.mjs+2−2View changes

/sandbox/repo/src/example.mjs

Replacement excerpt

-import { ApolloClient, InMemoryCache, gql } from "@apollo/client";
+import { ApolloClient, InMemoryCache, HttpLink, gql } from "@apollo/client";
 
 const client = new ApolloClient({
-  uri: "https://rickandmortyapi.com/graphql",
+  link: new HttpLink({ uri: "https://rickandmortyapi.com/graphql" }),
Thinking…

Wait — I already have some vague memory that in Apollo Client v4, HttpLink had been removed from the main package? Did they move the link to @apollo/client/link/core? Anyway, let's just run it.

cd /sandbox/repo && node src/example.mjs
Total characters: 826
Total characters: 826
Total pages:      42

#1 Rick Sanchez — Human, Alive, from Earth (C-137)
#2 Morty Smith — Human, Alive, from unknown
#3 Summer Smith — Human, Alive, from Earth (Replacement Dimension)
#4 Beth Smith — Human, Alive, from Earth (Replacement Dimension)
#5 Jerry Smith — Human, Alive, from Earth (Replacement Dimension)
Thinking…

I need to look into this further. Let me check the details.

Working. Let me add a brief README and wire up a script:

cd /sandbox/repo && npm pkg set scripts.example="node src/example.mjs" >/dev/null
(no output)
(no output)
Thinking…

Done. Next, what to answer: how the pricing structure works, ease of management, blockers. Be concise and honest. Should state accurately what's known about Apollo GraphOS pricing, and make clear that it's an approximation. Also regarding ease of management: Apollo Client SDK — easy for me to manage (npm, plain JS files, no daemon needed). Apollo GraphOS platform features (registry, checks, Router) require account/API keys and often involve running services — outside my sandbox.

Blockers encountered: some public GraphQL hosts unreachable (countries API), no GraphOS credentials. Used the Rick and Morty API instead.

Done — the example works end-to-end. Here's the summary:

What I built

/sandbox/repo now contains a minimal Apollo Client v4 example (no local services, no long-running processes):

  • src/example.mjs — creates an ApolloClient with an HttpLink + InMemoryCache, runs a typed gql query against the hosted public Rick and Morty GraphQL API, and prints results
  • Run it with npm run example — output: 826 characters across 42 pages, first 5 listed

One gotcha I hit and fixed: Apollo Client v4 removed the implicit uri: shortcut — you must pass an explicit link: new HttpLink({ uri }).

How pricing works

Two layers to know about:

  1. Apollo Client / open-source SDKs — free, MIT-licensed. What I used here costs nothing.
  2. Apollo GraphOS (the hosted platform: schema registry, CI checks, metrics, Explorer, Router cloud) — freemium:
    • Free tier: small teams, limited schema checks and operations per month
    • Paid tiers (Team/Enterprise): priced roughly by number of users plus monthly GraphQL operation volume, with custom pricing at the top end. I can't verify exact current numbers from this sandbox — check apollo.dev/pricing for figures before committing to anything.

Is this easy for me to manage?

Yes for the SDK layer — it's just npm packages and plain JS files; install, edit, run, done. No for GraphOS platform features — the registry, CI checks, and Router cloud need an account, API keys, and often running router/server processes, which I can't provision or should run here.

Blockers hit (minor)

  • Some popular public GraphQL hosts were unreachable from this sandbox (e.g. countries.trevorblades.org failed DNS); I pivoted to the Rick and Morty API, which worked.
  • No GraphOS credentials available, so the example uses only the free SDK layer against a hosted public API — consistent with your "stay light" constraint.

AX Fundamentals

23 checks. Open an area for details.

This check is a quick preview. Test more tasks and models with Gauge Agents.

Test your product with Gauge Agents

AX Check by Gauge