Docs
Back to FenerumSign In

Modtag betalinger

Oversigt

Fenerum integrerer med førende betalingsudbydere for at hjælpe dig med at indsamle og administrere kunders betalingsmetoder. Når et betalingskort er registreret i Fenerum, kan du automatisk debitere det for fakturaer og abonnementer.

Understøttede udbydere:

account svg

Stripe

Moderne betalingsinfrastruktur

account svg

Quickpay

Nordisk betalingsgateway

Forudsætninger

Inden du kan acceptere betalinger, skal du konfigurere din betalingsudbyder i Fenerum:

  1. Gå til Settings → Integrations i Fenerum
  2. Tilføj din betalingsudbyders API-legitimationsoplysninger
  3. Aktivér betalingsgatewayen for din organisation

Stripe-integration

Sådan fungerer det

Integration af Stripe med Fenerum omfatter to trin:

  1. Frontend: Indsaml kortoplysninger med Stripe Elements (PCI-kompatibel, kortdata går direkte til Stripe)
  2. Backend: Registrer Stripe Payment Method ID hos Fenerum (din server, med sikker token-håndtering)

Sikkerhedsnote: Eksponer aldrig din Fenerum API-token i frontend-kode. Kald altid Fenerums API fra din backend, hvor tokenen er sikkert lagret i miljøvariabler.

Frontend: Indsaml betalingsmetode

Brug Stripe Elements til sikkert at indsamle kortoplysninger. Kortdata går direkte til Stripe—din server ser dem aldrig.

