0Pricing
tRPC End-to-End Type Safe APIs · Lesson

Implementing Query Procedures

Create read-only data fetching endpoints using tRPC query procedures with input and output types.

Implementing Query Procedures is a free tRPC End-to-End Type Safe APIs lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the tRPC End-to-End Type Safe APIs learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

What are tRPC Queries?

Queries are like asking a question to your server. They are designed for fetching data, not changing it. Think of them as the "GET" requests in a traditional REST API.

  • Read-only: Queries should never change data on your server.
  • Idempotent: Running a query multiple times should produce the same result.
  • Cached: Clients can often cache query results for better performance.

They are the foundation for retrieving information in your tRPC application.

Defining a Simple Query

In tRPC, you define queries within a router using .query(). Let's look at the basic structure.

First, you need to initialize tRPC (usually done once in your server setup):

const t = initTRPC.create();

Then, define your router and add a query:

import { initTRPC } from '@trpc/server';

// 1. Initialize tRPC
const t = initTRPC.create();

// 2. Create a router
const appRouter = t.router({
  // 3. Define a query named 'hello'
  hello: t.procedure.query(() => {
    return 'Hello from tRPC!';
  }),
});
// This snippet shows the core definition.
// A full server setup is needed to run it.

Your First Runnable Query (Server)

Let's put it all together into a minimal, runnable tRPC server. This server will host our hello query.

Save this as server.ts and run with ts-node server.ts (after npm install @trpc/server @trpc/server-adapters ts-node typescript).

import { initTRPC } from '@trpc/server';
import { createHTTPServer } from '@trpc/server/adapters/standalone';

const t = initTRPC.create();

const appRouter = t.router({
  hello: t.procedure.query(() => {
    console.log('Hello query called on server!');
    return 'Hello from tRPC!';
  }),
});

export type AppRouter = typeof appRouter;

const server = createHTTPServer({
  router: appRouter,
});

server.listen(2025);
console.log('tRPC server listening on http://localhost:2025');

Calling a Query from the Client

Now that our server is running, let's call the hello query from a client application. We'll use @trpc/client to create a proxy that mirrors our server's API.

Save this as client.ts. You'll need the server.ts running first.

import { createTRPCProxyClient, httpBatchLink } from '@trpc/client';

// Simplified AppRouter type for this example
type AppRouter = {
  hello: {
    _def: {
      _input_in: undefined;
      _input_out: undefined;
      _output_in: string;
      _output_out: string;
    };
  };
};

const trpc = createTRPCProxyClient<AppRouter>({
  links: [
    httpBatchLink({
      url: 'http://localhost:2025',
    }),
  ],
});

async function callHello() {
  try {
    const greeting = await trpc.hello.query();
    console.log(greeting); // Expected: Hello from tRPC!
  } catch (error) {
    console.error('Error calling hello query:', error);
  }
}

callHello();

Passing Data to Queries

Often, you need to send data to your queries, for example, to fetch a specific user by ID. tRPC handles this beautifully with input schemas.

You define the expected input using a validation library like Zod. This ensures your input is always type-safe and valid, both on the client and server.

  • Use .input() after t.procedure.
  • Provide a Zod schema to define the shape of your input.
  • The input will be available in the input property of the resolve function's arguments.

Querying with an ID (Server)

Let's modify our server to fetch a "user" by their ID. We'll use Zod to validate that the input is a number.

Update your server.ts with this new procedure:

import { initTRPC } from '@trpc/server';
import { createHTTPServer } from '@trpc/server/adapters/standalone';
import { z } from 'zod'; // Import Zod

const t = initTRPC.create();

const appRouter = t.router({
  getUserById: t.procedure
    .input(z.object({ id: z.number() })) // Define input schema
    .query(({ input }) => { // Access input here
      console.log(`Fetching user with ID: ${input.id}`);
      // In a real app, you'd fetch from a database
      const users = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
      return users.find(user => user.id === input.id) || null;
    }),
});

export type AppRouter = typeof appRouter;

const server = createHTTPServer({
  router: appRouter,
});

server.listen(2025);
console.log('tRPC server listening on http://localhost:2025');

Calling Query with Input (Client)

Now, from the client, we can call our getUserById query and pass the required id. tRPC will ensure the input matches the Zod schema defined on the server, giving you type safety from end-to-end.

Update your client.ts to call this new query:

import { createTRPCProxyClient, httpBatchLink } from '@trpc/client';

// Simplified AppRouter for example
type AppRouter = {
  getUserById: {
    _def: {
      _input_in: { id: number };
      _input_out: { id: number };
      _output_in: { id: number; name: string } | null;
      _output_out: { id: number; name: string } | null;
    };
  };
};

const trpc = createTRPCProxyClient<AppRouter>({
  links: [
    httpBatchLink({
      url: 'http://localhost:2025',
    }),
  ],
});

async function callGetUser() {
  try {
    const user1 = await trpc.getUserById.query({ id: 1 });
    console.log('User 1:', user1); // Expected: User 1: { id: 1, name: 'Alice' }

    const user3 = await trpc.getUserById.query({ id: 3 });
    console.log('User 3:', user3); // Expected: User 3: null
  } catch (error) {
    console.error('Error calling getUserById query:', error);
  }
}

callGetUser();

Type Safety in Query Outputs

One of tRPC's biggest advantages is its end-to-end type safety. When you define a query, tRPC automatically infers the output type based on what your resolve function returns.

  • No need to manually define response interfaces.
  • If your server's return type changes, your client code will automatically show a TypeScript error.
  • This catches bugs early, before runtime!

For our getUserById query, tRPC correctly infers the return type as { id: number; name: string } | null.

Query Best Practices

As you build more queries, keep these tips in mind:

  • Keep it Read-Only: Never perform side effects (like database writes) in a query.
  • Clear Naming: Name your queries descriptively (e.g., getUserById, listPosts).
  • Granular Inputs: Use specific Zod schemas for inputs to ensure strict validation.
  • Error Handling: While tRPC propagates errors, consider specific error types for better client feedback (more on this in a later lesson!).

Queries are fundamental for fetching data. Next, we'll look at Mutations for changing data.

Query Procedure Check

You've learned how to define and use tRPC query procedures. Let's test your understanding.

Recap: Query Procedures

Great job! In this lesson, you learned about tRPC Query procedures.

  • Queries are for fetching read-only data from your server.
  • You define them using t.procedure.query(...) within your router.
  • You can add input validation using .input(z.object(...)) with Zod.
  • tRPC provides end-to-end type safety by inferring output types automatically.

You now have the tools to build powerful, type-safe data fetching endpoints! Next, we'll explore Mutations for data manipulation.

Frequently asked questions

Is the “Implementing Query Procedures” lesson free?

Yes — the full text of “Implementing Query Procedures” is free to read here on the web, and the tRPC End-to-End Type Safe APIs course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the tRPC End-to-End Type Safe APIs course, upgrade to CoddyKit PRO.

What will I learn in “Implementing Query Procedures”?

Create read-only data fetching endpoints using tRPC query procedures with input and output types. You practise tRPC End-to-End Type Safe APIs with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start tRPC End-to-End Type Safe APIs?

No prior experience is required. tRPC End-to-End Type Safe APIs on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Implementing Query Procedures” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this tRPC End-to-End Type Safe APIs lesson?

Yes. Every tRPC End-to-End Type Safe APIs lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Structuring with tRPC Routers
  2. Implementing Query Procedures
  3. Developing Mutation Procedures
  4. Merging and Nesting Routers
← Back to tRPC End-to-End Type Safe APIs