> ## Documentation Index
> Fetch the complete documentation index at: https://better-auth-razorpay.amankushwaha.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# useSubscriptionStatus

> Derive UI-friendly boolean flags from a subscription object with the useSubscriptionStatus helper.

`useSubscriptionStatus` is a pure helper hook that converts a raw subscription object into a set of boolean flags. Use it to render status badges, gate features, and decide which actions to show without hardcoding status string comparisons across your components.

## Fields

Pass a subscription object (or `null`/`undefined`) returned from [useSubscription](https://better-auth-razorpay.amankushwaha.dev/react/subscription-hooks.md) or [useSubscriptionList](https://better-auth-razorpay.amankushwaha.dev/react/subscription-hooks.md). Every field returns `false` when the subscription is missing.

| Field | Meaning |
| - | - |
| `isActive` | The subscription status is `"active"`. |
| `isAuthenticated` | The subscription status is `"authenticated"`. |
| `isPaused` | The subscription status is `"paused"`. |
| `isCancelled` | The subscription status is `"cancelled"`. |
| `isCompleted` | The subscription status is `"completed"`. |
| `isExpired` | The subscription status is `"expired"`. |
| `isHalted` | The subscription status is `"halted"`. |
| `isPending` | The subscription status is `"pending"`. |
| `isTrialing` | The subscription status is `"authenticated"` and `trialStart` is set while `trialEnd` is still `null`. |
| `isUsable` | The subscription is typically usable, meaning it is either `active` or currently `trialing`/`authenticated`. |
| `isTerminal` | The subscription has reached a terminal state: `cancelled`, `completed`, or `expired`. |
| `hasPaymentIssue` | The subscription is in a problematic state such as `halted` or `pending`. |
| `canRestore` | The subscription has `cancelAtCycleEnd` set to `true`, meaning it is pending cancellation and can be restored. |

## Example: status badges

Render a colored badge based on the subscription state.

```tsx components/subscription-badge.tsx theme={null}
"use client";

import { useSubscriptionStatus } from "@amank-root/better-auth-razorpay/react";

export function SubscriptionBadge({ subscription }: { subscription?: any }) {
  const status = useSubscriptionStatus(subscription);

  let label = "No subscription";
  let color = "#6b7280";

  if (status.isTrialing) {
    label = "In trial";
    color = "#16a34a";
  } else if (status.isActive) {
    label = "Active";
    color = "#16a34a";
  } else if (status.isPaused) {
    label = "Paused";
    color = "#ca8a04";
  } else if (status.hasPaymentIssue) {
    label = "Payment issue";
    color = "#dc2626";
  } else if (status.isCancelled) {
    label = "Cancelled";
    color = "#6b7280";
  } else if (status.isExpired) {
    label = "Expired";
    color = "#6b7280";
  }

  return (
    <span
      style={{
        display: "inline-block",
        padding: "4px 10px",
        borderRadius: 999,
        fontSize: 12,
        fontWeight: 600,
        color: "#fff",
        background: color,
      }}
    >
      {label}
    </span>
  );
}
```

## Example: gating UI

Conditionally render parts of your app depending on whether the user has an active or usable subscription.

```tsx components/feature-gate.tsx theme={null}
"use client";

import { useSubscriptionList, useSubscriptionStatus } from "@amank-root/better-auth-razorpay/react";
import { authClient } from "@/lib/auth-client";

export function ProFeature({ children }: { children: React.ReactNode }) {
  const { data: subscriptions } = useSubscriptionList(authClient);
  const activeSub = subscriptions?.[0];
  const status = useSubscriptionStatus(activeSub);

  if (!status.isUsable) {
    return (
      <div style={{ padding: 24, border: "1px dashed rgba(127,127,127,.4)", borderRadius: 12 }}>
        <p>This feature requires an active subscription.</p>
        <a href="/billing">Upgrade now</a>
      </div>
    );
  }

  return <>{children}</>;
}
```

## Example: action buttons

Use `canRestore`, `isPaused`, and `isActive` to decide which buttons to display.

```tsx components/subscription-actions.tsx theme={null}
"use client";

import {
  useSubscriptionList,
  useSubscriptionStatus,
  useCancelSubscription,
  useResumeSubscription,
  useRestoreSubscription,
} from "@amank-root/better-auth-razorpay/react";
import { authClient } from "@/lib/auth-client";

export function SubscriptionActions() {
  const { data: subscriptions } = useSubscriptionList(authClient);
  const sub = subscriptions?.[0];
  const status = useSubscriptionStatus(sub);

  const cancel = useCancelSubscription(authClient);
  const resume = useResumeSubscription(authClient);
  const restore = useRestoreSubscription(authClient);

  return (
    <div style={{ display: "flex", gap: 8 }}>
      {status.isActive && !status.isPaused && (
        <button
          onClick={() => cancel.mutate({ cancelAtCycleEnd: true })}
          disabled={cancel.isPending}
        >
          {cancel.isPending ? "Cancelling..." : "Cancel at cycle end"}
        </button>
      )}

      {status.canRestore && (
        <button
          onClick={() => restore.mutate({})}
          disabled={restore.isPending}
        >
          {restore.isPending ? "Restoring..." : "Restore"}
        </button>
      )}

      {status.isPaused && (
        <button
          onClick={() => resume.mutate({})}
          disabled={resume.isPending}
        >
          {resume.isPending ? "Resuming..." : "Resume"}
        </button>
      )}
    </div>
  );
}
```

> [!NOTE]
>
> `useSubscriptionStatus` does not perform any network requests. It is a synchronous helper that derives flags from the subscription object you pass in. You can also use it outside of React by replicating the same logic if needed.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.