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

# Create an invoice

> Raises an invoice: an order for a buyer to pay, with a page to pay it on. This is how a script makes an order. The answer has the order's ID (`orderId`) and the page it is paid on (`payUrl`), which you can hand to the buyer yourself.

With `send` on, the invoice is also emailed to the buyer with its PDF. A store may email one invoice in five minutes, so a script that makes many leaves `send` off and delivers the link itself.

A product line costs what the product costs. For any other price, add a line of your own with a `description` and a `unitPrice`. An invoice carries no automatic tax. A store may hold up to 2,000 unpaid invoices at once.

Needs the `invoices.write` permission (Raise Invoices). It makes an order, and is counted against a budget of its own: 60 a minute for each key.



## OpenAPI

````yaml /api-reference/openapi.json post /stores/{storeId}/invoices
openapi: 3.1.0
info:
  title: Shoply API
  version: '1'
  description: >-
    Everything a store's own server can do with a secret API key: its catalogue,
    orders, customers, marketing, finance and the rest of what the dashboard
    does. And the Customer API, which a buyer's own device asks with a token of
    theirs.
servers:
  - url: https://api.shoply.gg/v1
security:
  - apiKey: []
tags:
  - name: API key
  - name: Store
  - name: Domain
  - name: Payment methods
  - name: Analytics
  - name: Storefronts
  - name: Storefront code
  - name: Payment Routing
  - name: Custom payment methods
  - name: Products
  - name: Product pictures
  - name: Stock
  - name: Categories
  - name: Upsells
  - name: Subscriptions
  - name: Orders
  - name: Invoices
  - name: Reviews
  - name: Coupons
  - name: Coupon categories
  - name: Coupon pop-up
  - name: Sales
  - name: Blog
  - name: Search settings
  - name: Redirects
  - name: Sitemap
  - name: Cart Recovery
  - name: Email Marketing
  - name: Email Templates
  - name: Customers
  - name: Affiliates
  - name: Support Tickets
  - name: Blacklist
  - name: Fraud protection
  - name: Disputes
  - name: Finance
  - name: Tax
  - name: Expenses
  - name: Expense setup
  - name: API requests
  - name: Webhook endpoints
  - name: Webhook deliveries
  - name: Customer API
paths:
  /stores/{storeId}/invoices:
    post:
      tags:
        - Invoices
      summary: Create an invoice
      description: >-
        Raises an invoice: an order for a buyer to pay, with a page to pay it
        on. This is how a script makes an order. The answer has the order's ID
        (`orderId`) and the page it is paid on (`payUrl`), which you can hand to
        the buyer yourself.


        With `send` on, the invoice is also emailed to the buyer with its PDF. A
        store may email one invoice in five minutes, so a script that makes many
        leaves `send` off and delivers the link itself.


        A product line costs what the product costs. For any other price, add a
        line of your own with a `description` and a `unitPrice`. An invoice
        carries no automatic tax. A store may hold up to 2,000 unpaid invoices
        at once.


        Needs the `invoices.write` permission (Raise Invoices). It makes an
        order, and is counted against a budget of its own: 60 a minute for each
        key.
      operationId: invoices.create
      parameters:
        - name: storeId
          in: path
          required: true
          description: >-
            The store's ID. A key reaches the store it was made in: `GET /key`
            answers which.
          schema:
            type: string
        - $ref: '#/components/parameters/IdempotencyKey'
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                email:
                  type: string
                  description: The buyer's email address.
                  example: buyer@example.com
                name:
                  type: string
                  description: >-
                    The buyer's name, up to 120 characters. Printed on the
                    invoice.
                note:
                  type: string
                  description: A note printed on the invoice, up to 1,000 characters.
                dueDays:
                  type: integer
                  description: 'How many days the buyer has to pay: 1 to 30.'
                  default: 7
                gateways:
                  type: array
                  description: >-
                    The payment methods the buyer may pay with, by their names
                    in the payment methods list. At least one the store has
                    switched on.
                  items:
                    type: string
                  example:
                    - stripe
                items:
                  type: array
                  description: >-
                    What is being charged for, up to 50 lines. Each is a product
                    from the catalogue (`productId`, `variantId`, `quantity`) or
                    a line of your own (`description`, `quantity`, `unitPrice`).
                  items:
                    type: object
                    properties:
                      productId:
                        type: string
                        description: A product of the store.
                      variantId:
                        type: string
                        description: The variant of it being bought.
                      description:
                        type: string
                        description: >-
                          A line of your own: what it is for, up to 255
                          characters.
                      unitPrice:
                        type: number
                        description: 'A line of your own: its price for one.'
                      quantity:
                        type: integer
                        description: How many.
                        example: 1
                    required:
                      - quantity
                send:
                  type: boolean
                  description: Whether to email the invoice to the buyer now.
                  default: true
              required:
                - email
                - gateways
                - items
      responses:
        '200':
          description: It worked.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Envelope'
        '401':
          $ref: '#/components/responses/NoKey'
        '403':
          $ref: '#/components/responses/NotAllowed'
        '404':
          $ref: '#/components/responses/NotFound'
        '422':
          $ref: '#/components/responses/Refused'
        '429':
          $ref: '#/components/responses/TooMany'
      x-codeSamples:
        - lang: javascript
          label: Node.js
          source: |
            import Shoply from "@shoplygg/node";

            const shoply = new Shoply({ apiKey: process.env.SHOPLY_API_KEY });

            const result = await shoply.invoices.create({
              email: "buyer@example.com",
              gateways: ["stripe"],
              items: [],
            });
        - lang: php
          label: PHP
          source: |
            <?php

            require 'vendor/autoload.php';

            $shoply = new Shoply\Client(['apiKey' => getenv('SHOPLY_API_KEY')]);

            $result = $shoply->invoices->create([
                'email' => 'buyer@example.com',
                'gateways' => ['stripe'],
                'items' => [],
            ]);
        - lang: python
          label: Python
          source: >
            import shoply


            client = shoply.Client()  # reads SHOPLY_API_KEY


            result = client.invoices.create(email="buyer@example.com",
            gateways=["stripe"], items=[])
