Accepting Payments in Games: Complete Guide by Game Engine

Key Principles for Game Payments

• ✓ Never trust client-side confirmation: Always verify payments server-side via webhooks
• ✓ Use idempotency keys: Prevent duplicate charges from network retries
• ✓ Handle subscription lifecycles: Manage renewals, cancellations, and failed payments
• ✓ Consider microtransaction fees: The $0.30 fixed fee can be significant for small purchases

Recommended Payment Processors for Unity

Unity + Stripe Integration Example

Here's a basic Unity C# script for initiating a payment:

using System.Collections;
using UnityEngine;
using UnityEngine.Networking;
using System.Text;

public class PaymentManager : MonoBehaviour
{
    private string apiKey = "sk_test_your_stripe_secret_key";
    private string backendUrl = "https://your-backend.com/api/create-payment";
    
    public void ProcessPayment(float amount, string itemId, string userId)
    {
        StartCoroutine(CreatePaymentIntent(amount, itemId, userId));
    }
    
    private IEnumerator CreatePaymentIntent(float amount, string itemId, string userId)
    {
        // Create payment intent on your backend (NEVER do this in Unity!)
        // Your backend should call Stripe API with secret key
        
        var request = new UnityWebRequest(backendUrl, "POST");
        var jsonBody = $"{{\"amount\": {amount * 100}, \"itemId\": \"{itemId}\", \"userId\": \"{userId}\"}}";
        byte[] bodyRaw = Encoding.UTF8.GetBytes(jsonBody);
        
        request.uploadHandler = new UploadHandlerRaw(bodyRaw);
        request.downloadHandler = new DownloadHandlerBuffer();
        request.SetRequestHeader("Content-Type", "application/json");
        
        yield return request.SendWebRequest();
        
        if (request.result == UnityWebRequest.Result.Success)
        {
            var response = JsonUtility.FromJson<PaymentResponse>(request.downloadHandler.text);
            // Open payment page or handle client secret
            Debug.Log($"Payment intent created: {response.clientSecret}");
        }
        else
        {
            Debug.LogError($"Payment failed: {request.error}");
        }
    }
}

[System.Serializable]
public class PaymentResponse
{
    public string clientSecret;
    public string paymentIntentId;
}

Important: Never store your Stripe secret key in Unity! Always use a backend server to create payment intents. The Unity client should only handle the payment UI and communicate with your secure backend.

Unity Payment Architecture

1. Unity Client: Initiates payment request, displays payment UI
2. Your Backend Server: Creates Stripe PaymentIntent with secret key, returns client secret
3. Stripe Checkout/Element: Handles secure payment collection
4. Stripe Webhook: Sends payment confirmation to your backend
5. Your Backend: Verifies webhook signature, grants in-game items
6. Unity Client: Polls backend or receives push notification for payment confirmation

Recommended Payment Processors for Unreal Engine

Unreal Engine + Stripe Integration (Blueprint)

In Unreal Engine Blueprint, you can use HTTP Request nodes to communicate with your backend:

1. Create HTTP Request Node: Set URL to your backend endpoint (e.g., /api/create-payment)
2. Set Request Method: POST
3. Set Headers: Content-Type: application/json
4. Set Request Body: JSON with amount, itemId, userId
5. On Success: Parse response JSON to get client secret or payment URL
6. Open Payment Page: Use Open URL node to redirect to Stripe Checkout

Unreal Engine C++ Example

// PaymentManager.h
UCLASS()
class YOURGAME_API APaymentManager : public AActor
{
    GENERATED_BODY()
    
public:
    UFUNCTION(BlueprintCallable, Category = "Payment")
    void CreatePayment(float Amount, FString ItemId, FString UserId);
    
    void OnPaymentResponseReceived(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful);
    
private:
    FString BackendUrl = TEXT("https://your-backend.com/api/create-payment");
};

// PaymentManager.cpp
#include "HttpModule.h"
#include "Interfaces/IHttpRequest.h"
#include "Interfaces/IHttpResponse.h"