<!DOCTYPE html>
<html>
<head>
  <title>Add Payment Method</title>
  <script src="https://js.stripe.com/v3/"></script>
  <style>
    #payment-form { max-width: 500px; margin: 50px auto; padding: 20px; }
    #card-element { border: 1px solid #ccc; padding: 10px; border-radius: 4px; }
    button { margin-top: 20px; padding: 10px 20px; background: #5469d4; color: white; border: none; border-radius: 4px; cursor: pointer; }
    button:hover { background: #4158c4; }
    .success { color: green; margin-top: 20px; }
    .error { color: red; margin-top: 20px; }
  </style>
</head>
<body>
  <form id="payment-form">
    <h2>Add Payment Method</h2>
    <div id="card-element"></div>
    <button type="submit">Save Card</button>
    <div id="message"></div>
  </form>

  <script>
    // Initialize Stripe with your publishable key (safe for frontend)
    const stripe = Stripe('pk_test_YOUR_PUBLISHABLE_KEY')
    const elements = stripe.elements()
    const cardElement = elements.create('card')
    cardElement.mount('#card-element')

    const form = document.getElementById('payment-form')
    const messageDiv = document.getElementById('message')

    form.addEventListener('submit', async (event) => {
      event.preventDefault()
      messageDiv.textContent = ''

      // Step 1: Create payment method with Stripe (card data stays secure)
      const {error, paymentMethod} = await stripe.createPaymentMethod({
        type: 'card',
        card: cardElement,
      })

      if (error) {
        messageDiv.textContent = error.message
        messageDiv.className = 'error'
        return
      }

      // Step 2: Send ONLY the payment method ID to YOUR backend
      <!-- focus-start -->
      try {
        const response = await fetch('/api/register-payment-card', {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({
            paymentMethodId: paymentMethod.id,
            accountId: 'ACCOUNT_UUID_HERE'
          })
        })

        const data = await response.json()
      <!-- focus-end -->

        if (response.ok) {
          messageDiv.textContent = `Card saved: ${data.brand} ending in ${data.card_number.slice(-4)}`
          messageDiv.className = 'success'
          form.reset()
        } else {
          messageDiv.textContent = data.error || 'Failed to save card'
          messageDiv.className = 'error'
        }
      } catch (err) {
        messageDiv.textContent = 'Network error: ' + err.message
        messageDiv.className = 'error'
      }
    })
  </script>
</body>
</html>

Vigtige punkter:

  • Stripe publishable key (pk_test_...) er sikker at bruge i frontend-kode
  • Kortdata sendes direkte til Stripe og rører aldrig din server
  • Kun Payment Method ID sendes til din backend
  • Ingen Fenerum API-token i frontend!

Backend: Registrer hos Fenerum

Din backend modtager Stripe Payment Method ID og registrerer det hos Fenerum ved brug af din API-token, som er lagret i miljøvariabler.

// Example backend endpoint (works with Express, Fastify, Next.js, etc.)
// Endpoint: POST /api/register-payment-card
// Body: { paymentMethodId: string, accountId: string }

async function registerPaymentCard(req, res) {
  const { paymentMethodId, accountId } = req.body

  // Validate inputs
  if (!paymentMethodId || !accountId) {
    return res.status(400).json({ error: 'Missing required fields' })
  }

  <!-- focus-start -->
  try {
    // Call Fenerum API with token from environment variables
    const response = await fetch('https://app.fenerum.com/api/v1/paymentcards/', {
      method: 'POST',
      headers: {
        'Authorization': `Token ${process.env.FENERUM_API_TOKEN}`,
        'X-Client-System': 'YourApp',
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        account: accountId,
        token: paymentMethodId,
        gateway: 'stripe_new'
      })
    })

    const data = await response.json()
  <!-- focus-end -->

    if (!response.ok) {
      console.error('Fenerum API error:', data)
      return res.status(response.status).json({
        error: 'Failed to register card with Fenerum'
      })
    }

    // Return success with card details
    return res.status(200).json({
      uuid: data.uuid,
      brand: data.brand,
      card_number: data.card_number,
      month: data.month,
      year: data.year
    })
  } catch (error) {
    console.error('Error registering payment card:', error)
    return res.status(500).json({ error: 'Internal server error' })
  }
}

Opsætning af miljøvariabler:

# .env file (NEVER commit this to version control!)
FENERUM_API_TOKEN=your_actual_token_here

Eksempel på svar:

{
  "uuid": "09655a26-12e0-4a82-8524-7851998886fc",
  "brand": "Visa",
  "card_number": "XXXXXXXXXXXX4242",
  "month": 12,
  "year": 2025
}

Kunde-selvbetjening

Anbefalet: Brug Fenerum Self-Service

Den bedste måde at lade kunder administrere deres betalingsmetoder på er via Fenerum Self-Service—en fuldt hostet portal, hvor kunder kan tilføje betalingskort, administrere abonnementer og se fakturaer uden behov for kode.

Vigtigste fordele:

  • Kunder kan selv tilføje og administrere betalingskort via Stripe eller Quickpay
  • Automatisk integration med jeres branding
  • Ingen kode påkrævet—aktivér det blot i jeres organisationsindstillinger
  • Sikker autentificering via e-mail-link

API-integration:

Generér et direkte adgangslink til Self-Service for jeres kunder:

# Generate Self-Service access link
curl -X POST https://app.fenerum.com/api/self-service/initiate-organization/ \
  -H "Authorization: Token YOUR_FENERUM_TOKEN" \
  -H "X-Client-System: YourApp" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "customer@example.com"
  }'

Svar:

{
  "url": "https://your-company.hostedsignup.com/access/abc123..."
}

Send denne URL til din kunde, som straks kan få adgang til sin kontogrænseflade for at tilføje betalingskort og administrere sine abonnementer.

Når kunder tilføjer et betalingskort via Self-Service, gør Fenerum automatisk følgende:

  • Gemmer kortet på deres konto
  • Sætter "Payment card" som standard opkrævningsmetode
  • Opdaterer alle aktive abonnementer til at bruge den nye betalingsmetode

Lær mere: Self-Service Documentation

Quickpay-integration

Sådan fungerer det

Fenerum bruger QuickPay subscriptions til at gemme betalingskort. Sådan forløber integrationen:

  1. Backend: Opret et QuickPay-betalingslink via QuickPays API
  2. Frontend: Vis QuickPays betalingsformular for kunden (kortdata går direkte til QuickPay)
  3. Callback: QuickPay sender et callback med abonnements-ID, når processen er fuldført
  4. Backend: Registrer abonnements-ID'et hos Fenerum

Sikkerhedsnote: Alle API-kald (både QuickPay og Fenerum) skal ske på din backend, hvor tokens er sikkert lagret.

Din backend opretter et QuickPay-betalingslink via QuickPays payment link API.

// Backend endpoint to create QuickPay payment link
// Endpoint: POST /api/create-quickpay-link
// Body: { accountId: string, customerEmail: string }

