# Eine Rechnung erstellen und senden

Erstellen Sie ein Beispiel für eine Invoicing-Integration.

# Eine Rechnung erstellen und senden

Erstellen Sie eine vollständige, funktionierende Integration der Rechnungsstellung mithilfe von Stripe Invoicing. Erfahren Sie, wie Sie einen/eine Kund/in suchen, einen Preis aus einem Objekt erhalten, das eine Datenbank darstellt und eine Rechnung erstellen und senden.

1. Build the server

~~~
npm install
~~~

2. Run the server

~~~
npm start
~~~
1. Run the server

~~~
go run server.go
~~~
1. Build the server

~~~
pip3 install -r requirements.txt
~~~

2. Run the server

~~~
export FLASK_APP=server.py
python3 -m flask run --port=4242
~~~

1. Build the server

~~~
bundle install
~~~

2. Run the server

~~~
ruby server.rb -o 0.0.0.0
~~~

1. Build the server

~~~
composer install
~~~

2. Run the server

~~~
php -S 127.0.0.1:4242 --docroot=public
~~~
1. Build the server

~~~
dotnet build
~~~

2. Run the server

~~~
dotnet run
~~~
1. Build the server

~~~
mvn package
~~~

2. Run the server

~~~
java -cp target/sample-jar-with-dependencies.jar com.stripe.sample.Server
~~~

~~~
stripe listen --forward-to localhost:4242/webhook.php
~~~

~~~
stripe listen --forward-to localhost:4242/webhook
~~~
### Stripe Node-Bibliothek installieren

Installieren Sie das Paket und importieren Sie es in Ihren Code. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine package.json-Datei benötigen, laden Sie die Projektdateien über den Download-Link im Code-Editor herunter.

#### npm

Bibliothek installieren:

```bash
npm install --save stripe
```

#### GitHub