void APaymentManager::CreatePayment(float Amount, FString ItemId, FString UserId)
{
    TSharedRef<IHttpRequest> Request = FHttpModule::Get().CreateRequest();
    Request->OnProcessRequestComplete().BindUObject(this, &APaymentManager::OnPaymentResponseReceived);
    Request->SetURL(BackendUrl);
    Request->SetVerb(TEXT("POST"));
    Request->SetHeader(TEXT("Content-Type"), TEXT("application/json"));
    
    FString JsonBody = FString::Printf(TEXT("{\"amount\": %.0f, \"itemId\": \"%s\", \"userId\": \"%s\"}"), 
                                       Amount * 100, *ItemId, *UserId);
    Request->SetContentAsString(JsonBody);
    Request->ProcessRequest();
}

void APaymentManager::OnPaymentResponseReceived(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
    if (bWasSuccessful && Response.IsValid())
    {
        TSharedPtr<FJsonObject> JsonObject;
        TSharedRef<TJsonReader<>> Reader = TJsonReaderFactory<>::Create(Response->GetContentAsString());
        
        if (FJsonSerializer::Deserialize(Reader, JsonObject))
        {
            FString ClientSecret = JsonObject->GetStringField(TEXT("clientSecret"));
            // Open payment page or handle client secret
        }
    }
}

Recommended Payment Processors for Godot

Godot GDScript Example

extends Node

var backend_url = "https://your-backend.com/api/create-payment"
var http_request: HTTPRequest

func _ready():
    http_request = HTTPRequest.new()
    add_child(http_request)
    http_request.request_completed.connect(_on_payment_response)

func process_payment(amount: float, item_id: String, user_id: String):
    var json_body = JSON.stringify({
        "amount": int(amount * 100),
        "itemId": item_id,
        "userId": user_id
    })
    
    var headers = ["Content-Type: application/json"]
    var error = http_request.request(backend_url, headers, HTTPClient.METHOD_POST, json_body)
    
    if error != OK:
        print("Payment request failed: ", error)

func _on_payment_response(result: int, response_code: int, headers: PackedStringArray, body: PackedByteArray):
    if response_code == 200:
        var json = JSON.new()
        json.parse(body.get_string_from_utf8())
        var response = json.get_data()
        
        if response.has("clientSecret"):
            # Open payment page or handle client secret
            print("Payment intent created: ", response["clientSecret"])
    else:
        print("Payment failed with code: ", response_code)

Why You Need a Backend Server

• ✓ Security: Secret API keys must never be exposed in game clients
• ✓ Webhook Verification: Verify payment webhooks server-side to prevent fraud
• ✓ Idempotency: Prevent duplicate charges from network retries
• ✓ Item Granting: Securely grant in-game items only after verified payment

Backend Server Example (Node.js + Stripe)

const express = require('express');
const stripe = require('stripe')('sk_live_your_secret_key');
const app = express();

app.use(express.json());

// Create payment intent
app.post('/api/create-payment', async (req, res) => {
  try {
    const { amount, itemId, userId } = req.body;
    
    const paymentIntent = await stripe.paymentIntents.create({
      amount: amount, // in cents
      currency: 'usd',
      metadata: {
        itemId: itemId,
        userId: userId
      }
    });
    
    res.json({ clientSecret: paymentIntent.client_secret });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// Webhook handler (verify payment)
app.post('/webhook', express.raw({type: 'application/json'}), (req, res) => {
  const sig = req.headers['stripe-signature'];
  let event;
  
  try {
    event = stripe.webhooks.constructEvent(req.body, sig, process.env.WEBHOOK_SECRET);
  } catch (err) {
    return res.status(400).send(`Webhook Error: ${err.message}`);
  }
  
  if (event.type === 'payment_intent.succeeded') {
    const paymentIntent = event.data.object;
    const { itemId, userId } = paymentIntent.metadata;
    
    // Grant in-game item to user
    grantItemToUser(userId, itemId);
  }
  
  res.json({received: true});
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});