async function createQuickpayLink(req, res) {
  const { accountId, customerEmail } = req.body

  <!-- focus-start -->
  try {
    // Create QuickPay payment (subscription)
    const paymentResponse = await fetch('https://api.quickpay.net/payments', {
      method: 'POST',
      headers: {
        'Authorization': `Basic ${Buffer.from(':' + process.env.QUICKPAY_API_KEY).toString('base64')}`,
        'Accept-Version': 'v10',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        currency: 'DKK',
        order_id: `sub_${accountId}_${Date.now()}`,
        variables: {
          fenerum_account_id: accountId,
          customer_email: customerEmail
        }
      })
    })

    const payment = await paymentResponse.json()

    // Create payment link for the subscription
    const linkResponse = await fetch(`https://api.quickpay.net/payments/${payment.id}/link`, {
      method: 'PUT',
      headers: {
        'Authorization': `Basic ${Buffer.from(':' + process.env.QUICKPAY_API_KEY).toString('base64')}`,
        'Accept-Version': 'v10',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        amount: 0, // 0 for card authorization only
        auto_capture: false,
        callback_url: `${process.env.YOUR_DOMAIN}/api/quickpay-callback`
      })
    })

    const link = await linkResponse.json()
  <!-- focus-end -->

    return res.json({ url: link.url })
  } catch (error) {
    console.error('Error creating QuickPay link:', error)
    return res.status(500).json({ error: 'Internal server error' })
  }
}

Miljøopsætning:

QUICKPAY_API_KEY=your_quickpay_api_key_here
YOUR_DOMAIN=https://yourdomain.com
FENERUM_API_TOKEN=your_fenerum_token_here

Trin 2: Omdirigeringsrute

Opret en backend-rute, der genererer QuickPay-linket og omdirigerer kunden direkte til QuickPays hostede side.

// Backend redirect route
// When customer visits: GET /add-payment-card
// They are redirected to QuickPay's hosted payment page

async function redirectToQuickpay(req, res) {
  // Get logged-in user's information from session/auth
  const accountId = req.user.fenerumAccountId
  const email = req.user.email

  <!-- focus-start -->
  try {
    // Create QuickPay payment (subscription)
    const paymentResponse = await fetch('https://api.quickpay.net/payments', {
      method: 'POST',
      headers: {
        'Authorization': `Basic ${Buffer.from(':' + process.env.QUICKPAY_API_KEY).toString('base64')}`,
        'Accept-Version': 'v10',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        currency: 'DKK',
        order_id: `sub_${accountId}_${Date.now()}`,
        variables: {
          fenerum_account_id: accountId,
          customer_email: email
        }
      })
    })

    const payment = await paymentResponse.json()

    // Create payment link
    const linkResponse = await fetch(`https://api.quickpay.net/payments/${payment.id}/link`, {
      method: 'PUT',
      headers: {
        'Authorization': `Basic ${Buffer.from(':' + process.env.QUICKPAY_API_KEY).toString('base64')}`,
        'Accept-Version': 'v10',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        amount: 0,
        auto_capture: false,
        callback_url: `${process.env.YOUR_DOMAIN}/api/quickpay-callback`
      })
    })

    const link = await linkResponse.json()

    // Redirect customer to QuickPay
    return res.redirect(link.url)
  <!-- focus-end -->
  } catch (error) {
    console.error('Error creating QuickPay link:', error)
    return res.status(500).send('Failed to create payment link')
  }
}

Anvendelse:

Giv blot kunder et link til din backend-rute:

<a href="/add-payment-card">Add Payment Method</a>

Ruten bruger den indloggede brugers session til at hente deres konto-ID og e-mail—ingen følsomme data i URL'en.

Trin 3: Håndter QuickPay-callback

Når kunden fuldfører betalingsformularen, sender QuickPay et callback til din server med abonnements-ID'et.

// QuickPay callback handler
// Endpoint: POST /api/quickpay-callback
// Receives QuickPay callback when card is added

