> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dodopayments.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Hono Adaptor

> Lär dig hur du integrerar Dodo Payments med ditt Hono App Router-projekt med hjälp av vår NextJS Adaptor. Täcker checkout, kundportal, webhooks och säker miljöinställning.

<CardGroup cols={2}>
  <Card title="Checkout Handler" icon="cart-shopping" href="#checkout-route-handler">
    Integrera Dodo Payments kassa i din Hono-app.
  </Card>

  <Card title="Customer Portal" icon="user" href="#customer-portal-route-handler">
    Låt kunder hantera abonnemang och uppgifter.
  </Card>

  <Card title="Webhooks" icon="bell" href="#webhook-route-handler">
    Ta emot och behandla Dodo Payments webhook-händelser.
  </Card>
</CardGroup>

## Installation

<Steps>
  <Step title="Install the package">
    Kör följande kommando i projektets rotmapp:

    ```bash theme={null}
    npm install @dodopayments/hono
    ```
  </Step>

  <Step title="Set up environment variables">
    Skapa en <code>.env</code>-fil i projektets rotmapp:

    ```env expandable theme={null}
    DODO_PAYMENTS_API_KEY=your-api-key
    DODO_PAYMENTS_RETURN_URL=https://yourapp.com/success
    DODO_PAYMENTS_WEBHOOK_KEY=your-webhook-secret
    DODO_PAYMENTS_ENVIRONMENT="test_mode" or "live_mode""
    ```

    <Warning>
      Lägg aldrig upp din <code>.env</code>-fil eller hemligheter i versionshanteringen.
    </Warning>
  </Step>
</Steps>

## Exempel på Route Handlers

<Info>
  Alla exempel förutsätter att du använder Hono App Router.
</Info>

<Tabs>
  <Tab title="Checkout Handler">
    <Info>
      Använd denna hanterare för att integrera Dodo Payments kassa i din Hono-app. Stöder statiska (GET), dynamiska (POST) och sessionsflöden (POST).
    </Info>

    <CodeGroup>
      ```typescript Hono Route Handler expandable theme={null}
        // route.ts
        import { Checkout } from '@dodopayments/hono';
        import Hono from 'hono'

        const app = new Hono()

        app.get(
        "/api/checkout",
        Checkout({
            bearerToken: process.env.DODO_PAYMENTS_API_KEY,
            environment: process.env.DODO_PAYMENTS_ENVIRONMENT,
            returnUrl: process.env.DODO_PAYMENTS_RETURN_URL,
            type: 'static'
        })
        );

        app.post(
        "/api/checkout",
        Checkout({
            bearerToken: process.env.DODO_PAYMENTS_API_KEY,
            environment: process.env.DODO_PAYMENTS_ENVIRONMENT,
            returnUrl: process.env.DODO_PAYMENTS_RETURN_URL,
            type: 'dynamic'
        })
        );
        
        app.post(
        "/api/checkout",
        Checkout({
            bearerToken: process.env.DODO_PAYMENTS_API_KEY,
            environment: process.env.DODO_PAYMENTS_ENVIRONMENT,
            returnUrl: process.env.DODO_PAYMENTS_RETURN_URL,
            type: 'session'
        })
        );
      ```
    </CodeGroup>

    <CodeGroup>
      ```curl Static Checkout Curl example expandable theme={null}
      curl --request GET \
      --url 'https://example.com/api/checkout?productId=pdt_fqJhl7pxKWiLhwQR042rh' \
      --header 'User-Agent: insomnia/11.2.0' \
      --cookie mode=test
      ```
    </CodeGroup>

    <CodeGroup>
      ```curl Dynamic Checkout Curl example expandable theme={null}
      curl --request POST \
      --url https://example.com/api/checkout \
      --header 'Content-Type: application/json' \
      --header 'User-Agent: insomnia/11.2.0' \
      --cookie mode=test \
      --data '{
      "billing": {
        "city": "Texas",
        "country": "US",
        "state": "Texas",
        "street": "56, hhh",
        "zipcode": "560000"
      },
      "customer": {
        "email": "test@example.com",
        	"name": "test"
      },
      "metadata": {},
      "payment_link": true,
        "product_id": "pdt_QMDuvLkbVzCRWRQjLNcs",
        "quantity": 1,
        "billing_currency": "USD",
        "discount_codes": ["IKHZ23M9GQ"],
        "return_url": "https://example.com",
        "trial_period_days": 10
      }'
      ```
    </CodeGroup>

    <CodeGroup>
      ```curl Checkout Session Curl example expandable theme={null}
      curl --request POST \
      --url https://example.com/api/checkout \
      --header 'Content-Type: application/json' \
      --header 'User-Agent: insomnia/11.2.0' \
      --cookie mode=test \
      --data '{
      "product_cart": [
        {
          "product_id": "pdt_QMDuvLkbVzCRWRQjLNcs",
          "quantity": 1
        }
      ],
      "customer": {
        "email": "test@example.com",
        "name": "test"
      },
      "return_url": "https://example.com/success"
      }'
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Customer Portal Handler">
    <Info>
      Använd denna hanterare för att låta kunder hantera sina abonnemang och uppgifter via Dodo Payments kundportal.
    </Info>

    <CodeGroup>
      ```typescript Hono Route Handler expandable theme={null}
      // route.ts
      import { Checkout } from '@dodopayments/hono';
      import Hono from 'hono'

      const app = new Hono()
      app.get(
          "/api/customer-portal",
          CustomerPortal({
              bearerToken: process.env.DODO_PAYMENTS_API_KEY,
              environment: process.env.DODO_PAYMENTS_ENVIRONMENT
          })
      );
      ```
    </CodeGroup>

    <CodeGroup>
      ```curl Customer Portal Curl example expandable theme={null}
      curl --request GET \
      --url 'https://example.com/api/customer-portal?customer_id=cus_9VuW4K7O3GHwasENg31m&send_email=true' \
      --header 'User-Agent: insomnia/11.2.0' \
      --cookie mode=test
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Webhook Handler">
    <Info>
      Använd denna hanterare för att säkert ta emot och behandla Dodo Payments webhook-händelser i din Hono-app.
    </Info>

    <CodeGroup>
      ```typescript Hono Route Handler expandable theme={null}
      // route.ts
      import Hono from 'hono'
      import { Webhooks } from '@dodopayments/hono'

      const app = new Hono()
      app.post(
      "/api/webhooks",
          Webhooks({
              webhookKey: process.env.DODO_PAYMENTS_WEBHOOK_KEY,
              onPayload: async (payload) => {
              // Handle Payload Here
              console.log(payload)
              }
          })
      );

      ```
    </CodeGroup>
  </Tab>