Oder laden Sie den Quellcode der Stripe-Node-Bibliothek direkt von [GitHub](https://github.com/stripe/stripe-node) herunter.

### Stripe-Ruby-Bibliothek installieren

Installieren Sie Stripe Ruby Gem und fordern Sie es in Ihrem Code an. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine Gemfile benötigen, laden Sie die Projektdateien über den Download-Link im Code-Editor herunter.

#### Terminal

Gem installieren:

```bash
gem install stripe
```

#### Bundler

Fügen Sie diese Zeile in Ihre Gemfile ein:

```bash
gem 'stripe'
```

#### GitHub

Oder laden Sie den Quellcode von Stripe Ruby Gem direkt von [GitHub](https://github.com/stripe/stripe-ruby) herunter.

### Stripe Java-Bibliothek installieren

Fügen Sie Ihrem Build die Abhängigkeit hinzu und importieren Sie die Bibliothek. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine pom.xml-Beispieldatei (für Maven) benötigen, laden Sie die Projektdateien über den Download-Link im Code-Editor herunter.

#### Maven

Fügen Sie folgende Abhängigkeit zu Ihrer POM-Datei hinzu und ersetzen Sie {VERSION} durch die Versionsnummer, die Sie verwenden möchten.

```bash
<dependency>\n<groupId>com.stripe</groupId>\n<artifactId>stripe-java</artifactId>\n<version>{VERSION}</version>\n</dependency>
```

#### Gradle

Fügen Sie die Abhängigkeit zu Ihrer build.gradle-Datei hinzu und ersetzen Sie {VERSION} durch die Versionsnummer, die Sie verwenden möchten.

```bash
implementation "com.stripe:stripe-java:{VERSION}"
```

#### GitHub

Laden Sie die JAR-Datei direkt von [GitHub](https://github.com/stripe/stripe-java/releases/latest) herunter.

### Stripe-Python-Paket installieren

Installieren Sie das Stripe-Paket und importieren Sie es in Ihren Code. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine requirements.txt-Datei benötigen, laden Sie die Projektdateien über den Download-Link im Code-Editor herunter.

#### pip

Installieren Sie das Paket über pip:

```bash
pip3 install stripe
```

#### GitHub

Laden Sie den Quellcode der Stripe-Python-Bibliothek direkt [von GitHub](https://github.com/stripe/stripe-python) herunter.

### Stripe PHP-Bibliothek installieren

Installieren Sie die Bibliothek mit Composer und initialisieren Sie sie mit Ihrem geheimen API-Schlüssel. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine composer.csproj-Datei benötigen, laden Sie die Dateien über den Download-Link im Code-Editor herunter.

#### Composer

Bibliothek installieren:

```bash
composer require stripe/stripe-php
```

#### GitHub

Oder laden Sie den Quellcode der Stripe-PHP-Bibliothek direkt von [GitHub](https://github.com/stripe/stripe-php) herunter.

### Server einrichten

Fügen Sie Ihrem Build die Abhängigkeit hinzu und importieren Sie die Bibliothek. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine go.mod-Datei benötigen, laden Sie die Projektdateien über den Download-Link im Code-Editor herunter.

#### Go

Nutzen Sie für die Initialisierung Go-Module:

```bash
go get -u github.com/stripe/stripe-go/v84
```

#### GitHub

Oder laden Sie den Quellcode des Stripe-Go-Moduls direkt von [GitHub](https://github.com/stripe/stripe-go) herunter.

### Stripe.net-Bibliothek installieren

Installieren Sie das Paket mit .NET oder NuGet. Wenn Sie aber von Grund auf neu beginnen möchten, laden Sie die Dateien herunter, die eine konfigurierte .csproj-Datei enthalten.

#### dotnet

Bibliothek installieren:

```bash
dotnet add package Stripe.net
```

#### NuGet

Bibliothek installieren:

```bash
Install-Package Stripe.net
```

#### GitHub

Oder laden Sie den Quellcode der Stripe.net-Bibliothek direkt von [GitHub](https://github.com/stripe/stripe-dotnet) herunter.

### Stripe-Bibliotheken installieren

Installieren Sie die Pakete und importieren Sie sie in Ihren Code. Wenn Sie dagegen von Grund auf neu beginnen möchten und eine `package.json`-Datei benötigen, laden Sie die Projektdateien über den Download-Link im Code-Editor herunter.

Bibliotheken installieren:

```bash
npm install --save stripe @stripe/stripe-js next
```

### Produkte, Preise und Kund/innen verwalten

Erstellen Sie zunächst einen Preis für Ihr Produkt im [Dashboard](https://docs.stripe.com/invoicing/products-prices.md) oder über die [API](https://docs.stripe.com/api/prices/create.md). Nachdem Sie einen Preis erstellt und einem Produkt zugeordnet haben, speichern Sie seine ID in Ihrer Datenbank.

Suchen Sie als Nächstes nach [einem Kunden/einer Kundin](https://docs.stripe.com/api/customers.md) in Ihrer Datenbank anhand der [E-Mail-Adresse](https://docs.stripe.com/api/customers/object.md?lang=dotnet#customer_object-email). Wenn der Kunde/die Kundin nicht vorhanden ist, erstellen Sie das `Customer`-Objekt und speichern die Kunden-ID für zukünftige Käufe. Im nächsten Schritt wird beispielsweise die [ID](https://docs.stripe.com/api/customers/object.md#customer_object-id) des [Customer-Objekts](https://docs.stripe.com/api/customers/object.md) zum Erstellen einer Rechnung verwendet.

> Das `Customer`-Objekt stellt den/die Kund/in dar, der/die Ihr Produkt kauft. Es wird zum Erstellen einer Rechnung benötigt.

### Verwalten Sie Produkte, Preise und vom Kunden konfigurierte Konten

Erstellen Sie zunächst einen Preis für Ihr Produkt im [Dashboard](https://docs.stripe.com/invoicing/products-prices.md) oder über die [API](https://docs.stripe.com/api/prices/create.md). Nachdem Sie einen Preis erstellt und einem Produkt zugeordnet haben, speichern Sie seine ID in Ihrer Datenbank.

Suchen Sie anschließend eine Kundin oder einen Kunden in Ihrer Datenbank anhand der E-Mail-Adresse. Falls diese Kundin oder dieser Kunde nicht existiert, erstellen Sie das [Konto](https://docs.stripe.com/api/v2/core/accounts.md) für die [Kundin oder den Kunden](https://docs.stripe.com/connect/account-capabilities.md?accounts-namespace=v2#customer) und speichern Sie deren Ausweis für zukünftige Käufe. Der nächste Schritt verwendet beispielsweise die [id](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-id) des [Konto-Objekts](https://docs.stripe.com/api/v2/core/accounts/object.md), um eine Rechnung zu erstellen.

> Das vom Kunden konfigurierte `Account`-Objekt stellt die Kundin oder den Kunden dar, der Ihr Produkt kauft. Es ist erforderlich, um eine Rechnung zu erstellen.

### Leere Rechnung erstellen

Legen Sie das Attribut [collection_method](https://docs.stripe.com/api/invoices/object.md#invoice_object-collection_method) auf `send_invoice` fest. Damit Stripe eine Rechnung als überfällig kennzeichnet, müssen Sie den Parameter [days_until_due](https://docs.stripe.com/api/invoices/create.md#create_invoice-days_until_due) hinzufügen. Wenn Sie eine Rechnung senden, sendet Stripe die Rechnung per E-Mail mit Zahlungsanweisungen an den Kunden/die Kundin.

> Die andere verfügbare Einzugsmethode ist `charge_automatically`. Bei der automatischen Zahlung versucht Stripe, die Rechnung sofort mit der Standardquelle zu bezahlen, die mit dem/der Kund/in verbunden ist. Hier verwenden wir `send_invoice`, um eine sofortige, unerwünschte Belastung des Kundenkontos zu verhindern.

### Rechnungsposten erstellen

Erstellen Sie einen Rechnungsposten, indem Sie die `id` des/der Kund/in, den `price` des Produkts und die Rechnungs-ID der `invoice` übergeben.

Die maximale Anzahl der Rechnungsposten ist 250.

> Wenn Rechnungsposten vor der Erstellung einer Rechnung erstellt werden, setzen Sie das [pending_invoice_items_behavior](https://docs.stripe.com/api/invoices/create.md#create_invoice-pending_invoice_items_behavior) bei Erstellung der Rechnung auf `include`, damit alle ausstehenden Rechnungsposten der Rechnung automatisch hinzugefügt werden. Fügen Sie in diesem Fall die Rechnungsposten immer nur einem einzigen Kunden/einer einzigen Kundin hinzu, um zu vermeiden, dass sie dem falschen Kunden/der falschen Kundin hinzugefügt werden.
> 
> Beim Erstellen einer Rechnung werden bis zu 250 ausstehende Rechnungsposten hinzugefügt, der Rest wird bei der nächsten Rechnung hinzugefügt. Um ausstehende Rechnungsposten Ihrer Kundinnen/Kunden anzuzeigen, rufen Sie die Seite mit **Kundendetails** auf oder setzen Sie das Attribut [pending](https://docs.stripe.com/api/invoiceitems/list.md#list_invoiceitems-pending) auf `true`, wenn Sie die API verwenden, um alle Rechnungsposten aufzuführen.

Senden Sie die Rechnung an die mit dem/der Kund/in verbundenen E-Mail-Adresse. Sobald Sie die Rechnung versenden, wird sie von Stripe finalisiert. In vielen Zuständigkeitsbereichen gelten finalisierte Rechnungen als rechtliches Dokument, sodass bestimmte Felder nicht geändert werden können. Wenn Sie Rechnungen versenden, die bereits bezahlt wurden, gibt es in der E-Mail keinen Hinweis auf die Zahlung.

Für jede finalisierte Rechnung können Sie entweder eine [PDF](https://docs.stripe.com/api/invoices/object.md#invoice_object-invoice_pdf) oder den [Link](https://docs.stripe.com/api/invoices/object.md#invoice_object-hosted_invoice_url) zur entsprechenden [gehosteten Rechnungsseite](https://docs.stripe.com/invoicing/hosted-invoice-page.md) herunterladen und senden.

## Glückwunsch!

Sie haben Ihre erste Rechnung erstellt und versendet. Gehen Sie mit Ihrer Integration noch einen Schritt weiter und erfahren Sie, wie Sie die Steuererhebung über die API schnell automatisieren können.

### Steuereinzug automatisieren

Berechnen und erheben Sie den richtigen Steuerbetrag für Ihre Stripe-Transaktionen. Erfahren Sie mehr über [Stripe Tax](https://docs.stripe.com/tax.md) und wie Sie die Funktion im Dashboard [aktivieren](https://dashboard.stripe.com/tax), bevor Sie sie integrieren.

### Parameter für den automatischen Steuereinzug hinzufügen

Legen Sie den Parameter `automatic_tax` auf `enabled: true` fest.

// This is a public sample test API key.
// Don’t submit any personally identifiable information in requests made with this key.
// Sign in to see your own test API key embedded in code samples.
const stripe = require('stripe')('<<YOUR_SECRET_KEY>>');
// You probably have a database to keep track of preexisting customers.
// But to keep things simple, we'll use an Object to store Stripe object IDs in this example.
const CUSTOMERS = [{stripeId: "cus_123456789", email: "jenny.rosen@example.com"}];
// Prices on Stripe model the pricing scheme of your business.
// Create Prices in the Dashboard or with the API before accepting payments
// and store the IDs in your database.
const PRICES = {basic: "price_123456789", professional: "price_987654321"};

const sendInvoice = async function (email) {
  // Look up a customer in your database
  let customer = CUSTOMERS.find(c => c.email === email);
  let customerId;
  if (!customer) {
    // Create a new Customer
    customer = await stripe.customers.create({
      email,
      description: 'Customer to invoice',
    });
    // Store the Customer ID in your database to use for future purchases
    CUSTOMERS.push({stripeId: customer.id, email: email});
    customerId = customer.id;
  } else {
    // Read the Customer ID from your database
    customerId = customer.stripeId;
  }
// You probably have a database to keep track of preexisting customers.
// But to keep things simple, we'll use an Object to store Stripe object IDs in this example.
const CUSTOMERS = [{stripeId: "acct_123456789", email: "jenny.rosen@example.com"}];
// Prices on Stripe model the pricing scheme of your business.
// Create Prices in the Dashboard or with the API before accepting payments
// and store the IDs in your database.
const PRICES = {basic: "price_123456789", professional: "price_987654321"};

const sendInvoice = async function (email) {
  // Look up a customer in your database
  let customer = CUSTOMERS.find(c => c.email === email);
  let customerId;
  if (!customer) {
    // Create a new customer-configured Account
    customer = await stripe.v2.core.accounts.create({
      contact_email: email,
      display_name: 'Customer to invoice',
      configuration: {
        customer: {
            capabilities: {
              automatic_indirect_tax: {requested: true}
              },
        },
      },
    });
    // Store the Customer ID in your database to use for future purchases
    CUSTOMERS.push({stripeId: customer.id, email: email});
    customerId = customer.id;
  } else {
    // Read the Customer ID from your database
    customerId = customer.stripeId;
  }

  // Create an Invoice
  const invoice = await stripe.invoices.create({
    customer: customerId,
    collection_method: 'send_invoice',
    days_until_due: 30,
    automatic_tax: {enabled: true},
  });

  // Create an Invoice
  const invoice = await stripe.invoices.create({
    customer_account: customerId,
    collection_method: 'send_invoice',
    days_until_due: 30,
    automatic_tax: {enabled: true},
  });

  // Create an Invoice Item with the Price, and Customer you want to charge
  const invoiceItem = await stripe.invoiceItems.create({ 
    customer: customerId,
    pricing: {
      price: PRICES.basic,
    },
    invoice: invoice.id
  });

  // Create an Invoice Item with the Price and the customer-configured Account you want to charge
  const invoiceItem = await stripe.invoiceItems.create({ 
    customer_account: customerId,
    pricing: {
      price: PRICES.basic,
    },
    invoice: invoice.id
  });

  // Send the Invoice
  await stripe.invoices.sendInvoice(invoice.id);
};
{
  "name": "stripe-sample",
  "version": "1.0.0",
  "description": "A sample Stripe implementation",
  "main": "server.js",
  "scripts": {
    "start": "node server.js"
  },
  "author": "stripe-samples",
  "license": "ISC",
  "dependencies": {
    "express": "^4.17.1",
    "stripe": "^20.4.0"
  }
}
{
  "name": "stripe-sample",
  "version": "0.1.0",
  "dependencies": {
    "@stripe/react-stripe-js": "^3.7.0",
    "@stripe/stripe-js": "^7.3.0",
    "express": "^4.17.1",
    "react": "^18.2.0",
    "react-dom": "^18.2.0",
    "react-scripts": "^3.4.0",
    "stripe": "20.4.0"
  },
  "devDependencies": {
    "concurrently": "4.1.2"
  },
  "homepage": "http://localhost:3000/checkout",
  "proxy": "http://localhost:4242",
  "scripts": {
    "start-client": "react-scripts start",
    "start-server": "node server.js",
    "build": "react-scripts build",
    "test": "react-scripts test",
    "eject": "react-scripts eject",
    "start": "concurrently \"yarn start-client\" \"yarn start-server\""
  },
  "eslintConfig": {
    "extends": "react-app"
  },
  "browserslist": {
    "production": [
      ">0.2%",
      "not dead",
      "not op_mini all"
    ],
    "development": [
      "last 1 chrome version",
      "last 1 firefox version",
      "last 1 safari version"
    ]
  }
}
const stripe = require('stripe')('<<YOUR_SECRET_KEY>>');
\# This is a public sample test API key.
# Don’t submit any personally identifiable information in requests made with this key.
# Sign in to see your own test API key embedded in code samples.
Stripe.api_key = '<<YOUR_SECRET_KEY>>'
\# This is a public sample test API key.
# Don’t submit any personally identifiable information in requests made with this key.
# Sign in to see your own test API key embedded in code samples.
$CLIENT = Stripe::StripeClient.new('<<YOUR_SECRET_KEY>>')
\# You probably have a database to keep track of preexisting customers.
# But to keep things simple, we'll use an Object to store Stripe object IDs in this example.
$CUSTOMERS = [{ stripeId: 'cus_123456789', email: 'jenny.rosen@example.com' }]
# Prices on Stripe model the pricing scheme of your business.
# Create Prices in the Dashboard or with the API before accepting payments
# and store the IDs in your database.
$PRICES = { basic: 'price_123456', professional: 'price_456789' }

def send_invoice(email)
# Look up a customer in your database
  customer = $CUSTOMERS.find { |customer_obj| customer_obj[:email] == email }
  customer_id = nil

  if !customer
    # Create a new Customer
    customer = Stripe::Customer.create({
      email: email,
      description: 'Customer to invoice'
    })
    # Store the Customer ID in your database to use for future purchases
    $CUSTOMERS << { stripeId: customer.id, email: email }
    customer_id = customer.id
  else
    # Read the Customer ID from your database
    customer_id = customer[:stripeId]
  end
\# You probably have a database to keep track of preexisting customers.
# But to keep things simple, we'll use an Object to store Stripe object IDs in this example.
$CUSTOMERS = [{ stripeId: 'acct_123456789', email: 'jenny.rosen@example.com' }]
# Prices on Stripe model the pricing scheme of your business.
# Create Prices in the Dashboard or with the API before accepting payments
# and store the IDs in your database.
$PRICES = { basic: 'price_123456', professional: 'price_456789' }

def send_invoice(email)
# Look up a customer in your database
  customer = $CUSTOMERS.find { |customer_obj| customer_obj[:email] == email }
  customer_id = nil

  if !customer
    # Create a new customer-configured Account
    customer = $CLIENT.v2.core.accounts.create({
      contact_email: email,
      display_name: 'Customer to invoice',
      configuration: {
        customer: {
          capabilities: {automatic_indirect_tax: {requested: true}}
        }  
      }
    })
    \# Store the Customer ID in your database to use for future purchases
    $CUSTOMERS << { stripeId: customer.id, email: email }
    customer_id = customer.id
  else
    # Read the Customer ID from your database
    customer_id = customer[:stripeId]
  end

  \# Create an Invoice
  invoice = Stripe::Invoice.create({
    customer: customer_id,
    collection_method: 'send_invoice',
    days_until_due: 30,
    automatic_tax: {
      enabled: true
    },
  })

  \# Create an Invoice
  invoice = $CLIENT.v1.invoices.create({
    customer_account: customer_id,
    collection_method: 'send_invoice',
    days_until_due: 30,
    automatic_tax: {
      enabled: true
    },
  })

  \# Create an Invoice Item
  invoice_item = Stripe::InvoiceItem.create({ 
    customer: customer_id,
    pricing: {price: $PRICES[:basic]},
    invoice: invoice.id
  })

  \# Create an Invoice Item
  invoice_item = $CLIENT.v1.invoice_items.create({ 
    customer_account: customer_id,
    pricing: {price: $PRICES[:basic]},
    invoice: invoice.id
  })

  \# Send the Invoice
  Stripe::Invoice.send_invoice(invoice[:id])

  \# Send the Invoice
  $CLIENT.v1.invoices.send_invoice(invoice[:id])
Stripe.api_key = '<<YOUR_SECRET_KEY>>'
import stripe
\# This is a public sample test API key.
# Don’t submit any personally identifiable information in requests made with this key.
# Sign in to see your own test API key embedded in code samples.
stripe.api_key = '<<YOUR_SECRET_KEY>>'
import stripe
\# This is a public sample test API key.
# Don’t submit any personally identifiable information in requests made with this key.
# Sign in to see your own test API key embedded in code samples.
client = stripe.StripeClient('<<YOUR_SECRET_KEY>>')
\# You probably have a database to keep track of preexisting customers
# But to keep things simple, we'll use an Object to store Stripe object IDs in this example.
CUSTOMERS = [{"stripe_id": "cus_123456789", "email": "jenny.rosen@example.com"}]
# Prices in Stripe model the pricing scheme of your business.
# Create Prices in the Dashboard or with the API before accepting payments
# and store the IDs in your database.
PRICES = {"basic": "price_123456789", "professional": "price_987654321"}

def send_invoice(email):
  # Look up a customer in your database
    customers = [c for c in CUSTOMERS if c["email"] == email]
    if customers:
        customer_id=customers[0]["stripe_id"]
    else:
        # Create a new Customer
        customer = stripe.Customer.create(
            email=email, # Use your email address for testing purposes
            description="Customer to invoice",
        )
        # Store the customer ID in your database for future purchases
        CUSTOMERS.append({"stripe_id": customer.id, "email": email})
        # Read the Customer ID from your database
        customer_id = customer.id
\# You probably have a database to keep track of preexisting customers
# But to keep things simple, we'll use an Object to store Stripe object IDs in this example.
CUSTOMERS = [{"stripe_id": "acct_123456789", "email": "jenny.rosen@example.com"}]
# Prices in Stripe model the pricing scheme of your business.
# Create Prices in the Dashboard or with the API before accepting payments
# and store the IDs in your database.
PRICES = {"basic": "price_123456789", "professional": "price_987654321"}

def send_invoice(email):
  # Look up a customer in your database
    customers = [c for c in CUSTOMERS if c["email"] == email]
    if customers:
        customer_id=customers[0]["stripe_id"]
    else:
        # Create a new customer-configured Account
        customer = client.v2.core.accounts.create({
            "contact_email": email, # Use your email address for testing purposes
            "display_name": "Customer to invoice",
            "configuration": {
                "customer": {
                    "capabilities": {"automatic_indirect_tax": {"requested": True}}
                },
            },
        })
        \# Store the customer ID in your database for future purchases
        CUSTOMERS.append({"stripe_id": customer.id, "email": email})
        # Read the Customer ID from your database
        customer_id = customer.id

    \# Create an Invoice
    invoice = stripe.Invoice.create(
        customer=customer_id,
        collection_method='send_invoice',
        days_until_due=30,

    \# Create an Invoice
    invoice = client.v1.invoices.create({
        "customer_account": customer_id,
        "collection_method": 'send_invoice',
        "days_until_due": 30,
        "automatic_tax": { 'enabled': True },

    \# Create an Invoice Item with the Price and Customer you want to charge
    stripe.InvoiceItem.create(
        customer=customer_id,
        pricing={"price": PRICES["basic"]},
        invoice=invoice.id
    )

    \# Create an Invoice Item with the Price and the customer-configured Account you want to charge
    client.v1.invoice_items.create({
        "customer_account": customer_id,
        "pricing": {"price": PRICES["basic"]},
        "invoice": invoice.id
    })

    \# Send the Invoice
    stripe.Invoice.send_invoice(invoice.id)
    return

    \# Send the Invoice
    client.v1.invoices.send_invoice(invoice.id)
    return
certifi==2026.1.4
chardet==5.2.0
click==8.3.1
Flask==3.1.2
idna==3.11
itsdangerous==2.2.0
Jinja2==3.1.6
MarkupSafe==3.0.3
requests==2.32.5
stripe==14.4.0
toml==0.10.2
Werkzeug==3.1.5
stripe.api_key = '<<YOUR_SECRET_KEY>>'
\Stripe\Stripe::setApiKey($stripeSecretKey);
$CLIENT = new \Stripe\StripeClient($stripeSecretKey);
// You probably have a database to keep track of preexisting customers.
// But to keep things simple, we'll use an Object to store Stripe object IDs in this example.
$CUSTOMERS = [
  [
    'stripeId' => 'cus_123456789',
    'email' => 'jenny.rosen@example.com'
  ],
];
// Prices on Stripe model the pricing scheme of your business.
// Create Prices in the Dashboard or with the API before accepting payments
// and store the IDs in your database.
$PRICES = [
  'basic' => 'price_123456789',
  'professional' => 'price_987654321',
];

function sendInvoice($email) {
  // Look up a customer in your database
  global $CUSTOMERS;
  global $PRICES;

  $customerId = null;

  $customers = array_filter($CUSTOMERS, function ($customer) use ($email) {
    return $customer['email'] === $email;
  });

  if (!$customers) {
    // Create a new Customer
    $customer = \Stripe\Customer::create([
      'email' => $email,
      'description' => 'Customer to invoice',
    ]);
    // Store the Customer ID in your database to use for future purchases
    $CUSTOMERS[] = [
      'stripeId' => $customer->id,
      'email' => $email
    ];

    $customerId = $customer->id;
  }
  else {
    // Read the Customer ID from your database
    $customerId = $customers[0]['stripeId'];
  }
// You probably have a database to keep track of preexisting customers.
// But to keep things simple, we'll use an Object to store Stripe object IDs in this example.
$CUSTOMERS = [
  [
    'stripeId' => 'acct_123456789',
    'email' => 'jenny.rosen@example.com'
  ],
];
// Prices on Stripe model the pricing scheme of your business.
// Create Prices in the Dashboard or with the API before accepting payments
// and store the IDs in your database.
$PRICES = [
  'basic' => 'price_123456789',
  'professional' => 'price_987654321',
];

function sendInvoice($email) {
  // Look up a customer in your database
  global $CUSTOMERS;
  global $PRICES;
  global $CLIENT;

  $customerId = null;

  $customers = array_filter($CUSTOMERS, function ($customer) use ($email) {
    return $customer['email'] === $email;
  });

  if (!$customers) {
    // Create a new customer-configured Account
    $customer = $CLIENT->v2->core->accounts->create([
      'contact_email' => $email,
      'display_name' => 'Customer to invoice',
      'configuration' => [
        'customer' => [
          'capabilities' => [
                'automatic_indirect_tax' => [
                  'requested' => true,
                ],
          ],
        ],
      ]
    ]);
    // Store the Customer ID in your database to use for future purchases
    $CUSTOMERS[] = [
      'stripeId' => $customer->id,
      'email' => $email
    ];

    $customerId = $customer->id;
  }
  else {
    // Read the Customer ID from your database
    $customerId = $customers[0]['stripeId'];
  }

  // Create an Invoice
  $invoice = \Stripe\Invoice::create([
    'customer' => $customerId,
    'collection_method' => 'send_invoice',
    'days_until_due' => 30,
    'automatic_tax' => [
      'enabled' => true,
    ],
  ]);

  // Create an Invoice
  $invoice = $CLIENT->v1->invoices->create([
    'customer_account' => $customerId,
    'collection_method' => 'send_invoice',
    'days_until_due' => 30,
    'automatic_tax' => [
      'enabled' => true,
    ],
  ]);

  // Create an Invoice Item with the Price, and Customer you want to charge
  $invoiceItem = \Stripe\InvoiceItem::create([
    'customer' => $customerId,
    'pricing' => ['price' => $PRICES['basic']],
    'invoice' => $invoice->id
  ]);

  // Create an Invoice Item with the Price and the customer-configured Account you want to charge
  $invoiceItem = $CLIENT->v1->invoiceItems->create([
    'customer_account' => $customerId,
    'pricing' => ['price' => $PRICES['basic']],
    'invoice' => $invoice->id
  ]);

  // Send the Invoice
  $invoice->sendInvoice();
}

  // Send the Invoice
  $CLIENT->v1->invoices->sendInvoice();
}
$stripeSecretKey = '<<YOUR_SECRET_KEY>>';
    // This is a public sample test API key.
    // Don’t submit any personally identifiable information in requests made with this key.
    // Sign in to see your own test API key embedded in code samples.
    private static StripeClient Client { get; set; } = new StripeClient("<<YOUR_SECRET_KEY>>");

    public static void Main(string[] args)
    {
      // Add a Customer
      Customers.Add(new MyCustomer()
      {
        StripeId = "acct_123456789",
        Email = "jenny.rosen@example.com"
      });
    public static void sendInvoice(String email)
    {
      // Look up a customer in your database
      var customer = Customers.Find(customer => customer.Email == email);
      String customerId;
      if(customer == null) {
        // Create a new Customer
        var customerOptions = new CustomerCreateOptions
        {
          Email = email,
          Description = "Customer to invoice",
        };
        var stripeCustomer = Client.V1.Customers.Create(customerOptions);
        customerId = stripeCustomer.Id;

        // Store the Customer ID in your database to use for future purchases
        Customers.Add(new MyCustomer()
        {
          StripeId = stripeCustomer.Id,
          Email = stripeCustomer.Email,
        });
      } else {
        // Read the Customer ID from your database
        customerId = customer.StripeId;
      }

    public static void sendInvoice(String email)
    {
      // Look up a customer in your database
      var customer = Customers.Find(customer => customer.Email == email);
      String customerId;
      if(customer == null) {
        // Create a new customer-configured Account
        var customerOptions = new Stripe.V2.Core.AccountCreateOptions
        {
          ContactEmail = email,
          DisplayName = "Customer to invoice",
          Configuration = new Stripe.V2.Core.AccountCreateConfigurationOptions
          {
            Customer = new Stripe.V2.Core.AccountCreateConfigurationCustomerOptions
            {
              Capabilities = new Stripe.V2.Core.AccountCreateConfigurationCustomerCapabilitiesOptions
              {
                  AutomaticIndirectTax = new Stripe.V2.Core.AccountCreateConfigurationCustomerCapabilitiesAutomaticIndirectTaxOptions
                  {
                      Requested = true,
                  },
              },
            }
          },
        };
        var stripeCustomer = Client.V2.Core.Accounts.Create(customerOptions);
        customerId = stripeCustomer.Id;

        // Store the Customer ID in your database to use for future purchases
        Customers.Add(new MyCustomer()
        {
          StripeId = stripeCustomer.Id,
          Email = stripeCustomer.CustomerEmail,
        });
      } else {
        // Read the Customer ID from your database
        customerId = customer.StripeId;
      }

      // Create an Invoice
      var invoiceOptions = new InvoiceCreateOptions
      {
        Customer = customerId,
        CollectionMethod = "send_invoice",
        DaysUntilDue = 30,
        AutomaticTax = new InvoiceAutomaticTaxOptions
        {
          Enabled = true,
        },
      };
      var invoice = Client.V1.Invoices.Create(invoiceOptions);
      // Create an Invoice
      var invoiceOptions = new InvoiceCreateOptions
      {
        CustomerAccount = customerId,
        CollectionMethod = "send_invoice",
        DaysUntilDue = 30,
        AutomaticTax = new InvoiceAutomaticTaxOptions
        {
          Enabled = true,
        },
      };
      var invoice = Client.V1.Invoices.Create(invoiceOptions);
      // Create an Invoice Item with the Price, and Customer you want to charge
      var invoiceItemOptions = new InvoiceItemCreateOptions
      {
        Customer = customerId,
        Pricing = new InvoiceItemPricingOptions
        {
            Price = Prices["basic"],
        },
        Invoice = invoice.Id
      };
      Client.V1.InvoiceItems.Create(invoiceItemOptions);
      // Create an Invoice Item with the Price and the customer-configured Account you want to charge
      var invoiceItemOptions = new InvoiceItemCreateOptions
      {
        CustomerAccount = customerId,
        Pricing = new InvoiceItemPricingOptions
        {
            Price = Prices["basic"],
        },
        Invoice = invoice.Id
      };
      Client.V1.InvoiceItems.Create(invoiceItemOptions);

      // Send the Invoice
      Client.V1.Invoices.SendInvoice(invoice.Id);
    }
  }
}
      services.AddSingleton(new StripeClient("<<YOUR_SECRET_KEY>>"));
    "github.com/stripe/stripe-go/v84"
    "github.com/stripe/stripe-go/v84/customer"
    "github.com/stripe/stripe-go/v84/invoice"
    "github.com/stripe/stripe-go/v84/invoiceitem"
    // This is a public sample test API key.
    // Don’t submit any personally identifiable information in requests made with this key.
    // Sign in to see your own test API key embedded in code samples.
    stripe.Key = "<<YOUR_SECRET_KEY>>"
    // This is a public sample test API key.
    // Don’t submit any personally identifiable information in requests made with this key.
    // Sign in to see your own test API key embedded in code samples.
    client := stripe.NewClient("<<YOUR_SECRET_KEY>>")
    // You probably have a database to keep track of preexisting customers.
    // But to keep things simple, we'll hardcode a list of fake customers.
    customers := []MyCustomer{
        {
            StripeId: "cus_123456789",
            Email: "jenny.rosen@example.com",
        },
    }
    // Prices on Stripe model the pricing scheme of your business.
    // Create Prices in the Dashboard or with the API before accepting payments
    // and store the IDs in your database.
    prices := []MyPrice{
        {
          Tier: "basic",
          StripeId: "price_123456789",
        },
        {
          Tier: "professional",
          StripeId: "price_987654321",
        },
    }

    customerID := ""
    // Look up a customer in your database
    for _, x := range customers {
        if x.Email == email {
            customerID = x.StripeId
            break
        }
    }

    if customerID == "" {
        params := &stripe.CustomerParams{
            Email: stripe.String("jenny.rosen@example.com"),
            Description: stripe.String("Customer to invoice"),
        }
        cus, _ := customer.New(params)
        newCus := MyCustomer{
            Email: email,
            StripeId: cus.ID,
        }
        customers = append(customers, newCus)
        customerID = cus.ID
    }

    // Look up the Price ID from your database
    var priceID string
    for _, y := range prices {
        if y.Tier == "basic" {
            priceID = y.StripeId
            break
        }
    }
    // You probably have a database to keep track of preexisting customers.
    // But to keep things simple, we'll hardcode a list of fake customers.
    customers := []MyCustomer{
        {
            StripeId: "acct_123456789",
            Email: "jenny.rosen@example.com",
        },
    }
    // Prices on Stripe model the pricing scheme of your business.
    // Create Prices in the Dashboard or with the API before accepting payments
    // and store the IDs in your database.
    prices := []MyPrice{
        {
          Tier: "basic",
          StripeId: "price_123456789",
        },
        {
          Tier: "professional",
          StripeId: "price_987654321",
        },
    }

    customerID := ""
    // Look up a customer in your database
    for _, x := range customers {
        if x.Email == email {
            customerID = x.StripeId
            break
        }
    }

    if customerID == "" {
        params := &stripe.V2CoreAccountCreateParams{
            ContactEmail: stripe.String("jenny.rosen@example.com"),
            DisplayName: stripe.String("Customer to invoice"),
            Configuration: &stripe.V2CoreAccountCreateConfigurationParams{
                Customer: &stripe.V2CoreAccountCreateConfigurationCustomerParams{
                    Capabilities: &stripe.V2CoreAccountCreateConfigurationCustomerCapabilitiesParams{
                        AutomaticIndirectTax: &stripe.V2CoreAccountCreateConfigurationCustomerCapabilitiesAutomaticIndirectTaxParams{
                        Requested: stripe.Bool(true),
                        },
                    },
                },
            },
        }  
        cus, _ := client.V2CoreAccounts.Create(context.TODO(), params)
        newCus := MyCustomer{
            Email: email,
            StripeId: cus.ID,
        }
        customers = append(customers, newCus)
        customerID = cus.ID
    }

    // Look up the Price ID from your database
    var priceID string
    for _, y := range prices {
        if y.Tier == "basic" {
            priceID = y.StripeId
            break
        }
    }

    // Create an Invoice
    inParams := &stripe.InvoiceParams{
      Customer: stripe.String(customerID),
      CollectionMethod: stripe.String("send_invoice"),
      DaysUntilDue: stripe.Int64(30),
      AutomaticTax: &stripe.CheckoutSessionAutomaticTaxParams{Enabled: stripe.Bool(true)},
    }
    in, _ := invoice.New(inParams)

    // Create an Invoice
    inParams := &stripe.InvoiceCreateParams{
      CustomerAccount: stripe.String(customerID),
      CollectionMethod: stripe.String("send_invoice"),
      DaysUntilDue: stripe.Int64(30),
      AutomaticTax: &stripe.CheckoutSessionAutomaticTaxParams{Enabled: stripe.Bool(true)},
    }
    in, _ := client.V1Invoices.Create(context.TODO(), inParams)
    // Create an Invoice Item with the Price, and Customer you want to charge
    iiParams := &stripe.InvoiceItemParams{
      Customer: stripe.String(customerID),
      Pricing: &stripe.InvoiceItemPricingParams{
        Price: sstripe.String(priceID),
        },
      Invoice: stripe.String(in.ID)
    }
    invoiceitem.New(iiParams)
    // Create an Invoice Item with the Price and the customer-configured Account you want to charge
    iiParams := &stripe.InvoiceItemCreateParams{
      CustomerAccount: stripe.String(customerID),
      Pricing: &stripe.InvoiceItemCreatePricingParams{
        Price: sstripe.String(priceID),
        },
      Invoice: stripe.String(in.ID)
    }
    client.V1InvoiceItems.Create(context.TODO(), iiParams)
    // Send the Invoice
    params := &stripe.InvoiceSendInvoiceParams{}
    invoice.SendInvoice(in.ID, params)
    // Send the Invoice
    params := &stripe.InvoiceSendInvoiceParams{}
    client.V1Invoices.SendInvoice(context.TODO(), in.ID, params)
require github.com/stripe/stripe-go/v84 v84.4.0
  "github.com/stripe/stripe-go/v84"
  "github.com/stripe/stripe-go/v84/webhook"
  stripe.Key = "<<YOUR_SECRET_KEY>>"
import com.stripe.Stripe;
import com.stripe.model.Customer;
import com.stripe.param.CustomerCreateParams;
import com.stripe.StripeClient;
import com.stripe.model.v2.core.Account;
import com.stripe.param.v2.core.AccountCreateParams;
    public static void main(String[] args) {
        // This is a public sample test API key.
        // Don’t submit any personally identifiable information in requests made with this key.
        // Sign in to see your own test API key embedded in code samples.
        Stripe.apiKey = "<<YOUR_SECRET_KEY>>";

        // Simulate data in the DB
        customers.add(new MyCustomer("cus_123456789", "jenny.rosen@example.com"));
        prices.add(new MyPrice("price_123456", "basic"));
        prices.add(new MyPrice("price_789123", "professional"));
    }
    // This is a public sample test API key.
    // Don’t submit any personally identifiable information in requests made with this key.
    // Sign in to see your own test API key embedded in code samples.
    public static StripeClient client = new StripeClient("<<YOUR_SECRET_KEY>>");

    public static void main(String[] args) {

        // Simulate data in the DB
        customers.add(new MyCustomer("acct_123456789", "jenny.rosen@example.com"));
        prices.add(new MyPrice("price_123456", "basic"));
        prices.add(new MyPrice("price_789123", "professional"));
    }
    static void sendInvoice(String email) {
        Customer stripeCustomer;
        // Look up a customer in your database
        String customerId = null;
        for (MyCustomer c : customers) {
            if (c.getEmail().equals(email)) {
                customerId = c.getStripeId();
            }
        }

        // Create a new Customer
        if(customerId == null) {
          CustomerCreateParams params =
            CustomerCreateParams
              .builder()
              .setEmail(email)
              .setDescription("Customer to invoice")
              .build();

          try {
            // Store the Customer ID in your database to use for future purchases
            stripeCustomer = Customer.create(params);
            customers.add(new MyCustomer(stripeCustomer.getId(), email));
            customerId = stripeCustomer.getId();
          } catch(StripeException e) {
            System.out.println(e.getMessage());
          }
        }
    static void sendInvoice(String email) {
        Account stripeCustomer;
        // Look up a customer in your database
        String customerId = null;
        for (MyCustomer c : customers) {
            if (c.getEmail().equals(email)) {
                customerId = c.getStripeId();
            }
        }

        // Create a new customer-configured Account
        if(customerId == null) {
          AccountCreateParams params =
            AccountCreateParams
              .builder()
              .setContactEmail(email)
              .setDisplayName("Customer to invoice")
              .setConfiguration(
                AccountCreateParams.Configuration.builder()
                .setCustomer(
                  AccountCreateParams.Configuration.Customer.builder()
                    .setCapabilities(
                      AccountCreateParams.Configuration.Customer.Capabilities.builder()
                        .setAutomaticIndirectTax(
                          AccountCreateParams.Configuration.Customer.Capabilities.AutomaticIndirectTax.builder()
                            .setRequested(true)
                            .build()
                        )
                        .build()
                    )
                      .build()
                  )
                  .build()
              )
              .build();

          try {
            // Store the Customer ID in your database to use for future purchases
            stripeCustomer = client.v2().core().accounts().create(params);
            customers.add(new MyCustomer(stripeCustomer.getId(), email));
            customerId = stripeCustomer.getId();
          } catch(StripeException e) {
            System.out.println(e.getMessage());
          }
        }
        try {
          // Create an Invoice
          InvoiceCreateParams invoiceParams =
            InvoiceCreateParams
              .builder()
              .setCustomer(customerId)
              .setCollectionMethod(InvoiceCreateParams.CollectionMethod.SEND_INVOICE)
              .setDaysUntilDue(30L)
              .setAutomaticTax(
                InvoiceCreateParams.AutomaticTax.builder().setEnabled(true).build()
              )
              .build();

          Invoice invoice = Invoice.create(invoiceParams);

        try {
          // Create an Invoice
          InvoiceCreateParams invoiceParams =
            InvoiceCreateParams
              .builder()
              .setCustomerAccount(customerId)
              .setCollectionMethod(InvoiceCreateParams.CollectionMethod.SEND_INVOICE)
              .setDaysUntilDue(30L)
              .setAutomaticTax(
                InvoiceCreateParams.AutomaticTax.builder().setEnabled(true).build()
              )
              .build();

          Invoice invoice = client.v1().invoices().create(invoiceParams);

        // Look up the Price ID from your database
        String priceId = null;
        for (MyPrice p : prices) {
            if (p.getTier().equals("basic")) {
                priceId = p.getStripeId();
            }
        }

        // Create an Invoice Item with the Price and Customer you want to charge
        InvoiceItemCreateParams invoiceItemParams =
          InvoiceItemCreateParams.builder()
            .setCustomer(customerId)
            .setPricing(
              InvoiceItemCreateParams.Pricing.builder()
                .setPrice(priceId)
                .build()
            )
            .setInvoice(invoice.getId())
            .build();

        try {
          InvoiceItem.create(invoiceItemParams);
        } catch(StripeException e) {
          System.out.println(e.getMessage());
        }
        // Look up the Price ID from your database
        String priceId = null;
        for (MyPrice p : prices) {
            if (p.getTier().equals("basic")) {
                priceId = p.getStripeId();
            }
        }

        // Create an Invoice Item with the Price and the customer-configured Account you want to charge
        InvoiceItemCreateParams invoiceItemParams =
          InvoiceItemCreateParams.builder()
            .setCustomerAccount(customerId)
            .setPricing(
              InvoiceItemCreateParams.Pricing.builder()
                .setPrice(priceId)
                .build()
            )
            .setInvoice(invoice.getId())
            .build();

        try {
          client.v1().invoiceItems().create(invoiceItemParams);
        } catch(StripeException e) {
          System.out.println(e.getMessage());
        }
          // Send an Invoice
          InvoiceSendInvoiceParams params = InvoiceSendInvoiceParams.builder().build();
          invoice.sendInvoice(params);
          // Send an Invoice
          InvoiceSendInvoiceParams params = InvoiceSendInvoiceParams.builder().build();
          client.v1().invoices().sendInvoice(params);
        Stripe.apiKey = "<<YOUR_SECRET_KEY>>";
## Nächste Schritte

#### [Verwenden Sie eingehende Webhooks, um Updates in Echtzeit zu erhalten](https://docs.stripe.com/webhooks.md)

Überwachen Sie Ereignisse in Ihrem Stripe-Konto, damit Ihre Integration automatisch Reaktionen auslösen kann.

#### [Rechnungen anpassen](https://docs.stripe.com/invoicing/customize.md)

Mit der [Rechnungsvorlage](https://dashboard.stripe.com/account/billing/invoice) können Sie den Inhalt einer Rechnung anpassen. Sie können auch die bevorzugte Sprache eines/einer Kund/in festlegen und öffentliche Informationen in Ihren [Kontodetails](https://dashboard.stripe.com/settings/account/?support_details=true) angeben.

#### [Invoicing API](https://docs.stripe.com/api/invoices.md)

Erfahren Sie mehr über die Invoicing API.

#### [Stripe-CLI](https://docs.stripe.com/stripe-cli.md)

Die Stripe-CLI verfügt über mehrere Befehle, mit denen Sie Ihre Stripe-Anwendung über die Rechnungsstellung hinaus testen können.