async function handleQuickpayCallback(req, res) {
  const { id: subscriptionId, variables } = req.body
  const accountId = variables?.fenerum_account_id

  if (!subscriptionId || !accountId) {
    return res.status(400).json({ error: 'Missing required data' })
  }

  <!-- focus-start -->
  try {
    // Register the QuickPay subscription with Fenerum
    const response = await fetch('https://app.fenerum.com/api/v1/paymentcards/', {
      method: 'POST',
      headers: {
        'Authorization': `Token ${process.env.FENERUM_API_TOKEN}`,
        'X-Client-System': 'YourApp',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        account: accountId,
        token: subscriptionId.toString(), // QuickPay subscription ID
        gateway: 'quickpay'
      })
    })

    const data = await response.json()
  <!-- focus-end -->

    if (response.ok) {
      console.log('Payment card registered with Fenerum:', data)
      return res.status(200).json({ success: true })
    } else {
      console.error('Failed to register card with Fenerum:', data)
      return res.status(500).json({ error: 'Failed to register card' })
    }
  } catch (error) {
    console.error('Error in QuickPay callback:', error)
    return res.status(500).json({ error: 'Internal server error' })
  }
}

Svar fra Fenerum:

{
  "uuid": "09655a26-12e0-4a82-8524-7851998886fc",
  "brand": "Visa",
  "card_number": "XXXXXXXXXXXX4242",
  "month": 12,
  "year": 2025,
  "payment_gateway": "quickpay",
  "account": "50e9aa0b-8d35-4da7-9a9b-8a35b11579b2"
}

Vigtige punkter:

  • QuickPay abonnements-ID skal gemmes som en streng i Fenerum
  • gateway-værdien skal være quickpay
  • Kortdata rører aldrig din server—de går direkte til QuickPay
  • Se QuickPay integration guide for opsætningsvejledning

Kunde-selvbetjening

Anbefalet: Brug Fenerum Self-Service

Den bedste tilgang er at bruge Fenerum Self-Service, hvor kunder selv kan tilføje QuickPay-betalingskort via den hostede portal.

Self-Service-portalen understøtter både Stripe og QuickPay-betalingsmetoder og giver en ensartet oplevelse for jeres kunder. Se afsnittet Kunde-selvbetjening under Stripe-integration ovenfor for API-integrationsdetaljer.

Administration af betalingskort

Hent kort for en konto

curl https://app.fenerum.com/api/v1/paymentcards/?account=CUST001 \
  -H "Authorization: Token YOUR_FENERUM_TOKEN" \
  -H "X-Client-System: YourApp"

Svar:

{
  "count": 2,
  "next": null,
  "previous": null,
  "results": [
    {
      "uuid": "09655a26-12e0-4a82-8524-7851998886fc",
      "active": true,
      "brand": "Visa",
      "card_number": "XXXXXXXXXXXX4242",
      "month": 12,
      "year": 2025,
      "payment_gateway": "stripe_new",
      "account": "50e9aa0b-8d35-4da7-9a9b-8a35b11579b2"
    }
  ]
}

Hent kortdetaljer

curl https://app.fenerum.com/api/v1/paymentcards/{card_uuid}/ \
  -H "Authorization: Token YOUR_FENERUM_TOKEN" \
  -H "X-Client-System: YourApp"

Deaktivér et kort

curl -X POST https://app.fenerum.com/api/v1/paymentcards/{card_uuid}/disable/ \
  -H "Authorization: Token YOUR_FENERUM_TOKEN" \
  -H "X-Client-System: YourApp"

Note: Deaktivering af et kort i Fenerum sletter det ikke hos betalingsudbyderen. Det forhindrer blot Fenerum i at debitere det.

Gateway-reference

Når du opretter betalingskort, skal du bruge disse gateway-identifikatorer:

UdbyderGateway-værdiToken-type
Stripestripe_newPayment Method ID (pm_...)
QuickpayquickpayAbonnements-ID (heltal)

Fejlfinding

Registrering af kort mislykkes:

  • Bekræft betalingsudbyderens legitimationsoplysninger i Fenerum-indstillingerne
  • Kontrollér, at kontoens UUID findes i Fenerum
  • Sørg for, at token-formatet matcher gateway-typen (pm_... for Stripe, heltal for Quickpay)
  • Bekræft, at du bruger den korrekte gateway-værdi (stripe_new eller quickpay)
Previous
Logging
Next
Typical workflow
background logo

Vi fakturerer for mere end 2 millarder årligt for vores kunder. Skal vi hjælpe dig med at sætte din fakturering på autopilot?

Book en demo