{"id":1156,"date":"2026-07-04T06:10:30","date_gmt":"2026-07-03T23:10:30","guid":{"rendered":"https:\/\/sumberlaba.com\/index.php\/2026\/07\/04\/mastering-authentication-with-clerk-a-comprehensive-step-by-step-guide\/"},"modified":"2026-07-04T06:10:30","modified_gmt":"2026-07-03T23:10:30","slug":"mastering-authentication-with-clerk-a-comprehensive-step-by-step-guide","status":"publish","type":"post","link":"https:\/\/sumberlaba.com\/index.php\/2026\/07\/04\/mastering-authentication-with-clerk-a-comprehensive-step-by-step-guide\/","title":{"rendered":"Mastering Authentication with Clerk: A Comprehensive Step-by-Step Guide"},"content":{"rendered":"<h1>Mastering Authentication with Clerk: A Comprehensive Step-by-Step Guide<\/h1>\n<p>Authentication remains one of the most critical yet tedious aspects of modern web development. While frameworks like Next.js, React, and Vue have simplified frontend development, building a secure, scalable, and user-friendly authentication system from scratch still demands a significant investment of time and expertise. This is where Clerk enters the picture. Clerk is a complete user management and authentication platform that handles everything from sign\u2011up forms and passwordless logins to session management, multi\u2011factor authentication, and social OAuth providers. Unlike traditional libraries that only provide low\u2011level APIs, Clerk offers pre\u2011built UI components, drop\u2011in integration with popular frameworks, and an administration dashboard that gives you full control over your users without ever touching a database schema for auth purposes.<\/p>\n<p>The platform is designed with developer experience in mind. You can get a fully functional authentication flow running in minutes, complete with email verification, password reset, and role\u2011based access control. Clerk also supports tenancy, allowing you to build multi\u2011tenant applications effortlessly. Whether you are building a SaaS product, a community forum, or an internal tool, Clerk abstracts away the repetitive boilerplate of auth so you can focus on your core product logic. In this tutorial, we will walk through every step required to integrate Clerk into a modern JavaScript application, from creating your Clerk account to deploying a secured app with protected routes and custom user data. By the end of this guide, you will have a deep understanding of how to leverage Clerk for both simple and complex authentication scenarios.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/via.placeholder.com\/800x600\/4a90d9\/ffffff?text=how%20to%20use%20Clerk%20for%20authentication\" alt=\"Article illustration\" style=\"display:block;margin:20px auto;max-width:100%;height:auto;border-radius:8px;\" \/><\/p>\n<h2>Why Clerk Stands Out Among Authentication Solutions<\/h2>\n<p>Before diving into the implementation, it is worth understanding the unique advantages that Clerk provides over alternatives like Firebase Authentication, Auth0, or Supabase Auth. Clerk is built from the ground up with a \u201ccomponents\u2011first\u201d philosophy, meaning that instead of manually wiring up sign\u2011in forms and handling token refreshes, you can drop a `<SignIn \/>` component into your JSX and it instantly works with your chosen framework\u2019s routing. Clerk also provides a powerful organization and team management layer, which is often missing in other solutions. For applications that require user roles, permissions, and fine\u2011grained access control, Clerk includes a built\u2011in roles system that integrates seamlessly with its session tokens. Another standout feature is the ability to use Clerk without writing any backend code; the platform handles user creation, email verification, and session storage on its own infrastructure, but still lets you sync user data to your own database via webhooks when you need it. This hybrid approach gives you the best of both worlds \u2013 fast prototyping and full flexibility for production.<\/p>\n<h2>Step 1: Setting Up Your Clerk Account and Application<\/h2>\n<p>The first step is to create a Clerk account. Visit the <a href=\"https:\/\/clerk.com\" target=\"_blank\">Clerk website<\/a> and sign up using your email, GitHub, or Google account. The free tier is generous and allows up to 5,000 monthly active users, which is sufficient for most early\u2011stage projects. Once you log in, you will be greeted by the Clerk Dashboard. Click on \u201cAdd application\u201d to create a new project. You will be asked to provide an application name (e.g., \u201cMy Saas App\u201d) and select the authentication methods you want to enable. By default, Clerk supports email\/password, magic links, and social logins (Google, GitHub, Apple, etc.). You can also enable SMS\u2011based OTP and Web3 wallets later. After creating the application, Clerk will generate two important keys: the **Publishable Key** (starts with `pk_`) and the **Secret Key** (starts with `sk_`). These keys are used to authenticate your frontend and backend requests respectively. Keep the Secret Key safe \u2013 it should never be exposed in client\u2011side code. The dashboard also provides a **Clerk instance URL** (e.g., `https:\/\/clerk.example.com`) which you will need for configuration. Take note of these values or keep the dashboard open; you will need them in the next step.<\/p>\n<h2>Step 2: Installing Clerk SDK in Your Project<\/h2>\n<p>Clerk supports a wide range of JavaScript frameworks, including React, Next.js, Remix, Gatsby, and vanilla JavaScript. In this tutorial, we will focus on Next.js 13+ with the App Router, as it is one of the most common setups. Begin by installing the Clerk Next.js package in your project directory:<\/p>\n<pre><code>npm install @clerk\/nextjs<\/code><\/pre>\n<p>or if you are using Yarn:<\/p>\n<pre><code>yarn add @clerk\/nextjs<\/code><\/pre>\n<p>For other frameworks, the package names follow a similar pattern: `@clerk\/react`, `@clerk\/remix`, `@clerk\/gatsby`, etc. The core concepts remain identical across all of them. After installation, create a `.env.local` file in your project root and add the following environment variables, replacing the placeholders with the actual values from your Clerk dashboard:<\/p>\n<pre><code>NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY=pk_xxxxxxxxxxxxxxxx\nCLERK_SECRET_KEY=sk_xxxxxxxxxxxxxxxx\n<\/code><\/pre>\n<p>The `NEXT_PUBLIC_` prefix is required for Next.js to expose the publishable key to the client side. The Secret Key is kept server\u2011side and will be used for API calls that require elevated privileges. Next, wrap your entire application with the `<ClerkProvider>` component. In Next.js App Router, you would typically do this in your root `layout.tsx` file:<\/p>\n<pre><code>import { ClerkProvider } from '@clerk\/nextjs'\n\nexport default function RootLayout({ children }) {\n  return (\n    &lt;ClerkProvider&gt;\n      &lt;html lang=\"en\"&gt;\n        &lt;body&gt;{children}&lt;\/body&gt;\n      &lt;\/html&gt;\n    &lt;\/ClerkProvider&gt;\n  )\n}\n<\/code><\/pre>\n<p>This provider handles session management, token refreshing, and makes Clerk hooks available throughout your application. If you are using a different framework, the setup is analogous: import the provider and wrap your app tree.<\/p>\n<h2>Step 3: Adding Authentication UI Components<\/h2>\n<p>One of Clerk\u2019s biggest time\u2011savers is its collection of pre\u2011built UI components. These components are fully customizable using CSS or Clerk\u2019s built\u2011in theme system. The most important ones are `<SignIn>`, `<SignUp>`, and `<UserButton>`. To add a sign\u2011in page, create a new file `app\/sign-in\/[[&#8230;sign-in]]\/page.tsx` (catch\u2011all route for Clerk\u2019s routing). Inside it, import and use the `<SignIn \/>` component:<\/p>\n<pre><code>import { SignIn } from '@clerk\/nextjs'\n\nexport default function SignInPage() {\n  return (\n    &lt;div style={{ display: 'flex', justifyContent: 'center', marginTop: 50 }}&gt;\n      &lt;SignIn \/&gt;\n    &lt;\/div&gt;\n  )\n}\n<\/code><\/pre>\n<p>Similarly, create `app\/sign-up\/[[&#8230;sign-up]]\/page.tsx` and use the `<SignUp \/>` component. That is all it takes \u2013 Clerk automatically handles form validation, error messages, password strength checks, email verification, and redirect logic. When a user signs in, they are redirected to the default post\u2011sign\u2011in URL (which you can configure in the Dashboard or via the `afterSignInUrl` prop). To display the current user\u2019s profile, add the `<UserButton \/>` component anywhere in your application, typically in a navigation bar:<\/p>\n<pre><code>import { UserButton } from '@clerk\/nextjs'\n\nexport default function Navbar() {\n  return (\n    &lt;nav&gt;\n      &lt;UserButton afterSignOutUrl=\"\/\" \/&gt;\n    &lt;\/nav&gt;\n  )\n}\n<\/code><\/pre>\n<p>The UserButton shows a dropdown with options to manage account, sign out, and switch between organizations (if using multi\u2011tenancy). If you prefer a more minimal approach, you can also use the `useUser` hook to access the current user object and build your own UI.<\/p>\n<h2>Step 4: Protecting Routes and API Endpoints<\/h2>\n<p>With authentication in place, the next logical step is to protect certain pages or API routes from unauthenticated access. Clerk provides middleware for Next.js that makes this incredibly straightforward. Create or edit a `middleware.ts` file in your project root (inside the `src` folder if using the App Router):<\/p>\n<pre><code>import { authMiddleware } from \"@clerk\/nextjs\";\n\nexport default authMiddleware({\n  publicRoutes: [\"\/\", \"\/about\", \"\/sign-in\", \"\/sign-up\"], \/\/ routes accessible without auth\n});\n\nexport const config = {\n  matcher: [\"\/((?!.*\\\\..*|_next).*)\", \"\/\", \"\/(api|trpc)(.*)\"],\n};\n<\/code><\/pre>\n<p>The `authMiddleware` function automatically checks for a valid session token on every request. If the user is not authenticated and the route is not in the `publicRoutes` array, they are redirected to the sign\u2011in page. You can also pass a custom `afterAuth` callback for more granular control (e.g., role\u2011based redirection). For API routes, you can protect them by using the `requireAuth` utility from Clerk, or simply check the `auth()` function inside your route handler. In Next.js App Router route handlers (e.g., `app\/api\/protected\/route.ts`):<\/p>\n<pre><code>import { auth } from \"@clerk\/nextjs\";\n\nexport async function GET() {\n  const { userId } = auth();\n  if (!userId) {\n    return new Response(\"Unauthorized\", { status: 401 });\n  }\n  \/\/ Process the request...\n  return new Response(JSON.stringify({ message: \"Hello from protected route\" }), { status: 200 });\n}\n<\/code><\/pre>\n<p>For non\u2011Next.js frameworks, Clerk offers similar methods like `getAuth()` (Express) or `requireAuth` (Remix). The key principle remains the same: validate the session token before granting access to protected resources. Clerk also supports server\u2011side rendering of protected content \u2013 you can use the `currentUser` function to fetch the user on the server and pass it as props to your page components.<\/p>\n<h2>Step 5: Managing User Data and Custom Fields<\/h2>\n<p>Out of the box, Clerk saves standard user information such as email, phone number, name, and profile image. However, most applications need to store additional metadata like a user\u2019s subscription tier, preferences, or shipping address. Clerk provides two levels of custom data: **public metadata** (accessible via the client\u2011side `user.publicMetadata` object) and **private metadata** (only accessible server\u2011side via the `user.privateMetadata` object). You can set these from the Clerk Dashboard under the user\u2019s profile, or programmatically using the Clerk Backend SDK. To add custom fields during sign\u2011up, you can configure the `<SignUp \/>` component to include additional attribute fields. In your Dashboard, go to \u201cUser &#038; Authentication\u201d \u2192 \u201cEmail, Phone, Username\u201d and add custom attributes. These attributes are then automatically captured in the sign\u2011up form if you enable them. For programmatic updates, use the following approach in a server\u2011side API route (using Next.js):<\/p>\n<pre><code>import { clerkClient } from \"@clerk\/nextjs\";\n\nexport async function POST(req) {\n  const { userId, tier } = await req.json();\n  await clerkClient.users.updateUser(userId, {\n    publicMetadata: { tier: tier },\n  });\n  return new Response(\"Updated\", { status: 200 });\n}\n<\/code><\/pre>\n<p>You can also retrieve user data on the client side using the `useUser` hook:<\/p>\n<pre><code>const { user } = useUser();\nconsole.log(user.publicMetadata.tier);\n<\/code><\/pre>\n<p>For more complex scenarios \u2013 like syncing Clerk users to your own PostgreSQL database \u2013 you should use Clerk\u2019s webhooks. When a user is created, updated, or deleted, Clerk sends a POST request to a webhook endpoint you define. This allows you to maintain a local copy of user data that can be indexed and queried for custom analytics or relations. Setting up a webhook is straightforward: in the Dashboard, under \u201cWebhooks\u201d, create a new endpoint pointing to your backend (e.g., `\/api\/webhooks\/clerk`), select the events you want to listen to (user.created, user.updated, etc.), and verify the signature using the `svix` library that Clerk provides. This ensures the integrity of the incoming payload.<\/p>\n<h2>Step 6: Integrating Social OAuth and Multi\u2011Factor Authentication<\/h2>\n<p>Modern users expect to be able to log in with their existing Google, GitHub, or Apple accounts. Clerk makes adding social logins trivial. In the Dashboard, navigate to \u201cUser &#038; Authentication\u201d \u2192 \u201cSocial Connections\u201d. Toggle on the providers you want to enable. For each provider, you will need to obtain OAuth credentials (Client ID and Client Secret) from that provider\u2019s developer console. Clerk provides step\u2011by\u2011step guidance for each platform. Once configured, the `<SignIn \/>` component will automatically render buttons for each enabled provider. No additional code changes are required on the frontend. Clerk also supports passwordless authentication via magic links and SMS OTP, which can be enabled similarly in the Dashboard. For applications that require higher security \u2013 such as financial or health platforms \u2013 Clerk offers multi\u2011factor authentication (MFA). You can require users to enroll a second factor (TOTP, SMS, or backup codes) before accessing sensitive routes. MFA is configured per application in the Dashboard under \u201cUser &#038; Authentication\u201d \u2192 \u201cMulti\u2011factor\u201d, and you can enforce it for specific roles or all users. The Clerk UI components handle the entire enrollment and verification flow, so you only need to set the policy.<\/p>\n<h2>Step 7: Customizing the Look and Feel<\/h2>\n<p>Although Clerk\u2019s default UI is clean and functional, you will likely want to match it to your brand\u2019s design. Clerk offers two levels of customization: theme\u2011based (via the `appearance` prop) and full custom styling (via CSS variables or your own component overrides). The simplest way is to pass an object with your brand colors, fonts, and spacing to the `<ClerkProvider>` as the `appearance` prop:<\/p>\n<pre><code>&lt;ClerkProvider appearance={{\n  baseTheme: shadesOfPurple,\n  variables: {\n    colorPrimary: '#6C63FF',\n    colorText: '#333',\n    borderRadius: '8px',\n  },\n}}&gt;\n<\/code><\/pre>\n<p>Clerk includes several base themes (like `dark`, `shadesOfPurple`, `neobrutal`) that you can import from `@clerk\/themes`. You can also override individual components using the `elements` object, which maps to CSS class names. For complete control, you can build your own sign\u2011in\/sign\u2011up forms using Clerk\u2019s low\u2011level hooks (`useSignIn`, `useSignUp`) and underlying API. However, the component approach is recommended for 95% of use cases because it handles edge cases like error states, loading spinners, and accessibility automatically.<\/p>\n<h2>Best Practices and Tips for Production Use<\/h2>\n<h3>Tip 1: Use Middleware for Consistent Route Protection<\/h3>\n<p>Instead of adding `auth()` checks to every page or API handler individually, rely on Clerk\u2019s middleware to intercept requests at the edge. This centralizes your authentication logic and reduces the chance of accidentally leaving a route unprotected. For Next.js, the `authMiddleware` can also be configured to set custom headers or redirect based on user metadata. For other frameworks, look for a similar \u201cmiddleware\u201d or \u201cguard\u201d pattern. Remember that middleware runs on every request, so be mindful of performance \u2013 Clerk\u2019s middleware is highly optimized and only makes a lightweight token verification call, but you should still whitelist static assets and public pages.<\/p>\n<h3>Tip 2: Handle Loading and Error States Gracefully<\/h3>\n<p>Clerk components handle most loading states internally, but when you use hooks like `useUser` or `useAuth`, the initial value may be `undefined` while the session is being resolved. Always check for `isLoaded` before rendering conditional content. For example:<\/p>\n<pre><code>const { isLoaded, isSignedIn, user } = useUser();\nif (!isLoaded) return &lt;LoadingSpinner \/&gt;;\nif (!isSignedIn) return &lt;SignInButton \/&gt;;\nreturn &lt;p&gt;Welcome, {user.firstName}!&lt;\/p&gt;;<\/code><\/pre>\n<p>Similarly, handle errors from Clerk\u2019s API calls (e.g., when updating metadata) by wrapping them in try\u2011catch blocks and showing appropriate user\u2011friendly messages. Clerk throws typed errors like `ClerkAPIResponseError` that you can inspect for specific status codes.<\/p>\n<h3>Tip 3: Leverage Organizations for Multi\u2011Tenant Applications<\/h3>\n<p>If you are building a platform where users belong to different workspaces or teams (like Slack or Notion), Clerk\u2019s Organizations feature is a game\u2011changer. You can create organizations, assign members with roles (admin, member, etc.), and use the `<OrganizationSwitcher>` component to let users switch contexts. The organization ID is included in the session token, so you can enforce access control at the database level. Enable organizations in the Dashboard under \u201cOrganizations\u201d, then invite users or let them create their own organizations. The `useOrganization` and `useOrganizationList` hooks give you full programmatic control for custom UI.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>Q1: Can I use Clerk with my existing user database?<\/h3>\n<p>Yes, you can. Clerk is designed to be the source of truth for authentication, but you can synchronize user data to your own database using webhooks. When a user is created, updated, or deleted, Clerk sends a payload to your webhook endpoint. You can then store the user\u2019s Clerk ID in your database and link it to your own tables. For details, refer to Clerk\u2019s webhook documentation. Additionally, you can import existing users into Clerk via its Admin API, though this requires mapping passwords or using a migration wizard.<\/p>\n<h3>Q2: Is Clerk free to use for a small project?<\/h3>\n<p>Absolutely. Clerk offers a generous free plan that includes up to 5,000 monthly active users, unlimited social connections, and standard features like email\/password auth and magic links. The free plan is fully functional for production use, with no hidden limitations on sessions or API calls. For larger projects, paid tiers start at around $25\/month and include higher user limits, advanced role\u2011based access control, and audit logs.<\/p>\n<h3>Q3: How does Clerk handle OAuth token refresh and expiration?<\/h3>\n<p>Clerk manages OAuth tokens automatically for you. When a user signs in via a social provider (Google, GitHub, etc.), Clerk obtains a refresh token (if the provider supports it) and automatically refreshes the access token in the background. You never need to manually handle token expiration. On the frontend, Clerk\u2019s SDK ensures that every request to your backend includes a valid session token (JWT). If the token is near expiry, the SDK refreshes it transparently. For server\u2011side operations, you can use the `auth()` function to get a fresh token.<\/p>\n<h3>Q4: Can I embed Clerk\u2019s sign\u2011in modal directly in my app without navigating to a separate page?<\/h3>\n<p>Yes. Clerk provides a `<SignInButton \/>` component that can trigger a modal (or a drop\u2011in) sign\u2011in experience. You can also use the `useSignIn` hook to open a modal programmatically. This is particularly useful for applications where you want to keep the user on the same page, such as a single\u2011page app or a dashboard. Configure the modal behavior via the `<SignIn>` or `<SignUp>` component\u2019s `routing` prop (set to `modal` instead of `path`).<\/p>\n<h3>Q5: What happens if Clerk\u2019s server goes down? Will my app break?<\/h3>\n<p>Clerk is designed with high availability and redundancy across multiple cloud providers. However, in the unlikely event of an outage, your application\u2019s existing sessions remain valid until their token expires (usually 15 minutes to 1 hour, configurable). New sign\u2011ins will fail until Clerk recovers. To mitigate this, you can implement a fallback authentication mechanism using a cached JWT verification key, but for most applications, Clerk\u2019s typical uptime SLA (99.95%) is sufficient. You can monitor status at <a href=\"https:\/\/status.clerk.com\" target=\"_blank\">status.clerk.com<\/a>.<\/p>\n<h2>Comparing Clerk\u2019s Plans and Key Methods<\/h2>\n<table border=\"1\" cellpadding=\"8\" cellspacing=\"0\" style=\"border-collapse: collapse; width: 100%;\">\n<thead>\n<tr>\n<th>Feature<\/th>\n<th>Free Plan<\/th>\n<th>Pro Plan ($25\/mo)<\/th>\n<th>Enterprise (Custom)<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Monthly Active Users<\/td>\n<td>5,000<\/td>\n<td>20,000<\/td>\n<td>Unlimited<\/td>\n<\/tr>\n<tr>\n<td>Social Connections<\/td>\n<td>Unlimited<\/td>\n<td>Unlimited<\/td>\n<td>Unlimited<\/td>\n<\/tr>\n<tr>\n<td>Multi\u2011Factor Auth<\/td>\n<td>Limited (TOTP only)<\/td>\n<td>Full (SMS, backup codes)<\/td>\n<td>Full + custom policies<\/td>\n<\/tr>\n<tr>\n<td>Organizations<\/td>\n<td>Up to 5 orgs<\/td>\n<td>Unlimited<\/td>\n<td>Unlimited<\/td>\n<\/tr>\n<tr>\n<td>Audit Logs<\/td>\n<td>7 days<\/td>\n<td>30 days<\/td>\n<td>Custom retention<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<table border=\"1\" cellpadding=\"8\" cellspacing=\"0\" style=\"border-collapse: collapse; width: 100%; margin-top: 20px;\">\n<thead>\n<tr>\n<th>Clerk Function<\/th>\n<th>Description<\/th>\n<th>Where to Use<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>useUser()<\/code><\/td>\n<td>Returns the authenticated user object<\/td>\n<td>Client\u2011side components<\/td>\n<\/tr>\n<tr>\n<td><code>useAuth()<\/code><\/td>\n<td>Returns session claims and authentication status<\/td>\n<td>Client\u2011side and server\u2011side (via `auth()`)<\/td>\n<\/tr>\n<tr>\n<td><code>authMiddleware()<\/code><\/td>\n<td>Protects routes at the edge (Next.js)<\/td>\n<td>middleware.ts<\/td>\n<\/tr>\n<tr>\n<td><code>clerkClient.users.updateUser()<\/code><\/td>\n<td>Updates user metadata programmatically<\/td>\n<td>Server\u2011side API routes<\/td>\n<\/tr>\n<tr>\n<td><code>currentUser()<\/code><\/td>\n<td>Fetches the full user object on the server (Next.js)<\/td>\n<td>getServerSideProps or server components<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2>Conclusion<\/h2>\n<p>Integrating Clerk into your application removes the burdens of building authentication from scratch \u2013 no more hashing passwords, crafting session tokens, or managing email verification flows. As we have seen in this guide, Clerk provides a complete ecosystem that scales from a simple sign\u2011in page to a multi\u2011tenant SaaS platform with role\u2011based access control and custom user metadata. By following the seven steps outlined above \u2013 setting up your project, protecting routes, managing user data, enabling OAuth, and customizing the UI \u2013 you can have a production\u2011ready authentication system in less than an hour. Clerk\u2019s generous free tier, extensive documentation, and responsive SDKs make it an excellent choice for both hobby projects and enterprise applications. Now that you have a solid foundation, explore the Clerk Dashboard to fine\u2011tune your security policies, set up webhooks, and monitor user activity. Happy coding!<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Mastering Authentication with Clerk: A Comprehensive Step-by-Step Guide Authentication remains one of the most critical yet tedious aspects of modern web development. While frameworks like Next.js, React, and Vue have simplified frontend development, building a secure, scalable, and user-friendly authentication system from scratch still demands a significant investment of time and expertise. This is where &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-1156","post","type-post","status-publish","format-standard","hentry"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/posts\/1156","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=1156"}],"version-history":[{"count":0,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/posts\/1156\/revisions"}],"wp:attachment":[{"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/media?parent=1156"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/categories?post=1156"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/tags?post=1156"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}