components:
  parameters:
    IdempotencyKey:
      name: Idempotency-Key
      in: header
      required: false
      description: >-
        A word of your own for this one change, up to 180 letters, digits, dots,
        dashes, underscores and colons. Sent again with the same key, the
        request is not carried out twice: the first answer comes back, with
        `Idempotent-Replay: true`.
      schema:
        type: string
  schemas:
    Envelope:
      type: object
      properties:
        success:
          type: boolean
          description: Whether the request did what was asked.
        message:
          type:
            - string
            - 'null'
          description: Words for a person. Empty when it worked.
        code:
          type:
            - string
            - 'null'
          description: >-
            Why it was refused, as a word that does not change. Empty when it
            worked.
        data:
          description: 'The thing asked for: an object, or for a list its rows.'
        pages:
          type: integer
          description: 'For a paged list: how many pages there are.'
        total:
          type: integer
          description: 'For a paged list: how many rows there are in all.'
        meta:
          type: object
          description: Anything else the route answers beside the thing itself.
      required:
        - success
        - message
        - code
        - data
    Refusal:
      type: object
      properties:
        success:
          type: boolean
          example: false
        message:
          type: string
          description: What is wrong, in words for a person.
        code:
          type: string
          description: What is wrong, as a word that does not change.
        data:
          nullable: true
        errors:
          type: object
          description: >-
            For `validation_failed`: what is wrong with each field, by the
            field's name.
          additionalProperties:
            type: string
      required:
        - success
        - message
        - code
  responses:
    NoKey:
      description: >-
        No API key was sent, or the one sent is not a live key:
        `api_key_required`, `invalid_api_key`.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Refusal'
    NotAllowed:
      description: >-
        The key is real and may not do this: `missing_scope` (with
        `requiredScope`), `ip_not_allowed`, `account_unavailable`, or
        `dashboard_only` for something only a person in the dashboard may do.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Refusal'
    NotFound:
      description: >-
        There is no such thing in this store: `not_found`. A store that is not
        the key's own is answered the same way.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Refusal'
    Refused:
      description: >-
        The request was understood and not carried out. `validation_failed` says
        what is wrong with each field under `errors`; other codes are the
        route's own.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Refusal'
    TooMany:
      description: >-
        The key has used up its budget for now: `rate_limited`. `Retry-After`
        says how many seconds to wait.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Refusal'
  securitySchemes:
    apiKey:
      type: http
      scheme: bearer
      description: >-
        A secret API key, made under Developers in the dashboard:
        `Authorization: Bearer shoply_sk_...`

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.