</Tabs>

## Checkout Route Handler

<Info>
  Dodo Payments stöder tre typer av betalningsflöden för att integrera betalningar på din webbplats; denna anpassning stöder alla typer av betalningsflöden.
</Info>

* **Statiska betalningslänkar:** Omedelbart delbara URL:er för snabb, kodfri insamling av betalningar.
* **Dynamiska betalningslänkar:** Programmatisk generering av betalningslänkar med anpassade detaljer med hjälp av API eller SDK:er.
* **Checkout-sessioner:** Skapa säkra, anpassningsbara checkout-upplevelser med förkonfigurerade produktvagnar och kunddetaljer.

<AccordionGroup>
  <Accordion title="Static Checkout (GET)">
    ### Stödda frågeparametrar

    <ParamField query="productId" type="string" required>
      Produktidentifierare (t.ex. <code>?productId=pdt\_nZuwz45WAs64n3l07zpQR</code>).
    </ParamField>

    <ParamField query="quantity" type="integer">
      Produktens kvantitet.
    </ParamField>

    <ParamField query="fullName" type="string">
      Kundens fullständiga namn.
    </ParamField>

    <ParamField query="firstName" type="string">
      Kundens förnamn.
    </ParamField>

    <ParamField query="lastName" type="string">
      Kundens efternamn.
    </ParamField>

    <ParamField query="email" type="string">
      Kundens e-postadress.
    </ParamField>

    <ParamField query="country" type="string">
      Kundens land.
    </ParamField>

    <ParamField query="addressLine" type="string">
      Kundens adressrad.
    </ParamField>

    <ParamField query="city" type="string">
      Kundens stad.
    </ParamField>

    <ParamField query="state" type="string">
      Kundens delstat/provins.
    </ParamField>

    <ParamField query="zipCode" type="string">
      Kundens postnummer.
    </ParamField>

    <ParamField query="disableFullName" type="boolean">
      Inaktivera fältet för fullständigt namn.
    </ParamField>

    <ParamField query="disableFirstName" type="boolean">
      Inaktivera förnamnsfältet.
    </ParamField>

    <ParamField query="disableLastName" type="boolean">
      Inaktivera efternamnsfältet.
    </ParamField>

    <ParamField query="disableEmail" type="boolean">
      Inaktivera e-postfältet.
    </ParamField>

    <ParamField query="disableCountry" type="boolean">
      Inaktivera landfältet.
    </ParamField>

    <ParamField query="disableAddressLine" type="boolean">
      Inaktivera adressradsfältet.
    </ParamField>

    <ParamField query="disableCity" type="boolean">
      Inaktivera stadsfältet.
    </ParamField>

    <ParamField query="disableState" type="boolean">
      Inaktivera delstatsfältet.
    </ParamField>

    <ParamField query="disableZipCode" type="boolean">
      Inaktivera postnummerfältet.
    </ParamField>

    <ParamField query="paymentCurrency" type="string">
      Ange betalningsvalutan (t.ex. <code>USD</code>).
    </ParamField>

    <ParamField query="showCurrencySelector" type="boolean">
      Visa valutaväljaren.
    </ParamField>

    <ParamField query="paymentAmount" type="integer">
      Ange betalningsbeloppet (t.ex. <code>1000</code> för \$10.00).
    </ParamField>

    <ParamField query="showDiscounts" type="boolean">
      Visa rabattfält.
    </ParamField>

    <ParamField query="metadata_*" type="string">
      Alla frågeparametrar som börjar med <code>metadata\_</code> skickas vidare som metadata.
    </ParamField>

    <Warning>
      Om <code>productId</code> saknas returnerar hanteraren ett 400-svar. Ogiltiga frågeparametrar resulterar också i ett 400-svar.
    </Warning>

    ### Svarsformat

    Statisk checkout returnerar ett JSON-svar med checkout-URL:en:

    ```json theme={null}
    {
      "checkout_url": "https://checkout.dodopayments.com/..."
    }
    ```
  </Accordion>

  <Accordion title="Dynamic Checkout (POST)">
    * Skicka parametrar som en JSON-body i en POST-förfrågan.
    * Stöder både engångs- och återkommande betalningar.
    * För en komplett lista över stödda POST-body-fält, se:
      * [Request body for a One Time Payment Product](https://docs.dodopayments.com/api-reference/payments/post-payments)
      * [Request body for a Subscription Product](https://docs.dodopayments.com/api-reference/subscriptions/post-subscriptions)

    ### Svarsformat

    Dynamisk checkout returnerar ett JSON-svar med checkout-URL:en:

    ```json theme={null}
    {
      "checkout_url": "https://checkout.dodopayments.com/..."
    }
    ```
  </Accordion>

  <Accordion title="Checkout Sessions (POST)">
    Checkout-sessioner erbjuder en säkrare, värdd kassa som hanterar hela betalningsflödet för både engångsköp och abonnemang med fullt anpassningskontroll.

    Se [Checkout Sessions Integration Guide](https://docs.dodopayments.com/developer-resources/checkout-session) för mer information och en komplett lista över stödda fält.

    ### Svarsformat

    Checkout-sessioner returnerar ett JSON-svar med checkout-URL:en:

    ```json theme={null}
    {
      "checkout_url": "https://checkout.dodopayments.com/session/..."
    }
    ```
  </Accordion>
</AccordionGroup>

## Customer Portal Route Handler

Customer Portal Route Handler gör det möjligt för dig att sömlöst integrera Dodo Payments kundportal i din Hono-applikation.

### Frågeparametrar

<ParamField query="customer_id" type="string" required>
  Kundens ID för portalsessionen (t.ex. <code>?customer\_id=cus\_123</code>).
</ParamField>

<ParamField query="send_email" type="boolean">
  Om det anges till <code>true</code> skickas ett e-postmeddelande till kunden med portallänken.
</ParamField>

<Warning>
  Returnerar 400 om <code>customer\_id</code> saknas.
</Warning>

## Webhook Route Handler

* **Metod:** Endast POST-förfrågningar stöds. Andra metoder returnerar 405.
* **Signaturverifiering:** Verifierar webhook-signaturen med hjälp av <code>webhookKey</code>. Returnerar 401 om verifieringen misslyckas.
* **Payload-validering:** Valideras med Zod. Returnerar 400 för ogiltiga payloads.
* **Felhantering:**
  * 401: Ogiltig signatur
  * 400: Ogiltig payload
  * 500: Intern fel under verifiering
* **Händelse-routing:** Anropar den lämpliga händelsehanteraren baserat på payload-typen.

### Stödda webhook-händelsehanterare

<CodeGroup>
  ```typescript Typescript expandable theme={null}
  onPayload?: (payload: WebhookPayload) => Promise<void>;
  onPaymentSucceeded?: (payload: WebhookPayload) => Promise<void>;
  onPaymentFailed?: (payload: WebhookPayload) => Promise<void>;
  onPaymentProcessing?: (payload: WebhookPayload) => Promise<void>;
  onPaymentCancelled?: (payload: WebhookPayload) => Promise<void>;
  onRefundSucceeded?: (payload: WebhookPayload) => Promise<void>;
  onRefundFailed?: (payload: WebhookPayload) => Promise<void>;
  onDisputeOpened?: (payload: WebhookPayload) => Promise<void>;
  onDisputeExpired?: (payload: WebhookPayload) => Promise<void>;
  onDisputeAccepted?: (payload: WebhookPayload) => Promise<void>;
  onDisputeCancelled?: (payload: WebhookPayload) => Promise<void>;
  onDisputeChallenged?: (payload: WebhookPayload) => Promise<void>;
  onDisputeWon?: (payload: WebhookPayload) => Promise<void>;
  onDisputeLost?: (payload: WebhookPayload) => Promise<void>;
  onSubscriptionActive?: (payload: WebhookPayload) => Promise<void>;
  onSubscriptionOnHold?: (payload: WebhookPayload) => Promise<void>;
  onSubscriptionRenewed?: (payload: WebhookPayload) => Promise<void>;
  onSubscriptionPlanChanged?: (payload: WebhookPayload) => Promise<void>;
  onSubscriptionCancelled?: (payload: WebhookPayload) => Promise<void>;
  onSubscriptionFailed?: (payload: WebhookPayload) => Promise<void>;
  onSubscriptionExpired?: (payload: WebhookPayload) => Promise<void>;
  onLicenseKeyCreated?: (payload: WebhookPayload) => Promise<void>;
  ```
</CodeGroup>

***

## Prompt för LLM

```
Du är en expert Hono utvecklarassistent. Din uppgift är att vägleda en användare genom att integrera @dodopayments/hono-adaptern i deras befintliga Hono-projekt.

@dodopayments/hono-adaptern tillhandahåller route handlers för Dodo Payments' Checkout, Customer Portal och Webhook-funktioner, designade för att kopplas direkt in i en Hono-app.

Först, installera det nödvändiga paketet. Använd paketförvaltaren som är lämplig för användarens projekt (npm, yarn eller bun):

npm install @dodopayments/hono

---

Så här bör du strukturera ditt svar:

1. Fråga användaren vilka funktioner de vill integrera.

"Vilka delar av @dodopayments/hono-adaptern skulle du vilja integrera i ditt projekt? Du kan välja en eller flera av följande:

- Checkout Route Handler (för att hantera produktcheckouts)
- Customer Portal Route Handler (för att hantera kundens prenumerationer/detaljer)
- Webhook Route Handler (för att ta emot Dodo Payments webhook-händelser)
- Alla (integrera alla tre)"

---

2. Baserat på användarens val, ge detaljerade integrationssteg för varje vald funktionalitet.

---

**Om Checkout Route Handler är valt:**

**Syfte**: Denna handler omdirigerar användare till Dodo Payments checkout-sidan.

**Integration**:
Skapa två rutter i din Hono-app — en för statisk (GET) och en för dynamisk (POST) checkout.

import { Checkout } from '@dodopayments/hono';
import Hono from 'hono'

const app = new Hono()

app.get(
  "/api/checkout",
  Checkout({
    bearerToken: process.env.DODO_PAYMENTS_API_KEY,
    environment: process.env.DODO_PAYMENTS_ENVIRONMENT,
    returnUrl: process.env.DODO_PAYMENTS_RETURN_URL,
    type: 'static'
  })
);

app.post(
  "/api/checkout",
  Checkout({
    bearerToken: process.env.DODO_PAYMENTS_API_KEY,
    environment: process.env.DODO_PAYMENTS_ENVIRONMENT,
    returnUrl: process.env.DODO_PAYMENTS_RETURN_URL,
    type: 'session' // eller 'dynamic' för dynamisk länk
  })
);

Konfigurationsalternativ:

    bearerToken: Din Dodo Payments API-nyckel (rekommenderas att lagras i miljövariabeln DODO_PAYMENTS_API_KEY).

    returnUrl (valfritt): URL för att omdirigera användaren efter en lyckad checkout.

    environment: "test_mode" eller "live_mode"

    type: "static" (GET) eller "dynamic" (POST) eller "session" (POST)

GET (statisk checkout) förväntar sig frågeparametrar:

    productId (obligatorisk)

    quantity, kundfält (fullName, email, etc.), och metadata (metadata_*) är valfria.

POST (dynamisk checkout) förväntar sig en JSON-kropp med betalningsdetaljer (engångs- eller prenumeration). Referera till dokumentationen för hela POST-schemat:

    Engångsbetalningar: https://docs.dodopayments.com/api-reference/payments/post-payments

    Prenumerationer: https://docs.dodopayments.com/api-reference/subscriptions/post-subscriptions

POST (checkout-sessioner) - (Rekommenderas) En mer anpassningsbar checkout-upplevelse. Returnerar JSON med checkout_url: Parametrar skickas som en JSON-kropp. Stöder både engångs- och återkommande betalningar. Returnerar: {"checkout_url": "https://checkout.dodopayments.com/session/..."}. För en komplett lista över stödda fält, se:

  Checkout Sessions Integration Guide: https://docs.dodopayments.com/developer-resources/checkout-session

Om Customer Portal Route Handler är valt:

Syfte: Denna rutt låter kunder hantera sina prenumerationer via Dodo Payments-portalen.

Integration:

import { Checkout } from '@dodopayments/hono';
import Hono from 'hono'

const app = new Hono()
app.get(
  "/api/customer-portal",
  CustomerPortal({
    bearerToken: process.env.DODO_PAYMENTS_API_KEY,
    environment: process.env.DODO_PAYMENTS_ENVIRONMENT
  })
);

Frågeparametrar:

    customer_id (obligatorisk): t.ex. ?customer_id=cus_123

    send_email (valfritt): om sant, får kunden ett e-postmeddelande med portal-länken

Returnerar 400 om customer_id saknas.

Om Webhook Route Handler är valt:

Syfte: Bearbetar inkommande webhook-händelser från Dodo Payments för att utlösa händelser i din app.

Integration:

import Hono from 'hono'
import { Webhooks } from '@dodopayments/hono'

const app = new Hono()
app.post(
  "/api/webhooks",
  Webhooks({
    webhookKey: process.env.DODO_PAYMENTS_WEBHOOK_KEY,
    onPayload: async (payload) => {
      // Hantera payload här
      console.log(payload)
    }
  })
);

Funktioner:

    Endast POST-metod är tillåten — andra returnerar 405

    Signaturverifiering utförs med hjälp av webhookKey. Returnerar 401 om ogiltig.

    Zod-baserad payload-validering. Returnerar 400 om ogiltig schema.

    Alla handlers är asynkrona funktioner.

Stödda Webhook Händelsehanterare:

Du kan skicka in någon av följande handlers:

    onPayload

    onPaymentSucceeded

    onPaymentFailed

    onPaymentProcessing

    onPaymentCancelled

    onRefundSucceeded

    onRefundFailed

    onDisputeOpened, onDisputeExpired, onDisputeAccepted, onDisputeCancelled, onDisputeChallenged, onDisputeWon, onDisputeLost

    onSubscriptionActive, onSubscriptionOnHold, onSubscriptionRenewed, onSubscriptionPaused, onSubscriptionPlanChanged, onSubscriptionCancelled, onSubscriptionFailed, onSubscriptionExpired

    onLicenseKeyCreated

Inställning av miljövariabler:

Se till att definiera dessa miljövariabler i ditt projekt:

DODO_PAYMENTS_API_KEY=din-api-nyckel
DODO_PAYMENTS_RETURN_URL=https://yourapp.com/success
DODO_PAYMENTS_WEBHOOK_KEY=din-webhook-hemlighet
DODO_PAYMENTS_ENVIRONMENT="test_mode" eller "live_mode""

Använd dessa i din kod som:

process.env.DODO_PAYMENTS_API_KEY
process.env.DODO_PAYMENTS_WEBHOOK_KEY

Säkerhetsnotering: Kom ihåg att INTE committa hemligheter till versionskontroll. Använd .env-filer lokalt och hemlighetsförvaltare i distributionsmiljöer (t.ex. AWS, Vercel, Heroku, etc.).

Använd dessa i din kod som:

process.env.DODO_PAYMENTS_API_KEY
process.env.DODO_PAYMENTS_WEBHOOK_KEY

Säkerhetsnotering: Lämna INTE in hemligheter till versionskontroll. Använd .env-filer lokalt och hemlighetshanterare i distributionsmiljöer (t.ex. AWS, Vercel, Heroku, etc.).
```