{"id":1152,"date":"2026-07-04T06:08:57","date_gmt":"2026-07-03T23:08:57","guid":{"rendered":"https:\/\/sumberlaba.com\/index.php\/2026\/07\/04\/how-to-use-trpc-for-end-to-end-type-safety-a-comprehensive-tutorial\/"},"modified":"2026-07-04T06:08:57","modified_gmt":"2026-07-03T23:08:57","slug":"how-to-use-trpc-for-end-to-end-type-safety-a-comprehensive-tutorial","status":"publish","type":"post","link":"https:\/\/sumberlaba.com\/index.php\/2026\/07\/04\/how-to-use-trpc-for-end-to-end-type-safety-a-comprehensive-tutorial\/","title":{"rendered":"How to Use tRPC for End-to-End Type Safety: A Comprehensive Tutorial"},"content":{"rendered":"<h1>How to Use tRPC for End-to-End Type Safety: A Comprehensive Tutorial<\/h1>\n<p>Modern web development has long struggled with the disconnect between frontend and backend type systems. Even with TypeScript on both sides, maintaining consistent types across the network boundary often requires manually duplicating interfaces, generating OpenAPI specs, or relying on code generators that add complexity to the build pipeline. This is where tRPC comes in as a radical paradigm shift. tRPC (TypeScript Remote Procedure Call) allows you to build fully typesafe APIs with no code generation, no runtime schema, and no REST endpoints to manage manually. Instead, you simply import functions from your backend into your frontend, and TypeScript ensures that every parameter, response, and error is perfectly aligned. In this comprehensive tutorial, we will walk through everything you need to know to implement tRPC in a real-world application\u2014from initial setup to advanced patterns like middleware, error handling, and subscriptions. By the end, you will understand why tRPC is rapidly becoming the standard for full\u2011stack TypeScript developers and how you can leverage it for end\u2011to\u2011end type safety that eliminates an entire class of runtime bugs.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/via.placeholder.com\/800x600\/4a90d9\/ffffff?text=how%20to%20use%20tRPC%20for%20end%20to%20end%20typesafety\" alt=\"Article illustration\" style=\"display:block;margin:20px auto;max-width:100%;height:auto;border-radius:8px;\" \/><\/p>\n<p>The core philosophy behind tRPC is simple: treat your backend procedures as if they were local functions. Instead of defining routes and manually serializing JavaScript objects over HTTP, tRPC uses a lightweight server adapter (Express, Fastify, Next.js, etc.) to expose TypeScript functions as callable endpoints. On the client side, the same type definitions are imported directly from a shared package or a monorepo, giving you full autocompletion and compile\u2011time checking for every API call. This approach not only reduces boilerplate dramatically but also eliminates the need for middleware like Redux Toolkit Query or React Query to manually type responses\u2014tRPC integrates naturally with React Query for caching and revalidation while keeping everything typesafe. In this tutorial, we will assume you are building a Next.js application (the most common tRPC use case), but the principles apply to any Node.js framework. We will cover server setup, router creation, client integration, error handling, and real\u2011time subscriptions, and we will include practical tables and FAQs to solidify your understanding. Let\u2019s dive in.<\/p>\n<h2>What Is tRPC and Why Does End\u2011to\u2011End Type Safety Matter?<\/h2>\n<p>End\u2011to\u2011end type safety means that the types used on the backend (for input validation, database models, and return values) are automatically enforced on the frontend without any additional effort from the developer. In a traditional REST or GraphQL setup, you typically define your types on the backend (e.g., using Zod, Prisma, or TypeScript interfaces) and then manually replicate them on the frontend, often leading to mismatches when the API evolves. GraphQL mitigates this with a schema definition language and code generation, but it still requires a separate schema file and a complex build step. tRPC bypasses this entirely by leveraging TypeScript\u2019s type system across the network. When you define a procedure on the server using <code>.query()<\/code> or <code>.mutation()<\/code>, the input and output types are inferred directly from the function signature. The client then imports the router type and can call these procedures with full IntelliSense and type checking. If you change the return shape of a query, the frontend will immediately show a TypeScript error at compile time, preventing runtime crashes. This tight feedback loop is the holy grail of full\u2011stack development, and tRPC delivers it without sacrificing performance or flexibility.<\/p>\n<h2>Step\u2011by\u2011Step Guide to Implementing tRPC<\/h2>\n<h3>Step 1: Setting Up the Project and Installing Dependencies<\/h3>\n<p>Start by creating a new Next.js application with TypeScript. You can use the official Next.js starter or set up a monorepo with Turborepo if you plan to scale. For this tutorial, we\u2019ll use a simple standalone Next.js project:<\/p>\n<pre><code>npx create-next-app@latest my-trpc-app --typescript\ncd my-trpc-app\n<\/code><\/pre>\n<p>Next, install the core tRPC packages along with React Query and Zod for validation. tRPC works with React Query to handle caching and refetching, so we need both:<\/p>\n<pre><code>npm install @trpc\/server @trpc\/client @trpc\/react-query @trpc\/next @tanstack\/react-query zod\n<\/code><\/pre>\n<p>If you plan to use subscriptions, also install <code>@trpc\/server<\/code> with WebSocket support (we\u2019ll cover this later). For the server adapter, Next.js uses the App directory or Pages directory. In this guide we will use the App Router, which is the modern recommended approach. Create the following file structure inside <code>src\/<\/code>:<\/p>\n<ul>\n<li><code>src\/server\/trpc.ts<\/code> \u2013 where we initialize the tRPC instance with context and middleware.<\/li>\n<li><code>src\/server\/routers\/<\/code> \u2013 folder for individual routers (e.g., <code>user.ts<\/code>, <code>post.ts<\/code>).<\/li>\n<li><code>src\/server\/index.ts<\/code> \u2013 app router that merges all sub\u2011routers.<\/li>\n<li><code>src\/trpc\/server.ts<\/code> \u2013 server\u2011side client for calling procedures from SSR or server components.<\/li>\n<li><code>src\/trpc\/client.ts<\/code> \u2013 client\u2011side tRPC client for React hooks.<\/li>\n<\/ul>\n<p>With the foundation laid, you are ready to define your first procedure.<\/p>\n<h3>Step 2: Defining Procedures \u2013 Queries, Mutations, and Subscriptions<\/h3>\n<p>Procedures are the core building blocks in tRPC. They are functions that can be called remotely. The three types mirror HTTP concepts: <strong>queries<\/strong> for fetching data (GET), <strong>mutations<\/strong> for changing data (POST\/PUT\/DELETE), and <strong>subscriptions<\/strong> for real\u2011time updates (WebSocket). Each procedure can accept an input that is validated by Zod, and returns a typed output. Create a file <code>src\/server\/routers\/user.ts<\/code>:<\/p>\n<pre><code>import { z } from 'zod';\nimport { router, publicProcedure } from '..\/trpc';\n\nexport const userRouter = router({\n  getById: publicProcedure\n    .input(z.object({ id: z.string() }))\n    .query(async ({ input }) => {\n      \/\/ Simulate a database call\n      const user = { id: input.id, name: 'John Doe', email: 'john@example.com' };\n      return user;\n    }),\n  updateName: publicProcedure\n    .input(z.object({ id: z.string(), name: z.string().min(1) }))\n    .mutation(async ({ input }) => {\n      \/\/ Update user in database\n      return { success: true, id: input.id, newName: input.name };\n    }),\n});\n<\/code><\/pre>\n<p>Notice that <code>publicProcedure<\/code> is an alias for an unauthenticated procedure. You can later wrap it in middleware to enforce authentication. The input is validated at runtime using Zod, and the return type is automatically inferred from the function\u2019s return. On the frontend, the client will know that <code>getById<\/code> expects an object with <code>id: string<\/code> and returns <code>{ id: string; name: string; email: string }<\/code>. Any mismatch will cause a TypeScript error. To create subscriptions, you use <code>publicProcedure.subscription()<\/code> with an async generator or event emitter, but we\u2019ll cover that in a later step.<\/p>\n<h3>Step 3: Creating the Root Router and Context<\/h3>\n<p>The root router combines all sub\u2011routers into a single API contract. Context is a way to inject dependencies (like database clients, session data, or request\u2011scoped values) into every procedure. In <code>src\/server\/trpc.ts<\/code>, define the context factory and the base tRPC instance:<\/p>\n<pre><code>import { initTRPC } from '@trpc\/server';\nimport { CreateNextContextOptions } from '@trpc\/server\/adapters\/next';\nimport { getServerSession } from 'next-auth'; \/\/ Example authentication\n\nexport const createContext = async (opts: CreateNextContextOptions) => {\n  const session = await getServerSession(opts.req, opts.res);\n  return {\n    session,\n    db: prisma, \/\/ Your Prisma client\n  };\n};\n\nconst t = initTRPC.context&lt;typeof createContext&gt;().create();\nexport const router = t.router;\nexport const publicProcedure = t.procedure;\nexport const middleware = t.middleware;\n<\/code><\/pre>\n<p>Then in <code>src\/server\/index.ts<\/code>, merge all routers:<\/p>\n<pre><code>import { router } from '.\/trpc';\nimport { userRouter } from '.\/routers\/user';\nimport { postRouter } from '.\/routers\/post';\n\nexport const appRouter = router({\n  user: userRouter,\n  post: postRouter,\n});\n\nexport type AppRouter = typeof appRouter;\n<\/code><\/pre>\n<p>Now you have a type\u2011safe API contract defined entirely in TypeScript. The exported <code>AppRouter<\/code> type is what the client will import.<\/p>\n<h3>Step 4: Connecting the tRPC Client on the Frontend (React \/ Next.js App Router)<\/h3>\n<p>With the server ready, it\u2019s time to set up the client. In Next.js App Router, you create a tRPC provider that wraps your application. First, create <code>src\/trpc\/client.ts<\/code>:<\/p>\n<pre><code>import { createTRPCReact } from '@trpc\/react-query';\nimport type { AppRouter } from '@\/server';\n\nexport const trpc = createTRPCReact&lt;AppRouter&gt;();\n<\/code><\/pre>\n<p>This generates the hooks you will use in your components. Next, create a provider component (<code>src\/trpc\/Provider.tsx<\/code>):<\/p>\n<pre><code>'use client';\nimport { QueryClient, QueryClientProvider } from '@tanstack\/react-query';\nimport { httpBatchLink } from '@trpc\/client';\nimport { useState } from 'react';\nimport { trpc } from '.\/client';\n\nexport default function TRPCProvider({ children }: { children: React.ReactNode }) {\n  const [queryClient] = useState(() => new QueryClient());\n  const [trpcClient] = useState(() =>\n    trpc.createClient({\n      links: [httpBatchLink({ url: '\/api\/trpc' })],\n    })\n  );\n  return (\n    <trpc.Provider client={trpcClient} queryClient={queryClient}>\n      <QueryClientProvider client={queryClient}>{children}<\/QueryClientProvider>\n    <\/trpc.Provider>\n  );\n}\n<\/code><\/pre>\n<p>Wrap your root layout with this provider. Finally, create the API endpoint handler that tRPC uses: <code>src\/app\/api\/trpc\/[trpc]\/route.ts<\/code> (for App Router):<\/p>\n<pre><code>import { fetchRequestHandler } from '@trpc\/server\/adapters\/fetch';\nimport { appRouter } from '@\/server';\nimport { createContext } from '@\/server\/trpc';\n\nconst handler = (req: Request) =>\n  fetchRequestHandler({\n    endpoint: '\/api\/trpc',\n    req,\n    router: appRouter,\n    createContext,\n  });\n\nexport { handler as GET, handler as POST };\n<\/code><\/pre>\n<p>Now you can use hooks inside any client component:<\/p>\n<pre><code>'use client';\nimport { trpc } from '@\/trpc\/client';\n\nexport default function UserProfile({ id }: { id: string }) {\n  const { data, isLoading } = trpc.user.getById.useQuery({ id });\n  if (isLoading) return &lt;p&gt;Loading...&lt;\/p&gt;;\n  return &lt;p&gt;{data?.name}&lt;\/p&gt;;\n}\n<\/code><\/pre>\n<p>The hook <code>useQuery<\/code> is fully typesafe: the input parameter is typed, and the <code>data<\/code> object matches the server\u2019s output exactly. Mutations work similarly with <code>useMutation<\/code>.<\/p>\n<h3>Step 5: Error Handling and Custom Middleware<\/h3>\n<p>tRPC provides a structured way to handle errors. You can throw <code>TRPCError<\/code> inside a procedure, which will be serialized to the client as an error with a code (e.g., UNAUTHORIZED, NOT_FOUND). Example:<\/p>\n<pre><code>import { TRPCError } from '@trpc\/server';\n\nexport const userRouter = router({\n  getSecret: publicProcedure\n    .query(({ ctx }) => {\n      if (!ctx.session) throw new TRPCError({ code: 'UNAUTHORIZED' });\n      return { secret: 's3cret' };\n    }),\n});\n<\/code><\/pre>\n<p>On the client, you can catch these errors using the <code>onError<\/code> callback in the query options or via the <code>trpc.useUtils().user.getSecret.fetch()<\/code> pattern. For more advanced logic, you can create middleware that applies to multiple procedures. For example, an authentication middleware that attaches the user object to the context:<\/p>\n<pre><code>const isAuth = middleware(async ({ ctx, next }) => {\n  if (!ctx.session?.user) throw new TRPCError({ code: 'UNAUTHORIZED' });\n  return next({\n    ctx: {\n      user: ctx.session.user,\n    },\n  });\n});\n\nexport const protectedProcedure = publicProcedure.use(isAuth);\n<\/code><\/pre>\n<p>Now any procedure using <code>protectedProcedure<\/code> will automatically require a valid session.<\/p>\n<h3>Step 6: Subscriptions for Real\u2011Time Updates<\/h3>\n<p>To enable real\u2011time features like live chat or notifications, tRPC supports subscriptions. On the server, you need to add WebSocket support. Install <code>ws<\/code> and use the <code>applyWSSHandler<\/code> from <code>@trpc\/server\/adapters\/ws<\/code>. Here\u2019s a minimal example:<\/p>\n<pre><code>import { applyWSSHandler } from '@trpc\/server\/adapters\/ws';\nimport { WebSocketServer } from 'ws';\nimport { appRouter } from '.\/server';\nimport { createContext } from '.\/server\/trpc';\n\nconst wss = new WebSocketServer({ port: 3001 });\napplyWSSHandler({ wss, router: appRouter, createContext });\n<\/code><\/pre>\n<p>Then define a subscription procedure:<\/p>\n<pre><code>import { observable } from '@trpc\/server\/observable';\n\nexport const liveRouter = router({\n  onMessage: publicProcedure.subscription(() => {\n    return observable&lt;string&gt;((emit) => {\n      const interval = setInterval(() => emit.next('New message!'), 2000);\n      return () => clearInterval(interval);\n    });\n  }),\n});\n<\/code><\/pre>\n<p>On the client, you use <code>trpc.live.onMessage.useSubscription()<\/code> and receive real\u2011time data. The types remain consistent throughout.<\/p>\n<h2>Best Practices and Tips for Production\u2011Ready tRPC<\/h2>\n<h3>Tip 1: Always Validate Inputs with Zod (or Your Validator of Choice)<\/h3>\n<p>Even though TypeScript catches type mismatches at compile time, runtime validation is essential for security and data integrity. tRPC is agnostic to validation libraries but Zod is the most commonly used due to its excellent TypeScript integration. Always define strict input schemas\u2014never trust the client. For complex inputs, compose schemas using Zod\u2019s <code>.merge()<\/code> or <code>.object()<\/code>. This also acts as built\u2011in documentation for what your API expects.<\/p>\n<h3>Tip 2: Leverage React Query\u2019s Caching and Revalidation<\/h3>\n<p>tRPC\u2019s React integration is built on top of <code>@tanstack\/react-query<\/code>, meaning you get all its caching, background refetching, and mutation invalidation capabilities without extra work. Use <code>trpc.useUtils()<\/code> to manually invalidate queries after a mutation. For example, after updating a user\u2019s name, call <code>utils.user.getById.invalidate({ id })<\/code> to refetch that user\u2019s data. This keeps your UI synchronized with the server without manual state management.<\/p>\n<h3>Tip 3: Structure Your Routers Modularly<\/h3>\n<p>As your application grows, avoid a monolithic router file. Group related procedures into sub\u2011routers (e.g., <code>userRouter<\/code>, <code>postRouter<\/code>, <code>paymentRouter<\/code>) and merge them into the root <code>appRouter<\/code>. This keeps the codebase maintainable and allows you to reuse middleware selectively. Also consider using a monorepo with a shared types package if you have a separate frontend and backend repository.<\/p>\n<h2>Reference Tables<\/h2>\n<table border=\"1\" cellpadding=\"8\" cellspacing=\"0\" style=\"width:100%; border-collapse:collapse;\">\n<caption><strong>Comparison: tRPC vs. GraphQL vs. REST for Type Safety<\/strong><\/caption>\n<thead>\n<tr style=\"background-color:#f2f2f2;\">\n<th>Feature<\/th>\n<th>tRPC<\/th>\n<th>GraphQL<\/th>\n<th>REST + TypeScript<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>End\u2011to\u2011end type safety<\/td>\n<td>Native, zero\u2011code<\/td>\n<td>Via code generation<\/td>\n<td>Manual duplication or OpenAPI<\/td>\n<\/tr>\n<tr>\n<td>Schema definition<\/td>\n<td>TypeScript functions<\/td>\n<td>SDL language<\/td>\n<td>OpenAPI \/ TypeScript interfaces<\/td>\n<\/tr>\n<tr>\n<td>Latency overhead<\/td>\n<td>Minimal (batchable)<\/td>\n<td>Single endpoint, query overhead<\/td>\n<td>Multiple endpoints, caching simple<\/td>\n<\/tr>\n<tr>\n<td>Learning curve<\/td>\n<td>Low (if you know TypeScript)<\/td>\n<td>Medium (queries, mutations, fragments)<\/td>\n<td>Low to medium<\/td>\n<\/tr>\n<tr>\n<td>Tooling<\/td>\n<td>React Query, Zod<\/td>\n<td>Apollo, Relay, codegen<\/td>\n<td>Axios, React Query<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<table border=\"1\" cellpadding=\"8\" cellspacing=\"0\" style=\"width:100%; border-collapse:collapse; margin-top:20px;\">\n<caption><strong>tRPC Procedure Types and Their Default HTTP Mapping<\/strong><\/caption>\n<thead>\n<tr style=\"background-color:#f2f2f2;\">\n<th>Procedure Type<\/th>\n<th>HTTP Method<\/th>\n<th>Use Case<\/th>\n<th>Client Hook Example<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>.query()<\/code><\/td>\n<td>GET<\/td>\n<td>Fetch data without side effects<\/td>\n<td><code>trpc.user.getById.useQuery(input)<\/code><\/td>\n<\/tr>\n<tr>\n<td><code>.mutation()<\/code><\/td>\n<td>POST<\/td>\n<td>Create, update, or delete data<\/td>\n<td><code>trpc.user.updateName.useMutation()<\/code><\/td>\n<\/tr>\n<tr>\n<td><code>.subscription()<\/code><\/td>\n<td>WebSocket<\/td>\n<td>Real\u2011time event streams<\/td>\n<td><code>trpc.chat.onMessage.useSubscription()<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2>Frequently Asked Questions (FAQ)<\/h2>\n<h3>1. How does tRPC differ from a traditional REST API?<\/h3>\n<p>Traditional REST APIs require manual type definitions on both ends. You define endpoints, serialization rules, and often generate client SDKs to maintain type safety. tRPC removes this duplication by letting you write plain TypeScript functions on the server and import their types directly into the client. There are no manual routes, no HTTP method concerns (tRPC uses POST by default, but you can configure batch links), and no serialisation mismatch\u2014everything is type\u2011checked at compile time.<\/p>\n<h3>2. Can I use tRPC with a frontend framework other than React?<\/h3>\n<p>Yes. While tRPC provides excellent React\/Next.js integration, the core <code>@trpc\/client<\/code> is framework\u2011agnostic. You can use it with Vue, Svelte, or plain JavaScript by using the bare client (<code>import { createTRPCClient } from '@trpc\/client'<\/code>). The community also maintains adapters for Solid and React Native. The end\u2011to\u2011end type safety still applies as long as both sides are TypeScript.<\/p>\n<h3>3. How do I handle authentication with tRPC?<\/h3>\n<p>Authentication is typically handled via context. In your <code>createContext<\/code> function (e.g., inside Next.js API route), you parse cookies, JWT tokens, or session headers and attach the user info to the context. Then you create a <code>protectedProcedure<\/code> using tRPC\u2019s middleware that checks for the user. If authentication fails, throw a <code>TRPCError<\/code> with code <code>'UNAUTHORIZED'<\/code>. The client can then handle the error globally (e.g., redirect to login).<\/p>\n<h3>4. Is tRPC suitable for large\u2011scale applications with many endpoints?<\/h3>\n<p>Absolutely. tRPC\u2019s modular router system scales well. You can split routers across files and merge them. The batching link (<code>httpBatchLink<\/code>) collapses multiple requests into a single HTTP call, reducing latency. For even larger setups, you can use server\u2011less deployments (Vercel, AWS Lambda) because tRPC adapters are lightweight. However, if you need complex caching layers or public REST API consumption, you might still want a separate REST layer \u2013 tRPC excels for internal services and full\u2011stack apps.<\/p>\n<h3>5. How do I handle file uploads with tRPC?<\/h3>\n<p>tRPC does not natively support multipart form uploads because its default protocol is JSON. For file uploads, you have a few options: (a) Use a separate endpoint (e.g., a Next.js API route) to handle the file and return a URL, then pass that URL to a tRPC mutation. (b) Encode the file as base64 and send it as a string \u2014 but this is inefficient for large files. (c) Use a solution like <code>tRPC-formdata<\/code> or a custom link that serializes FormData. The recommended approach is to use a dedicated file upload endpoint (e.g., using <code>multer<\/code> or a third\u2011party service like UploadThing) and then reference the uploaded file by URL in your tRPC procedures.<\/p>\n<h2>Conclusion<\/h2>\n<p>tRPC fundamentally changes how we think about building full\u2011stack TypeScript applications. By eliminating the boundary between server and client types, it removes an entire class of bugs, speeds up development, and provides an unmatched developer experience. In this tutorial, we walked through the complete setup: from installing dependencies and defining procedures with Zod validation, to creating context, setting up the client in Next.js, adding error handling, middleware, and even real\u2011time subscriptions. We also compared tRPC with traditional approaches and answered common questions to help you avoid pitfalls. The key takeaway is that tRPC is not just another RPC framework\u2014it is the embodiment of the \u201ctype\u2011first\u201d philosophy that modern TypeScript developers have been craving. Whether you are building a small side project or a large enterprise application, adopting tRPC will make your codebase more robust, your APIs self\u2011documenting, and your team more productive. Start by migrating a single endpoint and experience the joy of automatic type safety across the wire. Your future self\u2014and your users\u2014will thank you.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>How to Use tRPC for End-to-End Type Safety: A Comprehensive Tutorial Modern web development has long struggled with the disconnect between frontend and backend type systems. Even with TypeScript on both sides, maintaining consistent types across the network boundary often requires manually duplicating interfaces, generating OpenAPI specs, or relying on code generators that add complexity &hellip; <\/p>\n","protected":false},"author":2716,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"footnotes":""},"categories":[],"tags":[],"class_list":["post-1152","post","type-post","status-publish","format-standard","hentry"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/posts\/1152","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/users\/2716"}],"replies":[{"embeddable":true,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/comments?post=1152"}],"version-history":[{"count":0,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/posts\/1152\/revisions"}],"wp:attachment":[{"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/media?parent=1152"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/categories?post=1152"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/tags?post=1152"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}