---
title: "Vite · React · Apollo Client · GraphQL over WebSocket"
url: "https://spinetab.com/docs/recipes/vite-react/apollo/graphql-ws/"
description: "GraphQL over WebSocket with Apollo Client in Vite · React: dependencies, configuration, component and cleanup."
---

# Vite · React · Apollo Client · GraphQL over WebSocket

Share GraphQL subscriptions through Apollo's client.

**Available recipes**

- [Vite · React · Apollo Client · GraphQL over WebSocket](https://spinetab.com/docs/recipes/vite-react/apollo/graphql-ws.md)
- [Vite · React · Apollo Client · GraphQL over SSE](https://spinetab.com/docs/recipes/vite-react/apollo/graphql-sse.md)

GraphQL over WebSocket · [Vite · React](https://spinetab.com/docs/setup/vite.md)

## Before you start

Start with an existing Vite · React app. Keep its renderer, routes and plugins. These files add one live view; Spinetab does not create your API.

Your schema exposes `Subscription.queue: Queue!` with `Queue.open: Int!`. Each event contains the complete queue value. Serve the graphql-transport-ws protocol at /graphql. Queries and mutations, if used, go to `/graphql`. This is a GraphQL endpoint, not a plain SSE or WebSocket feed.

The examples use same-origin URLs and declare `anonymous: true`: no token is supplied, although cookies still flow. For a separate API origin, use its URL and configure CORS or your application's proxy. For private data, add [credentials and user scopes](https://spinetab.com/docs/concepts/credentials.md); never put a secret in these files.

## 1\. Install

```sh
pnpm add spinetab graphql@^17.0.2 graphql-ws@^6.3.0 @apollo/client@^4.3.1 rxjs@^7.8.2
```

Keep your framework's existing dependencies. See [compatible versions](https://spinetab.com/docs/compatibility.md) if upgrading an older app.

## 2\. Configure your app

Merge this addition into your configuration; preserve existing plugins and options. Restart the dev server afterwards. The plugin bundles the worker and discovers the adapters imported below.

**File: `vite.config.ts`**

```ts
import react from "@vitejs/plugin-react";
import { spinetab } from "spinetab/vite";
import { defineConfig } from "vite";

export default defineConfig({ plugins: [react(), spinetab()] });
```

## 3\. Connect and render

Save these files together in `src/recipe/`.

The provider supplies Apollo's client to its subscription hook. Keep an existing app provider/client when extending an Apollo app rather than introducing a second cache.

`reconcile: "latest"` fits this full-state contract: the next complete event restores the displayed value after a gap. Use a [refresh/merge policy](https://spinetab.com/docs/concepts/continuity.md) for deltas or partial GraphQL results. Reconnecting alone does not reconstruct missed state.

**File: `src/recipe/live.ts`**

```ts
import { createSpinetab } from "spinetab";

export const spinetab = createSpinetab({ anonymous: true });
```

**File: `src/recipe/queue-types.ts`**

```ts
export type Queue = { open: number };
export type QueueView = { open?: number; problem?: string };
```

**File: `src/recipe/endpoint.ts`**

```ts
import { graphqlWs } from "spinetab/graphql-ws";

export const endpoint = graphqlWs("/graphql");
```

**File: `src/recipe/document.ts`**

```ts
import { gql, type TypedDocumentNode } from "@apollo/client";
import type { Queue } from "./queue-types";

export const QUEUE: TypedDocumentNode<{ queue: Queue }> = gql`
  subscription Queue { queue { open } }
`;
```

**File: `src/recipe/client.ts`**

```ts
import { ApolloClient, HttpLink, InMemoryCache } from "@apollo/client";
import { spinetabSplit } from "spinetab/apollo";
import { endpoint } from "./endpoint";
import { spinetab } from "./live";

export function makeClient() {
	return new ApolloClient({
		cache: new InMemoryCache(),
		link: spinetabSplit(spinetab, endpoint, new HttpLink({ uri: "/graphql" }), {
			reconcile: "latest",
		}),
	});
}
```

**File: `src/recipe/Queue.tsx`**

```tsx
import { useSubscription } from "@apollo/client/react";
import { QUEUE } from "./document";

export default function Queue() {
	const { data, error } = useSubscription(QUEUE);
	if (error) return <p role="alert">{error.message}</p>;
	if (!data) return <p role="status">Loading queue…</p>;
	return (
		<p>
			<output>{data.queue.open}</output> open
		</p>
	);
}
```

**File: `src/recipe/Recipe.tsx`**

```tsx
import { ApolloProvider } from "@apollo/client/react";
import { useState } from "react";
import { makeClient } from "./client";
import Queue from "./Queue";

export default function Recipe() {
	const [client] = useState(makeClient);
	return (
		<ApolloProvider client={client}>
			<Queue />
		</ApolloProvider>
	);
}
```

## 4\. Mount the view

**File: `src/App.tsx`**

```tsx
import Recipe from "./recipe/Recipe";
export default function App() {
	return <Recipe />;
}
```

Your existing entry point mounts App as usual. Keep its renderer plugin; no additional application provider is required beyond those shown.

## Check the result

Open the page in two tabs of the same browser profile. Both should show advancing queue values. Matching subscriptions share upstream work when SharedWorker is available; fallback runs independently in each tab. Remove one view and the other should keep updating. Removing the last view releases its subscription; connection closure can follow the adapter's idle delay.

[API options and advanced recovery](https://spinetab.com/docs/integrations/apollo.md) · [Authentication](https://spinetab.com/docs/concepts/credentials.md)
