Actyx RPC
Actyx RPC v0.7.0 is officially here

Type-Safe RPC.Composable Server Actions.

Build server-side procedures with full type safety, minimal boilerplate, and a clean, composable API. Bridges client-side queries and server-side execution seamlessly.

Read DocumentationExplore Playground
Full Type Inference
Schema-Agnostic Resolvers
Built-in Caching & Retry

Built for Production Type-Safety

Actyx RPC eliminates boilerplate and bridges the gap between client and server with full end-to-end type safety.

Type-Safe Procedures

Define server actions with full type inference from server to client. Input validation, context injection, and typed outputs — all inferred automatically.

Schema-Agnostic Resolvers

Bring your own validation library. Supports Zod, Valibot, ArkType, Joi, and Yup out of the box with a clean resolver interface.

Built-in Caching

Pluggable cache adapters including MemoryCache and RedisCache with configurable TTL, max size, and automatic invalidation strategies.

Real-Time SSE

Stream server-sent events directly to the client with automatic reconnection. Perfect for live data feeds, notifications, and progress updates.

Resilience Layer

Automatic retries with configurable backoff, circuit breaker pattern, request timeouts, and response compression for production-grade reliability.

React Integration

First-class React hooks including useQuery, useMutation, useSuspenseQuery, useInfiniteQuery, and SSE subscriptions with Suspense support.

Define Once, Use Everywhere

Create a procedure, chain your business logic, and call it from any client with full type inference.

1

Create Procedure

const procedure = createProcedure({
  createContext: () => ({
    ok: true,
    ctx: { userId: "user_1" },
  }),
  inputMode: "strict",
});

Define a base procedure with shared context, error handling, and input mode.

2

Chain Builders

const getUser = procedure
  .input(zodResolver(z.object({ id: z.string() })))
  .cache({ ttl: 60000 })
  .query(async ({ input }) => {
    return db.users.findById(input.id);
  });

Compose input validation, middleware, caching, and execution policies in any order.

3

Call from Client

const [user, error] = await getUser({ id: "123" });

// Or in React:
const { data, isLoading } = useQuery(
  () => getUser({ id: "123" }),
);

Call as a plain function or use React hooks. Full type safety end-to-end.

See It In Action

Clean procedure definitions paired with type-safe client execution. Open your browser console to inspect the network calls.

procedures.ts
TypeScript
import createProcedure from "@explita/actyx-rpc"; import z from "zod"; import zodResolver from "@explita/actyx-rpc/resolvers/zod"; // Define a procedure with context const procedure = createProcedure( createContext: () => ({ db, auth }), }); // Type-safe query procedure export const ping = procedure.query( async ({ ctx, input }) => ({ message: "pong", serverTime: new Date().toISOString(), }), }); // With input validation export const greet = procedure .input(zodResolver(z.object({ name: z.string().min(1), }))) .query(async ({ input }) => ({ greeting: `Hello, ${input.name}!`, serverTime: new Date().toISOString(), }), });

Live Actyx RPC Instance

Execute queries against the server and inspect responses below.

Server Ping
Connecting...
End-to-End Type Safety

Every query flows through the full type pipeline — from the procedure definition on the server to the useQuery hook on the client. Errors are caught at compile time, not runtime. Open your DevTools Network tab to inspect the underlying HTTP calls.

Ready to Build Type-Safe APIs?

Install, define a procedure, and call it from anywhere. Full type safety from server to client.

npm install @explita/actyx-rpc
Read DocumentationView on GitHub