Polar.sh Creator Monetization

# Polar.sh Creator Monetization for Google Antigravity

Monetize your open source projects and developer tools with Polar.sh in your Google Antigravity IDE projects. This comprehensive guide covers sponsorships, subscriptions, digital products, and API integration optimized for Gemini 3 agentic development.

## Polar.sh Configuration

Set up Polar.sh SDK with proper TypeScript configuration:

```typescript
// lib/polar.ts
import { Polar } from '@polar-sh/sdk';

if (!process.env.POLAR_ACCESS_TOKEN) {
  throw new Error('POLAR_ACCESS_TOKEN is not defined');
}

export const polar = new Polar({
  accessToken: process.env.POLAR_ACCESS_TOKEN,
});

export const ORGANIZATION_ID = process.env.POLAR_ORGANIZATION_ID!;

// Subscription tier configuration
export const SUBSCRIPTION_TIERS = {
  supporter: {
    name: 'Supporter',
    priceMonthly: 500, // $5.00
    priceYearly: 5000, // $50.00 (2 months free)
    benefits: [
      'Access to supporter Discord channel',
      'Name in project README',
      'Early access to new features',
    ],
  },
  professional: {
    name: 'Professional',
    priceMonthly: 2000, // $20.00
    priceYearly: 20000, // $200.00
    benefits: [
      'All Supporter benefits',
      'Priority support',
      'Access to premium prompts',
      '1-on-1 monthly call',
    ],
  },
  enterprise: {
    name: 'Enterprise',
    priceMonthly: 10000, // $100.00
    priceYearly: 100000, // $1000.00
    benefits: [
      'All Professional benefits',
      'Custom integrations',
      'Dedicated support channel',
      'SLA guarantees',
    ],
  },
} as const;

export type SubscriptionTier = keyof typeof SUBSCRIPTION_TIERS;
```

## Subscription Management

Handle subscription checkout and management:

```typescript
// app/api/subscriptions/checkout/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { polar, ORGANIZATION_ID, SUBSCRIPTION_TIERS, SubscriptionTier } from '@/lib/polar';
import { getServerSession } from 'next-auth';
import { authOptions } from '@/lib/auth';

export async function POST(request: NextRequest) {
  try {
    const session = await getServerSession(authOptions);
    if (!session?.user?.email) {
      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
    }

    const { tier, interval } = await request.json() as {
      tier: SubscriptionTier;
      interval: 'month' | 'year';
    };

    const tierConfig = SUBSCRIPTION_TIERS[tier];
    if (!tierConfig) {
      return NextResponse.json({ error: 'Invalid tier' }, { status: 400 });
    }

    const price = interval === 'year' 
      ? tierConfig.priceYearly 
      : tierConfig.priceMonthly;

    // Create checkout session
    const checkout = await polar.checkouts.create({
      productPriceId: `price_${tier}_${interval}`,
      successUrl: `${process.env.NEXT_PUBLIC_APP_URL}/dashboard?subscription=success`,
      customerEmail: session.user.email,
      metadata: {
        userId: session.user.id,
        tier,
        interval,
      },
    });

    return NextResponse.json({ checkoutUrl: checkout.url });
  } catch (error) {
    console.error('Checkout creation failed:', error);
    return NextResponse.json(
      { error: 'Failed to create checkout' },
      { status: 500 }
    );
  }
}
```

## Webhook Handler

Process Polar.sh webhooks for subscription events:

```typescript
// app/api/webhooks/polar/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { Webhooks } from '@polar-sh/sdk/webhooks';
import { db } from '@/lib/db';

const webhooks = new Webhooks({
  webhookSecret: process.env.POLAR_WEBHOOK_SECRET!,
});

export async function POST(request: NextRequest) {
  const payload = await request.text();
  const signature = request.headers.get('polar-signature')!;

  let event;
  try {
    event = webhooks.verify(payload, signature);
  } catch (error) {
    console.error('Webhook verification failed:', error);
    return NextResponse.json({ error: 'Invalid signature' }, { status: 400 });
  }

  try {
    switch (event.type) {
      case 'subscription.created': {
        const subscription = event.data;
        await handleSubscriptionCreated(subscription);
        break;
      }
      case 'subscription.updated': {
        const subscription = event.data;
        await handleSubscriptionUpdated(subscription);
        break;
      }
      case 'subscription.canceled': {
        const subscription = event.data;
        await handleSubscriptionCanceled(subscription);
        break;
      }
      case 'order.created': {
        const order = event.data;
        await handleOrderCreated(order);
        break;
      }
    }

    return NextResponse.json({ received: true });
  } catch (error) {
    console.error('Webhook handler error:', error);
    return NextResponse.json({ error: 'Handler failed' }, { status: 500 });
  }
}

async function handleSubscriptionCreated(subscription: any) {
  const userId = subscription.metadata?.userId;
  if (!userId) return;

  await db.user.update({
    where: { id: userId },
    data: {
      polarSubscriptionId: subscription.id,
      subscriptionTier: subscription.metadata?.tier,
      subscriptionStatus: 'active',
      subscriptionCurrentPeriodEnd: new Date(subscription.currentPeriodEnd),
    },
  });

  // Send welcome email
  await emailService.sendSubscriptionWelcome(
    subscription.customer.email,
    subscription.metadata?.tier
  );
}

async function handleSubscriptionCanceled(subscription: any) {
  const userId = subscription.metadata?.userId;
  if (!userId) return;

  await db.user.update({
    where: { id: userId },
    data: {
      subscriptionStatus: 'canceled',
      subscriptionEndsAt: new Date(subscription.currentPeriodEnd),
    },
  });
}
```

## Digital Products Store

Sell digital products like premium prompts:

```typescript
// lib/products.ts
import { polar, ORGANIZATION_ID } from './polar';

export async function listProducts() {
  const products = await polar.products.list({
    organizationId: ORGANIZATION_ID,
    isArchived: false,
  });

  return products.items.map((product) => ({
    id: product.id,
    name: product.name,
    description: product.description,
    price: product.prices[0]?.priceAmount || 0,
    type: product.type,
    benefits: product.benefits,
  }));
}

export async function createProductCheckout(
  productId: string,
  userEmail: string,
  userId: string
) {
  const checkout = await polar.checkouts.create({
    productId,
    customerEmail: userEmail,
    successUrl: `${process.env.NEXT_PUBLIC_APP_URL}/purchases?success=true`,
    metadata: { userId },
  });

  return checkout;
}

// app/products/page.tsx
import { listProducts } from '@/lib/products';
import { ProductCard } from '@/components/ProductCard';

export default async function ProductsPage() {
  const products = await listProducts();

  return (
    <div className="products-page">
      <h1>Premium Resources</h1>
      <p>Exclusive prompts and workflows for professional developers</p>
      
      <div className="products-grid">
        {products.map((product) => (
          <ProductCard key={product.id} product={product} />
        ))}
      </div>
    </div>
  );
}
```

## Subscriber Benefits Access

Control access to premium content:

```typescript
// lib/access-control.ts
import { db } from './db';
import { cache } from 'react';

export const checkSubscriptionAccess = cache(async (userId: string) => {
  const user = await db.user.findUnique({
    where: { id: userId },
    select: {
      subscriptionTier: true,
      subscriptionStatus: true,
      subscriptionCurrentPeriodEnd: true,
    },
  });

  if (!user) return { hasAccess: false, tier: null };

  const isActive = 
    user.subscriptionStatus === 'active' &&
    user.subscriptionCurrentPeriodEnd &&
    new Date(user.subscriptionCurrentPeriodEnd) > new Date();

  return {
    hasAccess: isActive,
    tier: isActive ? user.subscriptionTier : null,
  };
});

// Higher-order component for protected content
export function withSubscription<T extends { userId: string }>(
  Component: React.ComponentType<T & { subscription: SubscriptionAccess }>,
  requiredTier?: SubscriptionTier
) {
  return async function ProtectedComponent(props: T) {
    const subscription = await checkSubscriptionAccess(props.userId);
    
    if (!subscription.hasAccess) {
      return <UpgradePrompt />;
    }
    
    if (requiredTier && !hasRequiredTier(subscription.tier, requiredTier)) {
      return <TierUpgradePrompt currentTier={subscription.tier} requiredTier={requiredTier} />;
    }

    return <Component {...props} subscription={subscription} />;
  };
}
```

## Best Practices

1. **Verify webhook signatures** to prevent spoofed events
2. **Store subscription state** in your database for offline access checks
3. **Implement grace periods** for subscription renewals
4. **Cache access checks** to reduce database queries
5. **Send confirmation emails** for all subscription changes
6. **Track analytics** on conversion funnels
7. **Offer annual discounts** to improve retention