openapi: 3.0.0
servers:
  - url: https://sandbox.przelewy24.pl
    description: Sandbox server (uses test data)
  - url: https://secure.przelewy24.pl
    description: Production server (uses live data)
info:
  x-logo:
    url: "getfile/przelewy24-logo_mini.png"
    altText: LogoP24
  contact:
    name: Przelewy24 Support
    url: https://www.przelewy24.pl/support    
  title: Przelewy24 REST API Dokumentacja
  description: >


  version: 1.0.17
x-tagGroups:
  - name: Integracja
    tags:
      - System płatności
      - Authentication
      - Środowisko produkcyjne i sandbox
      - Wytyczne API
      - Przypadki użycia
      - Definicje
      - Materiały graficzne
  - name: Obsługa transakcji
    tags:
      - Transaction service API
      - Notification
      - Calculating Sign
  - name: Dodatkowe usługi
    tags:
      - Additional API functionality
      - RefundNotification
      - Przypadki użycia metod płatności
  - name: Płatność kartą
    tags:
      - Card Description
      - Card API
      - Card Notification
  - name: BLIK
    tags:
      - BLIK Use Cases
      - BLIK API
      - BLIK Additional
      - Alias Update Notification
  - name: Raporty
    tags:
      - Raport API
  - name: Google Pay
    tags:
      - GPay Description
      - GPay API
  - name: Apple Pay
    tags:
      - APay Description
      - APay API
  - name: Jak zintegrować raty? 
    tags:
      - Buttony i bannery
      - Widget
      - Symulator      

paths:
   /api/v1/transaction/register:
    post:
      tags:
        - Transaction service API
      summary: Rejestracja transakcji
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/TransactionRequestBody1"
        description: Przed wysłaniem żądania transakcji należy zapisać jej dane do lokalnej bazy danych sprzedawcy. W szczególności należy zachować informacje o identyfikatorze     sesji i kwocie transakcji. <br><br><hr>
          <h3>Przekierowanie do panelu transakcyjnego</h3>
          Adres URL https://secure.przelewy24.pl/trnRequest/{TOKEN}<br><br>
          gdzie {TOKEN} został pobrany w wyniku zarejestrowania transakcji.<br>
          <hr><br>

          Po poprawnej transakcji zostaje wywoływany adres URL przekazany w procesie rejestracji transakcji w parametrze <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b>"urlStatus"</b></a>. Powiadomienie następuje niezależnie od tego, czy Klient został przekierowany na <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b>"urlReturn"</b></a>, czy też nie. Powiadomienie zostaje wysłane tylko i wyłącznie dla poprawnej wpłaty. System nie wysyła informacji o transakcjach, które nie zostały wykonane, bądź zostały wykonane niepoprawnie. Notyfikacja wysyłana jest w formacie JSON. <br/><br/>

          <a href="#tag/Notification"><font color = "red"><b>Zobacz JSON wyniku transakcji</b></font></a>

        required: true
      responses:
        "200":
          description: successful operation
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/TransactionRegistrationResponse"
        "400":
          description: bad request
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/InvalidInputData"
        "401":
          description: not authorized
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/UnauthorizedResponse"
      security:
        - basicAuth: []
   /api/v1/transaction/verify:
    put:
      tags:
        - Transaction service API
      summary: Weryfikacja transakcji
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/TransactionVerificationBody"
        description: Po odebraniu powiadomienia, system Partnera powinien wykonać dodatkową operację mającą na celu potwierdzenie przyjęcia wpłaty oraz potwierdzenie autentyczności    powiadomienia. Konieczne jest wykonanie weryfikacji transakcji za pomocą metody transaction/verify.<br><br>
          **Ważne!**  Transakcja zostaje uznana za potwierdzoną po jej weryfikacji. Jeżeli klient dokona transakcji, wróci na stronę sprzedawcy, ale sprzedawca nie zweryfikuje transakcji, dana kwota nie zostanie przekazana sprzedawcy ani uwzględniona w rozliczeniach. Pozostanie ona do dyspozycji klienta w formie przedpłaty.
      responses:
        "200":
          description: successful operation
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/TransactionVerificationResponse"
        "400":
          description: bad request
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/InvalidInputData"
        "401":
          description: not authorized
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/UnauthorizedResponse"
      security:
        - basicAuth: []


   /api/v1/testAccess:
    get:
      tags:
        - Additional API functionality
      summary: Test Access
      description: Test połączenia. REST korzysta ze standardu autoryzacji  <a href="#section/Authentication"><b>"basicAuth"</b></a>, gdzie login i hasło to, odpowiednio, ID konta w P24 i klucz API (klucz do raportów) uzyskany z sekcji “Moje dane”.
      responses:
        "200":
          description: OK
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/TransactionTestAccess200"
        "400":
          description: Bad Request
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/InvalidInputData"
        "401":
          description: Unauthorized
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/UnauthorizedResponse"
      security:
        - basicAuth: []
   /api/v1/payment/methods/{lang}?amount=150&currency=PLN:
    get:
      tags:
        - Additional API functionality
      summary: Metody płatności
      description: Metoda zwraca listę dostępnych metod płatności.
      parameters:
        - name: lang
          in: path
          description: "Kod wybranego języka. Dostępne: pl , en"
          required: true
          schema:
            type: string
            enum:
              - pl
              - en
        - in: query
          name: amount
          schema:
            type: integer
          description: Kwota transakcji.<br> Parametr pozwala zweryfikować czy dana metoda płatności jest dostępna dla konkretnej kwoty.
          required: false
        - in: query
          name: currency
          schema:
            type: string
            default: PLN
          description: Wartość waluty zgodna z ISO np. PLN
          required: false
      responses:
        "200":
          description: Lista metod płatności
          content:
            application/json:
              schema:
                properties:
                  data:
                    type: array
                    description: Lista metod
                    items:
                      $ref: "#/components/schemas/PaymentMethodsResponseMethod"
                  agreements:
                    type: array
                    description: Lista umów
                  responseCode:
                    type: string
                    default: ""
                type: object
        "403":
          description: Not authorized.
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/UnauthorizedResponse"
        "404":
          description: Payment methods not found
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/BasicResponse"
      security:
        - basicAuth: []
   /api/v1/transaction/refund:
    post:
      tags:
        - Additional API functionality
      summary: Zwrot transakcji
      description: Zwróć jedną lub wiele transakcji.
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/TransactionRefundJsonRequestBody'
        description: 'Parametr ''refunds'' może zawierać wiele zwrotów.'
        required: true
      responses:
        "201":
          description: 'Created. Parametr ''data'' zawiera wszystkie zwroty.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TransactionRefund201'
        "400":
          description: 'Invalid input data'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InvalidInputDataRefund'
        "401":
          description: 'Not authorized'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnauthorizedResponse'
        "409":
          description: 'Conflict'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TransactionRefund409'
        "500":
          description: 'Unknown error'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Refund500Response'
      security:
        - basicAuth: []
   /api/v1/transaction/registerOffline:
    post:
      description: Ta metoda umożliwia rejestrowanie płatności offline. Aby skorzystać z tej metody, w pierwszej kolejności trzeba zarejestrować standardową transakcję płatniczą z użyciem metody <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b>transaction/register</b></a>.<br><br> Dodatkowo można kontrolować, w którym banku zostanie wykonana płatność, za pomocą parametru <b>method</b>.
      tags:
        - Additional API functionality
      summary: Rejestracja transakcji offline
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/TransactionRegisterOfflineRequest"
          application/x-www-form-urlencoded:
            schema:
              $ref: "#/components/schemas/TransactionRegisterOfflineRequest"
        description: Input parameters.
        required: true
      responses:
        "200":
          description: Successful response
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/TransactionRegistrationOffline200"
        "400":
          description: Invalid input data
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/InvalidInputData"
        "401":
          description: Not authorized
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/UnauthorizedResponse"
        "409":
          description: Conflict
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/TransactionRegistrationOffline409"
        "500":
          description: Undefined error
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ErrorCodeResponse"
      security:
        - basicAuth: []
   /api/v1/transaction/register/splitpayment:
    post:
      description: Obciążanie płatności w trybie Split Payment odbywa się z wykorzystaniem uprzednio zarejestrowanego tokenu w procesie analogicznym do <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b>transaction/register</b></a>. Podczas rejestracji tokenu, należy dodać obiekt <b>splitPaymentDetails</b>, charakterystyczny dla tej formy wykonania transakcji.
      tags:
        - Additional API functionality
      summary: Split Payment
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/TranstactionSplitPayment"
        description: Array
      responses:
        "200":
          description: Successful operation
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/TransactionRegistrationResponse"
        "400":
          description: Bad request
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/InvalidInputData"
        "401":
          description: Not authorized
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/UnauthorizedResponse"
      security:
        - basicAuth: []
   '/api/v1/refund/by/orderId/{orderId}':
    get:
      tags:
        - Additional API functionality
      summary: Dane zwrotu dla OrderID
      description: Uzyskaj szczegóły zwrotu na podstawie ID zamówienia.
      consumes:
        - application/json
        - application/x-www-form-urlencoded
      parameters:
        -
          name: orderId
          in: path
          description: 'Id zamówienia dla istniejącego zwrotu'
          required: true
          type: integer
          format: int64
      responses:
        "200":
          description: 'Żądanie zostało pomyślnie przetworzone. Parametr ''data'' zawiera dane zwrotu.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TransactionRefundsInfoResponse'
        "401":
          description: 'Not authorized'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnauthorizedResponse'
        "404":
          description: 'Refund with given Order Id not found'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TransactionNotFoundResponse'
        "500":
          description: 'Undefined error'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorCodeResponse'
      security:
        - basicAuth: []
   '/api/v1/transaction/by/sessionId/{sessionId}':
    get:
      tags:
        - Additional API functionality
      summary: Dane o transakcji poprzez sessionID
      description: Metoda zwraca informacje o transakcji na podstawie pola “sessionId”.
      consumes:
        - application/json
        - application/x-www-form-urlencoded
      parameters:
        -
          name: sessionId
          in: path
          description: 'Unikalny identyfikator transakcji z systemu sprzedawcy'
          required: true
          type: string
      responses:
        "200":
          description: 'OK'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TransactionBySessionIdSuccessResponse'
        "400":
          description: 'Invalid input data'
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/InvalidInputData"
        "401":
          description: 'Incorrect authentication'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnauthorizedResponse'
        "404":
          description: 'Transaction not exist'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TransactionNotFoundResponse'
      security:
        - basicAuth: []

   /api/v1/report/history:
    get:
      tags:
        - Raport API
      summary: Historia transakcji
      description: '<div id="note" style="padding: 7px;">Aby włączyć taką funkcjonalność należy skontaktować się z opiekunem handlowym poprzez <a href="https://www.przelewy24.pl/centrum-pomocy/sprzedaje-z-przelewy24/metody-platnosci-konto/brakuje-odpowiedzi-na-twoje-pytanie"><b>formularz kontaktowy</b></a></div><br/>Metoda zwraca informacje na temat: paczek (batch), transakcji i zwrotów, w zadanym okresie czasu.<h2>Stronicowanie</h2> Aby wywołać nastepna stronę, należy wysłać żądanie <b>report/history</b> z parametrem <b>token</b>, np.:<br/><table border="0 px"><tr><th bgcolor="#0f6ab4"><font color="white"><b>GET</b></font></th><th bgcolor="E7F0F7"><a href="	https://secure.przelewy24.pl/api/v1/report/history/{token}">	https://secure.przelewy24.pl/api/v1/report/history/{token}</a></th></tr></table>'
      parameters:
        - name: dateFrom
          in: path
          description: Data w formacie YYYYMMDD
          required: true
          schema:
            type: string
        - name: dateTo
          in: path
          description: Data w formacie YYYYMMDD. Maksymalny okres czasu to 31 dni
          required: true
          schema:
            type: string
        - name: type
          in: path
          description: 'Typ obiektów do załadowania. Omiń ten parametr, jeśli chcesz pobrać wszystkie dane. Akceptowane wartości: batch, transaction, refund.'
          required: false
          schema:
            type: string
      responses:
        "200":
          description: OK
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/HistoryResponse200Body"
        "400":
          description: Bad request
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/HistoryError400Body"
        "401":
          description: Not authorized
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/GeneralErrorResponse"
        "500":
          description: Undefined error
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/GeneralErrorResponse"
      security:
        - basicAuth: []

   /api/v1/report/batch/details:
    get:
      tags:
        - Raport API
      summary: Informacje o paczce (batch)
      description: '<div id="note" style="padding: 7px;">Aby włączyć taką funkcjonalność należy skontaktować się z opiekunem handlowym poprzez <a href="https://www.przelewy24.pl/centrum-pomocy/sprzedaje-z-przelewy24/metody-platnosci-konto/brakuje-odpowiedzi-na-twoje-pytanie"><b>formularz kontaktowy</b></a></div><br/> Metoda zwraca wszystkie transakcje i zwroty opłacone w zadanej paczce (batch).<br/><h2>Stronicowanie</h2>Aby wywołać następną strone należy wywołać żądanie <b>report/batch/details</b> z parametrem <b>token</b> np.:<table><tr><th bgcolor="#0f6ab4"><font color="white"><b>GET</b></font></th><th bgcolor="E7F0F7"><a href="	https://secure.przelewy24.pl/api/v1/report/batch/details/{token}">https://secure.przelewy24.pl/api/v1/report/batch/details/{token}</a></th></tr></table>'
      parameters:
        - name: batch
          in: path
          description: Unikalne ID paczki
          required: true
          schema:
            type: integer
        - name: token
          in: path
          description: Token potrzebny do wywołania następnej strony
          required: false
          schema:
            type: string
      responses:
        "200":
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BatchDetails200ResponseBody'
        "400":
          description: Bad request
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/BatchDetailsError400Body"
        "401":
          description: Not authorized
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/GeneralErrorResponse"
        "500":
          description: Undefined error
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/GeneralErrorResponse"
      security:
        -
          basicAuth: []        

   /api/v1/paymentMethod/blik/chargeByCode:
    post:
      tags:
        - BLIK API
      summary: 'BLIK charge by code'
      description: Umożliwia obciążenie transakcji za pomocą kodu T6. Zwraca unikalny identyfikator transakcji.
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/RecurringParams"
      responses:
        "201":
          description: Created
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/BlikChargeByCodeResponse"
        "400":
          description: Invalid input data
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/InvalidInputData"
        "401":
          description: not authorized
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/UnauthorizedResponse"
        "500":
          description: Undefined error
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ErrorCodeResponse"
      security:
        - basicAuth: []
   /api/v1/paymentMethod/blik/chargeByAlias:
    post:
      tags:
        - BLIK API
      summary: BLIK charge by Alias
      description: ChargeByAlias to metoda płatności typu one-click. Pozwala na obciążenie środków klienta, korzystając z uprzednio pozyskanego aliasu (**getAliasesByEmail**). Pozyskany alias musi zostac przekazany w parametrze <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b>methodRefId</b></a> podczas rejestracji transakcji
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/BlikOneClick"
      responses:
        "201":
          description: Created
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/BlikChargeByCodeResponse"
        "400":
          description: Bad request
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/InvalidInputData"
        "401":
          description: Not authorized
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/UnauthorizedResponse"
        "409":
          description: AlternativeKeys
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ChargeByAlias409"
        "500":
          description: Undefined error
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ErrorCodeResponse"
      security:
        - basicAuth: []
   /api/v1/paymentMethod/blik/getAliasesByEmail/{email}:
    get:
      tags:
        - BLIK API
      summary: Getting Aliases ByEmail
      description: Aby uzyskać alias do kolejnych płatności, skorzystaj z metody
                    <b>"getAliasesByEmail" </b><br><br>
                    Metoda zwraca listę aliasów (wraz z typem i statusem) utworzonych dla danego adresu e-mail w zakresie danego merchanta.
      parameters:
        - name: email
          in: path
          description: Dla aliasów zarejestrowanych poprzez e-mail
          required: true
      responses:
        "200":
          description: OK
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Transaction200Blik"
        "400":
          description: Bad Request
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/InvalidInputData"
        "401":
          description: Unauthorized
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/UnauthorizedResponse"
        "404":
          description: 'Alias not found'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TransactionNotFoundResponse'
      security:
        - basicAuth: []
   /api/v1/paymentMethod/blik/getAliasesByEmail/{email}/custom:
    get:
      tags:
        - BLIK API
      summary: Getting Aliases ByEmail (Custom)
      description: Aby uzyskać alias do kolejnych płatności, skorzystaj z metody
                    <b>"getAliasesByEmail" </b><br><br>
                    Metoda zwraca listę aliasów (wraz z typem i statusem) utworzonych dla danego adresu e-mail w zakresie danego merchanta.
      parameters:
        - name: email
          in: path
          description: Dla aliasów zarejestrowanych z wartościami <b><i><b>"aliasValue"</b></b></i> i <b><i><b>"aliasLabel"</b></b></i>
          required: true
      responses:
        "200":
          description: OK
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Transaction200Blik"
        "400":
          description: Bad Request
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/InvalidInputData"
        "401":
          description: Unauthorized
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/UnauthorizedResponse"
        "404":
          description: 'Alias not found'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TransactionNotFoundResponse'
      security:
        - basicAuth: []
  

   "/api/v1/card/info/{orderId}":
    get:
      tags:
        - Card API
      summary: Card info
      parameters:
        - name: orderId
          in: path
          description: Unikalne ID zamówienia.
          required: true
          schema:
            type: integer
            format: int64
      description: Metoda zwraca informację na temat danej karty płatniczej na podstawie poprzedniej płatności. Włączając numer referencyjny do obciążenia kart bez autoryzacji CVV.
      responses:
        "200":
          description: Success
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/cardinfores"
        "400":
          description: Wrong input data
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ErrorCodeResponse"
        "403":
          description: Not authorized
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/UnauthorizedResponse"
        "404":
          description: Transaction not exists
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ErrorCodeResponse"
      security:
        - basicAuth: []
   /api/v1/card/chargeWith3ds:
    post:
      tags:
        - Card API
      summary: Charge card with 3DS
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/CardChargeRequestBody"
      description: Metoda umożliwia obciążenie karty na podstawie numeru referencyjnego.
      responses:
        "200":
          description: The charge card command has been accepted - notification will be
            send on success.
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ChargeCard3dsSuccessResponse"
        "201":
          description: The card payment requires 3DS redirection
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ChargeCard3dsSuccessResponse"
        "400":
          description: Invalid input data
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/InvalidInputData"
        "401":
          description: Not authorized
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/UnauthorizedResponse"
      security:
        - basicAuth: []
   /api/v1/card/charge:
    post:
      tags:
        - Card API
      summary: Charge card
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/CardChargeRequestBody"
      description: Metoda umożliwia obciążenie karty na podstawie numeru referencyjnego.
      responses:
        "200":
          description: The charge card command has been accepted - notification will be
            send on success.
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ChargeCardSuccessResponse"
        "400":
          description: Invalid input data
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/InvalidInputData"
        "401":
          description: Not authorized
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/UnauthorizedResponse"
      security:
        - basicAuth: []
   /api/v1/card/pay:
    post:
      tags:
        - Card API
      summary: Card Payment
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/CardRegisterRequestBody"
      description: Metoda służy do obciążenia karty klienta. Metoda przesyła dane kartowe bezpośrednio.
      responses:
        "200":
          description: The card payment has been succesed.
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/CardPaySuccessResponse"
        "201":
          description: The card payment requires 3DS redirection.
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/CardPayThreeDSecureResponse"
        "400":
          description: Invalid input data
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/InvalidInputData"
        "401":
          description: Not authorized
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/UnauthorizedResponse"
        "409":
          description: Conflict
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/CardPayResponse409"
      security:
        - basicAuth: []



   /bundle/payWithGoogle/{TOKEN}:
    get:
      tags:
        - GPay API
      summary: Przekazanie tokenu
      servers:
      - url: https://secure.przelewy24.pl
        description: Production server (uses live data)
      consumes:
        - application/json
        - application/x-www-form-urlencoded
      parameters:
        -
          name: TOKEN
          in: path
          description: Token uzyskany z Przelewy24.
      description:
        Po otrzymaniu tokenu z Przelewy24 należy na stronie wywołać skrypt w Javascript.<br><br>

        Po wykonaniu transakcji wywoływana jest odpowiednia odpowiedź zwrotna (callback).

        W przypadku transakcji wymagającej dodatkowej autoryzacji (3DSecure) klient zostaje przekierowany, a następnie wraca na adres podany przy rejestracji transakcji w parametrze  <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b>"urlReturn"</b></a>.
      x-codeSamples:
          - lang: HTML
            source: |
              <head>
                <meta charset="UTF-8">
                <meta name="viewport"
                      content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
                <meta http-equiv="X-UA-Compatible" content="ie=edge">
                <title>PayWithGoogle</title>
                <script src="https://secure.przelewy24.pl/bundle/payWithGoogle/{{TOKEN}}"></script>
              </head>
              <body>
              <script>
                document.addEventListener("DOMContentLoaded", function () {
                    Przelewy24PayWithGoogle.config({
                        errorCallback: function () {
                            alert("error");
                        },
                        exceptionCallback: function () {
                            alert("exception");
                        },
                        requestFailedCallback: function () {
                            alert('requestFailed');
                        },
                        completePaymentCallback: function () {
                            alert("success");
                        }
                    });
                    Przelewy24PayWithGoogle.charge();
                });
              </script>
              </body>

   /bundle/applepay/{TOKEN}:
    get:
      tags:
        - APay API
      summary: Przekazanie tokenu
      servers:
      - url: https://secure.przelewy24.pl
        description: Production server (uses live data)
      consumes:
        - application/json
        - application/x-www-form-urlencoded
      parameters:
        -
          name: TOKEN
          in: path
          description: Token uzyskany z Przelewy24.
      description:
        Po otrzymaniu tokenu z Przelewy24 należy na stronie wywołać skrypt w JS.<br><br>

        Skrypt w Java Script procesuje transakcje, po jej wykonaniu wywoływana jest odpowiednia odpowiedź zwrotna (callback).
      x-codeSamples:
          - lang: HTML
            source: |
                <head>
                    <meta charset="UTF-8">
                    <meta name="viewport"
                          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
                    <meta http-equiv="X-UA-Compatible" content="ie=edge">
                    <title>Apple Pay</title>
                    <script src="https://secure.przelewy24.pl/bundle/applepay/{{TOKEN}}"></script>
                </head>
                <body>
                <script>
                    document.addEventListener("DOMContentLoaded", function () {
                      Przelewy24ApplePay.config({
                        errorCallback: function () {
                            alert("error");
                        },
                        exceptionCallback: function () {
                            alert("exception");
                        },
                        requestFailedCallback: function () {
                            alert('requestFailed');
                        },
                        completePaymentCallback: function () {
                            alert("success");
                        }
                      });
                    Przelewy24ApplePay.charge();
                    });
                  </script>

                  </body>



####components######
components:
  securitySchemes:
   basicAuth:
      description: Jest to podstawowa metoda uwierzytelnienia. User i secretId dostępne są w panelu:<br/>- "User" odpowiada tej samej wartości, co posId,</br>- secretId, odpowiada tej samej wartości co klucz do raportów (klucz do API).
      type: http
      scheme: basic
  schemas:
    TransactionVerificationResponse:
      properties:
        data:
          properties:
            status:
              type: string
              default: success
          type: object
        responseCode:
          type: number
          default: 0
    TransactionVerificationBody:
      properties:
        merchantId:
          description: ID Sklepu
          type: integer
        posId:
          description: ID Sklepu (domyślnie ID Sprzedawcy)
          type: integer
        sessionId:
          description: Unikalny identyfikator z systemu sprzedawcy
          type: string
          maxLength: 100
        amount:
          description: Kwota transakcji wyrażona w groszach, np. 1.23 PLN = 123
          type: integer
        currency:
          description: Waluta
          type: string
          maxLength: 3
          default: "PLN"
        orderId:
          description: Id zamówienia z systemu Przelewy24
          type: integer
          format: int64
        sign:
          description: Suma kontrolna parametrów:<br>
            {<font color = "brown">"sessionId":</font>"str",<font color = "brown">"orderId":</font>int,<font color = "brown">"amount":</font>int,<font color = "brown">"currency":</font>"str",<font color = "brown">"crc":</font>"str"}
            <br><br>liczona z użyciem sha384<br><br> <b><font color = "#DB2053">WAŻNE!:</font></b><br> przy wykorzystaniu funkcji json_encode należy dodać następujące atrybuty
            <br> "JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES"
          type: string
      required:
        - posId
        - sessionId
        - amount
        - currency
        - orderId
        - sign
        - merchantId
    AvailabilityHoursResponse:
      properties:
        mondayToFriday:
          type: string
        saturday:
          type: string
        sunday:
          type: string
    TransactionRequestBody1:
      type: object
      properties:
        merchantId:
          name: merchantId
          in: formData
          description: ID Sklepu
          type: integer
        posId:
          name: posId
          in: formData
          description: ID Sklepu (domyślnie ID Sprzedawcy)
          type: integer
        sessionId:
          name: sessionId
          in: formData
          description: Unikalny identyfikator z systemu sprzedawcy
          type: string
          maxLength: 100
        amount:
          name: amount
          in: formData
          description: Kwota transakcji wyrażona w groszach, np. 1.23 PLN = 123
          type: integer
        currency:
          name: currency
          in: formData
          description: Wartość zgodna z ISO np. PLN
          type: string
          maxLength: 3
        description:
          name: description
          in: formData
          description: Opis transakcji
          type: string
          maxLength: 1024
        email:
          name: email
          in: formData
          description: Email Klienta
          type: string
          maxLength: 50
        client:
          name: client
          in: formData
          description: Imię i nazwisko Klienta
          type: string
          maxLength: 40
        address:
          name: address
          in: formData
          description: Adres Klienta
          type: string
          maxLength: 80
        zip:
          name: zip
          in: formData
          description: Kod pocztowy Klienta
          type: string
          maxLength: 10
        city:
          name: city
          in: formData
          description: Miasto Klienta
          type: string
          maxLength: 50
        country:
          name: country
          in: formData
          description: Kody krajów zgodnie ISO, np. PL, DE itp
          type: string
          maxLength: 2
          default: PL
        phone:
          name: phone
          in: formData
          description: Telefon klienta w formacie 481321132123
          type: string
          maxLength: 12
        language:
          name: language
          in: formData
          description: "Jeden z następujących kodów krajów zgodnie z normą ISO 639-1: bg, cs, de, en, es, fr, hr, hu, it, nl, pl, pt, se, sk, ro"
          type: string
          maxLength: 2
          default: pl
        method:
          name: method
          in: formData
          description: Identyfikator metody płatności. Lista metod płatności widoczna w panelu lub dostępna przez API
          type: integer
        urlReturn:
          name: urlReturn
          in: formData
          description: Adres powrotny po zakończeniu transakcji
          type: string
          maxLength: 250
        urlStatus:
          name: urlStatus
          in: formData
          description: Adres do przekazania statusu transakcji
          type: string
          maxLength: 250
        timeLimit:
          name: timeLimit
          in: formData
          description: Limit czasu na wykonanie transakcji, 0 - brak limitu, maks. 99 (w minutach)
          type: integer
        channel:
          name: channel
          description: "
                      1 - karty + ApplePay + GooglePay,
                      2 - przelewy,
                      4 - przelew tradycyjny,
                      8 -
                                  N/A,
                      16 - wszystkie 24/7 – udostępnia wszystkie metody płatności,
                      32 -
                                  użyj przedpłatę,
                      64 – tylko metody pay-by-link,
                      128 –
                                  formy ratalne,
                      256 – wallety, 
                      4096 - karty,
                      8192 - blik,
                      16384 - wszystkie metody z wyłączeniem blika

                      <p>Aby uruchomić
                                  poszczególne kanały, nalezy zsumowac ich wartości.


                      <p>Przykład:

                      przelewy i przelew tradycyjny:
                                  channel=6"
          type: integer
          enum:
            - 1
            - 2
            - 4
            - 8
            - 16
            - 32
            - 64
            - 128
            - 256
            - 4096
            - 8192
            - 16384
        waitForResult:
          type: boolean
          description: Parametr determinuje, czy użytkownik zostanie przekierowany z powrotem do sklepu od razu po wykonaniu płatności, czy dopiero, gdy dotrze wynik transakcji (z potwierdzeniem płatności).  <a href="#section/Przypadki-uzycia/Jak-umozliwic-plynny-powrot-klienta-do-sklepu-bez-koniecznosci-oczekiwania-na-synchroniczne-potwierdzenie-platnosci"><b>Przeczytaj więcej</b></a>
        regulationAccept:
          type: boolean
          description: 'Akceptacja regulaminu Przelewy24: <br/>false – wyświetl zgodę na stronie p24 (domyślna),<br/>true – akceptacja dokonana, nie wyświetlaj.<br/>W przypadku wysyłania parametru „true”, na stronie Partnera musi znaleźć się zgoda o treści: „Oświadczam, że zapoznałem się z [regulaminem](https://www.przelewy24.pl/regulamin) i [obowiązkiem informacyjnym](https://www.przelewy24.pl/obowiazekinformacyjny) serwisu Przelewy24”. <br/>Pod słowami <i>regulamin</i> i <i>obowiązek informacyjny</i> musi być link do stron z tymi dokumentami. Checkbox nie może być odgórnie zaznaczony.'
          default: false
        shipping:
          name: shipping
          in: formData
          description: Koszt dostawy/wysyłki
          type: integer
        transferLabel:
          name: transferLabel
          in: formData
          description: Opis pojawiający się w tytule przelewu. Dozwolone znaki to [a-z A-Z 0-9 ęółśążźćńĘÓŁŚĄŻŹĆŃ . /\ :- ]
          type: string
          maxLength: 20
        mobileLib:
          name: mobileLib
          description: Przesłanie tego parametru jest niezbędne przy wykorzystaniu bibliotek SDK. W <b>mobileLib</b> należy przesłać wartość 1, natomiast w parametrze <b>sdkVersion</b> należy wskazać wersję biblioteki, z której chcemy skorzystać.
          type: integer
          enum:
            - 1
        sdkVersion:
          name: sdkVersion
          in: formData
          description: Wersja bibliotek mobilnych. Określa czy transakcja jest mobilna.
          type: string
          maxLength: 10
        sign:
          name: sign
          in: formData
          type: string
          maxLength: 100
          description: <br>Suma kontrolna parametrów:<br>
            {<font color = "brown">"sessionId":</font>"str",<font color = "brown">"merchantId":</font>int,<font color = "brown">"amount":</font>int,<font color = "brown">"currency":</font>"str",<font color = "brown">"crc":</font>"str"}
            <br><br> liczona z użyciem sha384<br><br> <b><font color = "#DB2053">WAŻNE!:</font></b><br>  przy wykorzystaniu funkcji json_encode należy dodać następujące atrybuty <br> "JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES"
        encoding:
          name: encoding
          in: formData
          description: "System kodowania przesyłanych znaków: ISO-8859-2, UTF-8, Windows-1250"
          type: string
          maxLength: 15
        methodRefId:
          name: methodRefId
          in: formData
          description: Specjalny parametr wymagany dla niektórych procesów płatności, np. BLIK i Karty one-click.
          type: string
          maxLength: 250
        cart:
          description: Koszyk
          items:
            $ref: "#/components/schemas/CartParameters"
        additional:
          type: object
          description: Zbiór dodatkowych danych nt. transakcji i płatnika
          allOf:
            - $ref: "#/components/schemas/AdditionalProperties"  
      required:
        - merchantId
        - posId
        - sessionId
        - amount
        - currency
        - description
        - email
        - country
        - language
        - urlReturn
        - ttl
        - sign
    AdditionalProperties:
      properties:
         shipping:
              type: object
              description: Dodatkowe dane dostawy
              properties:
                type:
                  type: integer
                  description: Typ dostawy:<br/> 0 - kurier<br/>1 - dostawa do punktu<br/>2 - paczkomat<br/>3 - paczka w sklepie
                  enum:
                    - 0
                    - 1
                    - 2
                    - 3
                address:
                  type: string
                  description: 'Adres dostawy: ulica i numer'
                zip:
                  type: string
                  description: Kod pocztowy
                city:
                  type: string
                  description: Miasto adresu dostawy
                country:
                  type: string
                  description: Kraj adresu dostawy
              required:
               - type
               - address
               - zip
               - city
               - country
         PSU:
          type: object
          description: >
                Payment Service User<br>
                <b><font color = "#DB2053">WAŻNE!:</font></b><br>
                Obiekt wymagany przy wykorzystaniu metod <b><a href="#tag/BLIK-API/paths/~1api~1v1~1paymentMethod~1blik~1chargeByCode/post">blikChargeByCode</a></b> lub <b><a href="#tag/BLIK-API/paths/~1api~1v1~1paymentMethod~1blik~1chargeByAlias/post">blikChargeByAlias</a></b>.
          properties:
            IP:
              type: string
              description: IPv4 lub IPv6
            userAgent:
              type: string
              maxLength: 255
              description: userAgent to ciąg identyfikujący przeglądarkę i system operacyjny.
    TransactionRegistrationResponse:
      properties:
        data:
          properties:
            token:
              type: string
          type: object
        responseCode:
          type: number
          default: 0

    Transaction200Blik:
      properties:
        data:
          description: Tablica obiektów związanych z aliasem BLIK
          items:
            $ref: "#/components/schemas/BlikAlias200"
        responseCode:
          type: integer
          description: Kod odpowiedzi
          default: 0

    BlikAlias200:
      properties:
        value: 
          type: string
          description: Wartość aliasu
        type:
          type: string
          description: Typ aliasu
        status:
          type: string
          description: Status aliasu
        expirationDate:
          type: string
          description: Data ważności aliasu

    InvalidInputData:
      properties:
        error:
          type: string
          default: Invalid input data
          example: Invalid input data
        code:
          type: number
          default: 400
          example: 400
    UnauthorizedResponse:
      properties:
        error:
          type: string
          default: Incorrect authentication
          example: Incorrect authentication
        code:
          type: number
          default: 401
          example: 401
    TransactionTestAccess200:
      properties:
        data:
          type: boolean
          default: true
        error:
          type: string
    PaymentMethodsResponse:
      properties:
        name:
          type: string
          description: Name of payment method
        id:
          type: integer
          description: Payment method ID
        status:
          type: boolean
          description: Specifies whether a given method is active
        imgUrl:
          type: string
          description: Link do grafiki
        mobileImgUrl:
          type: string
          description: Link do grafiki mobilnej
        mobile:
          type: boolean
          description: Czy forma płatności jest dostępna mobilnie
        availabilityHours:
          $ref: "#/components/schemas/AvailabilityHoursResponse"
    BasicResponse:
      properties:
        data:
          type: array
          default: Payment methods not found
          items:
            type: string
            default: Payment methods not found
        responseCode:
          default: 404
          type: number
    TransactionRefundJsonRequestBody:
      properties:
        requestId:
          type: string
          description: Indywidualne ID żądania
          maxLength: 45
        refunds:
          type: array
          items:
            $ref: "#/components/schemas/RefundRequestArrayDataBasic"
        refundsUuid:
          type: string
          description: Indywidualne ID dla poprawnego żądania zwrotu w systemie Merchanta
          maxLength: 35
        urlStatus:
          type: string
          description: Adres do przekazania danych zwrotów
      required:
        - requestId
        - refunds
        - refundsUuid
    RefundRequestArrayDataBasic:
      properties:
        orderId:
          type: integer
          format: int64
          description: ID zamówienia zwracanej transakcji z systemu Przelewy24
        sessionId:
          type: string
          description: session ID zwracanej transakcji z systemu Partnera
        amount:
          type: integer
          description: Kwota zwrotu
        description:
          type: string
          description: Opis zwrotu widoczny na przelewie
          maxLength: 35
      type: object
      required:
        - orderId
        - sessionId
        - amount
    TransactionRefund201:
      properties:
        data:
          type: array
          items:
            $ref: "#/components/schemas/TransactionRefund201Item"
        responseCode:
          type: number
          example: 0
    TransactionRefund201Item:
      properties:
        orderId:
          type: integer
          format: int64
          description: ID zamówienia transakcji z systemu Przelewy24
        sessionId:
          type: string
          description: ID sesji transkacji z systemu Partnera
        amount:
          type: integer
          description: Kwota zwrotu
        description:
          type: string
          description: Opis transakcji
        status:
          type: boolean
          example: true
          description: Czy próba zwrotu była udana?
        message:
          type: string
          example: success
          description: Opis tekstowy udanego zwrotu
    InvalidInputDataRefund:
      properties:
        error:
          type: string
          example: Request already exists
          description: Komunikat błędu. Możliwe wartości:<br/><br/>"Invalid input parameters" - w przypadku podania błędnych parametrów lub ich wartości,<br/><br/> "Request already exists" - w przypadku gdy zwrot dla danej transakcji już istnieje,<br/><br/> "Concurent call" - w przypadku powielonego requestu zwrotu.
        code:
          type: number
          default: 400
          example: 400
    TransactionRefund409:
      properties:
        error:
          type: array
          items:
            $ref: "#/components/schemas/TransactionRefund409Item"
        code:
          type: integer
          example: 409
    TransactionRefund409Item:
      properties:
        orderId:
          type: integer
          format: int64
          description: ID zamówienia transakcji z systemu Przelewy24
        sessionId:
          type: string
          description: ID sesji transkacji z systemu Partnera
        amount:
          type: integer
          description: Kwota zwrotu
        description:
          type: string
          description: Opis zwrotu
        status:
          type: boolean
          example: false
          description: Czy próba zwrotu była udana?
        message:
          type: string
          example: The amount of refund exceeds available amount for the transaction
          description: Komunikat błędu. Możliwe wartości:<br/><br/>"Transaction not found" - w przypadku, gdy transakcja nie została odnaleziona, <br/><br/>"Transaction in wrong status - cannot refund" - w przypadku, gdy transakcja jest w niewłaściwym statusie, przez co niemożliwe jest wykonanie zwrotu, <br/><br/>"Insufficient funds available" - w przypadku braku wystarczającyh środków na wykonanie zwrotu, <br/><br/>"The amount of refund exceeds available amount for the transaction" - w przypadku, gdy w żądaniu zwrotu podano kwotę, która przekracza dostępne środki do zwrotu dla danej transakcji
    Refund500Response:
      properties:
        error:
          type: string
          example: Unknown error
          description: Komunikat błędu
        code:
          type: integer
          example: 500
          default: 500
    TransactionRegisterOfflineRequest:
      properties:
        token:
          type: string
    TransactionRegistrationOffline200:
      properties:
        data:
          properties:
            orderId:
              type: integer
              format: int64
              description: Unique transaction ID assigned by P24
            sessionId:
              type: string
              description: Unique ID assigned by the merchant’s system
            amount:
              type: integer
              description: Transaction amount
            statement:
              type: string
              description: Full payment title
            iban:
              type: string
              description: Number of account for payment
            ibanOwner:
              type: string
              description: Name of payment recipient
            ibanOwnerAddress:
              type: string
              description: Address of payment recipient
          type: object
        responseCode:
          type: number
          example: 0
    TransactionRegistrationOffline409:
      properties:
        error:
          type: string
          default: Unable to create offline transaction
          example: Unable to create offline transaction
        code:
          type: number
          example: 409
    ErrorCodeResponse:
      properties:
        error:
          type: string
          example: Undefined error
          default: Undefined error
        code:
          type: integer
          example: 500
          default: 500
      type: object
    TranstactionSplitPayment:
      required:
        - merchantId
        - posId
        - sessionId
        - amount
        - currency
        - descrition
        - email
        - country
        - language
        - urlReturn
        - sign
        - splitPaymentDetails
        - description
      properties:
        merchantId:
          name: merchantId
          in: formData
          description: ID Merchanta
          type: integer
        posId:
          name: posId
          in: formData
          description: ID Sklepu (domyślnie ID merchanta)
          type: integer
        sessionId:
          name: sessionId
          in: formData
          description: Unikalny identyfikator z systemu sprzedawcy
          type: string
          maxLength: 100
        amount:
          name: amount
          in: formData
          description: Kwota transakcji wyrażona w groszach, np. 1.23 PLN = 123
          type: integer
        currency:
          name: currency
          in: formData
          description: Wartość zgodna z ISO np. PLN
          type: string
          maxLength: 3
          default: PLN
        description:
          name: description
          in: formData
          description: Opis transakcji
          type: string
          maxLength: 1024
        email:
          name: email
          in: formData
          description: Email Klienta
          type: string
          maxLength: 50
        client:
          name: client
          in: formData
          description: Imię i nazwisko Klienta
          type: string
          maxLength: 40
        address:
          name: address
          in: formData
          description: Adres Klienta
          type: string
          maxLength: 80
        zip:
          name: zip
          in: formData
          description: Kod pocztowy Klienta
          type: string
          maxLength: 10
        city:
          name: city
          in: formData
          description: Miasto Klienta
          type: string
          maxLength: 50
        country:
          name: country
          in: formData
          description: Kody krajów zgodnie ISO, np. PL, DE itp.
          type: string
          maxLength: 2
          default: PL
        phone:
          name: phone
          in: formData
          description: "Telefon klienta w formacie: 481321132123"
          type: string
          maxLength: 12
        language:
          name: language
          in: formData
          description: "Jeden z następujących kodów krajów zgodnie z normą ISO 639-1: bg, cs, de,
            en, es, fr, hr, hu, it, nl, pl, pt, se, sk, ro"
          type: string
          default: pl
          maxLength: 2
        method:
          name: method
          in: formData
          description: Identyfikator metody płatności. Lista metod płatności widoczna w panelu lub dostępna przez API
          type: integer
        urlReturn:
          name: urlReturn
          in: formData
          description: Adres powrotny po zakończeniu transakcji
          type: string
          maxLength: 250
        urlStatus:
          name: urlStatus
          in: formData
          description: Adres do przekazania statusu transakcji
          type: string
          maxLength: 250
        timeLimit:
          name: timeLimit
          in: formData
          description: Limit czasu na wykonanie transakcji, 0 - brak limitu, maks. 99 (w minutach)
          type: integer
        channel:
          name: channel
          in: formData
          description: "
                      1 - karty + ApplePay + GooglePay,
                      2 - przelew,
                      4 - tradycyjny przelew,
                      8 -
                                  N/A,
                      16 - wszystkie 24/7 – udostępnia wszystkie metody płatności,
                      32 -
                                  uzyj przedpłaty,
                      64 – tylko metody pay-by-link,
                      128 –
                                  formy ratalne,
                      256 – wallety, 
                      4096 - karty
                      8192 - blik
                      16384 - wszystkie metody z wyłączeniem blika

                      <p>Aby uruchomić
                                  poszczególne kanały, nalezy zsumowac ich wartości

                      <p>Przykład:

                      przelewy i przelew tradycyjny:
                                  channel=6"
          type: integer
          enum:
            - "1"
            - "2"
            - "4"
            - "8"
            - "16"
            - "32"
            - "64"
            - "128"
            - "256"
            - "4096"
        shipping:
          name: shipping
          in: formData
          description: Koszt dostawy/wysyłki
          type: integer
        transferLabel:
          name: transferLabel
          in: formData
          description: Opis pojawiający się w tytule przelewu. Dozwolone znaki to [a-z A-Z 0-9 ęółśążźćńĘÓŁŚĄŻŹĆŃ . /\ :- ]
          type: string
          maxLength: 20
        sdkVersion:
          name: sdkVersion
          in: formData
          description: Wersja bibliotek mobilnych. Określa czy transakcja jest mobilna.
          type: string
          maxLength: 10
        sign:
          name: sign
          in: formData
          type: string
          maxLength: 100
          description: <br>Suma kontrolna parametrów:<br>
            {<font color = "brown">"sessionId":</font>"string",<font color = "brown">"merchantId":</font>int,<font color = "brown">"amount":</font>int,<font color = "brown">"currency":</font>"string",<font color = "brown">"crc":</font>"string"}
            <br><br>liczona z użyciem sha384<br><br> <b><font color = "#DB2053">WAŻNE!:</font></b><br> przy wykorzystaniu funkcji json_encode należy dodać następujące atrybuty<br> "JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES"
        encoding:
          name: encoding
          in: formData
          description: "System kodowania przesyłanych znaków: ISO-8859-2, UTF-8, Windows-1250"
          type: string
          maxLength: 15
        cart:
          description: Koszyk
          items:
            $ref: "#/components/schemas/CartParameters"
        methodRefId:
          name: methodRefId
          in: formData
          description: Specjalny parametr wymagany dla niektórych procesów płatności, np. BLIK i Karty one-click.
          type: string
          maxLength: 250
        splitPaymentDetails:
          type: object
          properties:
            vatAmount:
              type: integer
              description: Kwota podatku VAT
            invoiceNumber:
              type: string
              description: Numer faktury
            nip:
              type: string
              description: Numer identyfikacji podatkowej
            iban:
              type: string
              description: Międzynarodowy numer rachunku bankowego IBAN (international bank account number)
          required:
            - vatAmount
            - invoiceNumber
            - nip
    CartParameters:
      description: Cart Parameters
      type: object
      required:
        - sellerId
        - sellerCategory
      properties:
        sellerId:
          type: string
          description: ID Sklepu po stronie Partnera
        sellerCategory:
          type: string
          description: Kategoria sklepu
        name:
          type: string
          description: Nazwa produktu<br/><br/><font color="red">Wymagane dla metody płatności PayPal</font>
        description:
          type: string
          description: Opis produktu<br/><br/><font color="red">Wymagane dla metody płatności PayPal</font>
        quantity:
          type: integer
          description: Ilość produktu<br/><br/><font color="red">Wymagane dla metody płatności PayPal</font>
        price:
          type: integer
          description: Cena produktu<br/><br/><font color="red">Wymagane dla metody płatności PayPal</font>
        number:
          type: string
          description: Numer produktu<br/><br/><font color="red">Wymagane dla metody płatności PayPal</font>
    TransactionRefundsInfoResponse:
      properties:
        data:
          $ref: "#/components/schemas/TransactionWithRefundsResponse"
        responseCode:
          type: number
          example: 0
    TransactionWithRefundsResponse:
      properties:
        orderId:
          type: integer
          format: int64
        sessionId:
          type: string
        amount:
          type: integer
        currency:
          type: string
        refunds:
          type: array
          items:
            $ref: "#/components/schemas/RefundsCollection"
      type: object
    RefundsCollection:
      properties:
        batchId:
          type: integer
        requestId:
          type: string
        date:
          type: string
        login:
          type: string
        description:
          type: string
        status:
          type: integer
          example: 3
          default: 3
          description: 1 - zrealizowany,<br/>2 - oczekuje na realizację,<br/>3 - czeka na akceptację P24,<br/>4 - odrzucony
        amount:
          type: integer
      type: object

    PaymentMethodsResponseMethod:
      properties:
        name:
          type: string
          description: Nazwa metody płatności
        id:
          type: integer
          description: Identyfikator metody płatności
        group:
          type: string
          description: "Możliwe wartości: FastTransfers, Blik, eTransfer, Credit Card, Installments, Wallet, Foreign, PrePayment, TraditionalTransfer, Another. SplitPayment"
        subgroup:
          type: string
          description: "Możliwe wartości: FastTransfers, Blik, eTransfer, Credit Card, Installments, Wallet, Foreign, PrePayment, TraditionalTransfer, Another. SplitPayment"
        status:
          type: boolean
          example: true
          description: Status określający czy dana metoda jest aktywna
        imgUrl:
          type: string
          description: Link do grafiki  
        mobileImgUrl:
          type: string
          description: Link do grafiki mobilnej
        mobile:
          type: boolean
          example: true
          description: Czy dostępna jest mobilna metoda płatności?
        availabilityHours:
          $ref: "#/components/schemas/availabilityHours"

    availabilityHours:
      type: object
      description: Obiekt zawierający informację o godzinach dostępności metody (metody o ID 177, 178 zwracają informacje w typie bool true/false)    
      properties:
        mondayToFriday:
          type: string
        saturday:
          type: string
        sunday:
          type: string
    TransactionNotFoundResponse:
      properties:
        error:
          type: string
          default: Transaction not found
          example: Transaction not found
        responseCode:
          type: number
          default: 0
          example: 0
    InfoResponse:
      properties:
        country:
          type: string
          default: PL
        bank:
          type: string
          default: PL
      type: object
    TransactionBySessionIdSuccessResponse:
      properties:
        data:
          $ref: "#/components/schemas/TransactionBySessionIdResponse"
        responseCode:
          type: number
          default: 0
      type: object
    TransactionBySessionIdResponse:
      properties:
        statement:
          type: string
          description: Transfer title
        orderId:
          type: integer
          format: int64
          description: Transaction ID
        sessionId:
          type: string
          description: Transaction ID assigned by Merchant
        status:
          type: integer
          description: Transaction status. 0 - no payment, 1 - advance payment, 2 - payment made, 3 - payment returned
        amount:
          type: integer
          description: Transaction amount
        currency:
          type: string
          default: PLN
          description: Transaction currency
        date:
          type: string
          description: Transaction registration date
        dateOfTransaction:
          type: string
          description: Date of payment
        clientEmail:
          type: string
          description: Customer's e-mail
        accountMD5:
          type: string
          description: Customer's hashed bank account number
        paymentMethod:
          type: integer
          description: Payment method ID
        description:
          type: string
          description: Transaction description
        clientName:
          type: string
          description: Customer's first name and surname
        clientAddress:
          type: string
          description: Customer's address
        clientCity:
          type: string
          description: Customer's city
        clientPostcode:
          type: string
          description: Customer's zip code
        batchId:
          type: integer
          description: Batch number in which the transaction was paid
        fee:
          type: string
          default: "0"
          description: Commission
    RecurringParams:
      type: object
      properties:
        token:
          type: string
          description: Token uzyskany podczas rejestracji transakcji żądaniem <b><a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post">transaction/register</a></b>. <br> <br>
            <b><font color = "#DB2053">WAŻNE!:</font></b><br>
            Aby poprawnie obciążyć płatnika metodą blikChargeByCode należy w żądaniu <b><a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post">transaction/register</a></b> przesłać w obiekcie <b>additional</b> obiekt <b>PSU</b>. 
        blikCode:
          type: string
          description: 6-cyfrowy, jednorazowy kod BLIK, wygenerowany w aplikacji
        aliasValue:
          type: string
          description: Unikalny alias użytkownika, który może być użyty do obciążenia środków podczas kolejnych transakcji. <br><br><b><font color = "#DB2053">WAŻNE!:</font></b> Parametr <b>wymagany</b> jeśli w żądaniu przesłano obiekt `recurring`.
        aliasLabel:
          type: string
          description:  Etykieta aliasu wyświetlana w aplikacji. <br><br><b><font color = "#DB2053">WAŻNE!:</font></b> Parametr <b>wymagany</b> jeśli w żądaniu przesłano obiekt `recurring`.
          minLength: 5
          maxLength: 35
        recurring:
          type: object
          $ref: "#/components/schemas/RecurringParamsIn"
      required:
        - token
        - blikCode
    RecurringParamsIn:
      description: >
        Obiekt zawierający infomacje dotyczące płatności cyklicznej BLIK.

        <div id="note"> 
        Funkcjonalność płatności cyklicznej nie jest domyślnie włączona. Skontaktuj się z Działem Obsługi Technicznej poprzez <a href="https://www.przelewy24.pl/centrum-pomocy/wsparcie-techniczne-api/brakuje-odpowiedzi-na-twoje-pytanie"><b>formularz kontaktowy</b></a>, w celu uruchomienia usługi. 
        </div>
      type: object
      discriminator:
        propertyName: type
        mapping:
          O: '#/components/schemas/RecurringParametersO'
          M: '#/components/schemas/RecurringParametersM'
          A: '#/components/schemas/RecurringParametersA'
      properties:
        type:
          type: string
          name: type
          enum:
            - M
            - A
            - O
          description: 'Typ płatności cyklicznej, dozwolone wartości: A, M, O'
          in: formData
          default: M
        expirationDate:
          type: string
          description: 'Data ważności płatności cyklicznej w formacie: YYYY-MM-DDThh:mm:ss'
        frequency:
          type: string
          description: 'Częstotliwość płatności; wartość musi spełnić warunek regex: [1-9][0-9]{0,2}[DWMY])'
        totalLimitAmount:
          type: integer
          description: 'Maksymalna łączna kwota na jaką zostaną obciążone środki w trakcie całego procesu'
        limitAmount:
          type: integer
          description: 'Maksymalna kwota pojedynczego obciążenia'
        totalLimitCount:
          type: integer
          description: 'Liczba płatności jaka zostanie wykonana w całym procesie'
        availableBanks:
          description: 'Parametr kontrolujący weryfikację tego, czy bank wspiera płatności cykliczne. Wartość false oznacza, że nie zostało sprawdzone czy bank wspiera płatności cykliczne.'
          type: boolean
    RecurringParametersO:
      allOf:
        # - $ref: '#/components/schemas/RecurringParamsIn'
        - type: object
          properties:
            type:
              type: string
              name: type
              enum:
                - M
                - A
                - O
              description: 'Typ płatności cyklicznej, dozwolone wartości: A, M, O'
              in: formData
            expirationDate:
              type: string
              description: 'Dozwolony format: YYYY-MM-DD hh:mm:ss'
            availableBanks:
              description: 'Parametr pozwalający kontrolować sprawdzanie, czy bank obsługuje rekurencję. Jeśli ustawiony na false, nie jest sprawdzane, czy bank obsługuje rekurencję.'
              default: true
              type: boolean
            initDate:
              type: string
              description: 'Dozwolony format: YYYY-MM-DD'
          required:
           - type
    RecurringParametersA:
      allOf:
        - $ref: '#/components/schemas/RecurringParamsIn'
        - type: object
          properties:
            type:
              type: string
              name: type
              enum:
                - M
                - A
                - O
              description: 'the type of recurring payment; allowed values: A, O, M'
              in: formData
            initDate:
              type: string
              description: 'Dozwolony format:: YYYY-MM-DD'
            expirationDate:
              type: string
              description: 'Dozwolony format:: YYYY-MM-DD hh:mm:ss'
            frequency:
              type: string
              description: 'Częstotliwość płatności; wartość musi spełnić warunek regex: [1-9][0-9]{0,2}[DWMY])'
            totalLimitAmount:
              type: integer
              description: 'Maksymalna łączna kwota na jaką zostaną obciążone środki w trakcie całego procesu'
            limitAmount:
              type: integer
              description: 'Maksymalna kwota pojedynczego obciążenia'
            totalLimitCount:
              type: integer
              descrition: 'Liczba płatności jaka zostanie wykonana w całym procesie'
            availableBanks:
              description: 'Parametr kontrolujący weryfikację tego, czy bank wspiera płatności cykliczne. Wartość false oznacza, że nie zostało sprawdzone czy bank wspiera płatności cykliczne.'
              type: boolean
          required:
            - initDate
            - totalLimitCount
            - totalLimitAmount
            - limitAmount
            - frequency
    RecurringParametersM:
      allOf:
        - $ref: '#/components/schemas/RecurringParamsIn'
        - type: object
          properties:
            type:
              type: string
              name: type
              enum:
                - A
                - O
                - M
              description: 'the type of recurring payment; allowed values: A, O, M'
              in: formData
            expirationDate:
              type: string
              description: 'Dozwolony format:: YYYY-MM-DD hh:mm:ss'
            frequency:
              type: string
              description: 'Częstotliwość płatności; wartość musi spełnić warunek regex: [1-9][0-9]{0,2}[DWMY])'
            totalLimitAmount:
              type: integer
              description: 'Maksymalna łączna kwota na jaką zostaną obciążone środki w trakcie całego procesu'
            limitAmount:
              type: integer
              description: 'Maksymalna kwota pojedynczego obciążenia'
            totalLimitCount:
              type: integer
              descrition: 'Liczba płatności jaka zostanie wykonana w całym procesie'
            minimumTime:
              type: boolean
              description: 'Parametr do kontrolowania flagi min'
              default: true
            availableBanks:
              description: 'Parametr kontrolujący weryfikację tego, czy bank wspiera płatności cykliczne. Wartość false oznacza, że nie zostało sprawdzone czy bank wspiera płatności cykliczne.'
              type: boolean
          required:
            - totalLimitCount
    BlikChargeByCodeResponse:
      properties:
        data:
          properties:
            orderId:
              type: integer
              format: int64
            message:
              type: string
          type: object
        responseCode:
          type: number
          default: 0
    BlikOneClick:
      type: object
      required:
        - token
        - type
      discriminator:
        propertyName: type
        mapping:
          alias: '#/components/schemas/Alias'
          alternativeKey: '#/components/schemas/Alternativekey'
          #blikCode: '#/components/schemas/Blik_Code'
      properties:
        token:
          type: string
          description: Token uzyskany podczas rejestracji transakcji żądaniem <b><a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post">transaction/register</a></b>. <br> <br>
            <b><font color = "#DB2053">WAŻNE!:</font></b><br>
            Aby poprawnie obciążyć płatnika metodą blikChargeByAlias należy w żądaniu <b><a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post">transaction/register</a></b> przesłać w obiekcie <b>additional</b> obiekt <b>PSU</b>. 
        type:
          type: string
        aliasValue:
          type: string
          description: <b>Uwaga! Wysłanie parametru spowoduje nadpisanie istniejącego aliasu.</b> <br/> Unikalny alias użytkownika, który może być użyty do obciążenia środków podczas kolejnych transakcji. <br><br><b><font color = "#DB2053">WAŻNE!:</font></b> Parametr <b>wymagany</b> jeśli w żądaniu przesłano obiekt `recurring`.
        aliasLabel:
          type: string
          description: <b>Uwaga! Wysłanie parametru spowoduje nadpisanie istniejącej etykiety.</b> <br/> Etykieta aliasu wyświetlana w aplikacji. <br><br><b><font color = "#DB2053">WAŻNE!:</font></b> Parametr <b>wymagany</b> jeśli w żądaniu przesłano obiekt `recurring`.
        recurring:
          description:
          $ref: "#/components/schemas/RecurringParamsIn"
    Alias:
      description: alias description
      type: object
      allOf:
        - $ref: '#/components/schemas/BlikOneClick'
        - type: object
          properties:
            token:
              type: string
              description: Token uzyskany podczas rejestracji transakcji żądaniem <b><a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post">transaction/register</a></b>. <br> <br>
                <b><font color = "#DB2053">WAŻNE!:</font></b><br>
                Aby poprawnie obciążyć płatnika metodą blikChargeByAlias należy w żądaniu <b><a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post">transaction/register</a></b> przesłać w obiekcie <b>additional</b> obiekt <b>PSU</b>. 
            type:
              type: string
              description: Ustaw wartość „alias”
          required:
            - token
            - type
    Alternativekey:
      type: object
      allOf:
        - $ref: '#/components/schemas/BlikOneClick'
        - type: object
          properties:
            token:
              type: string
              description: Token uzyskany podczas rejestracji transakcji żądaniem <b><a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post">transaction/register</a></b>. <br> <br>
                <b><font color = "#DB2053">WAŻNE!:</font></b><br>
                Aby poprawnie obciążyć płatnika metodą blikChargeByAlias należy w żądaniu <b><a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post">transaction/register</a></b> przesłać w obiekcie <b>additional</b> obiekt <b>PSU</b>. 
            type:
              type: string
              description: Ustaw wartość „alternativeKey”
            alternativeKey:
              type: string
              description: Wartość uzyskana jako odpowiedź z chargeByAlias, podczas obciążenia tokenu z "type" = "alias", gdzie przypisana jest więcej niż jedna aplikacja bankowa
          required:
            - token
            - type
            - alternativeKey
    # Blik_Code:
    #   type: object
    #   allOf:
    #     - $ref: '#/components/schemas/BlikOneClick'
    #     - type: object
    #       properties:
    #         token:
    #           type: string
    #           description: Token pozyskany podczas rejestracji transakcji
    #         type:
    #           type: string
    #           description: Ustaw wartość „blikCode”
    #         blikCode:
    #           type: string
    #           description: Wartość T6 wprowadzona przez klienta.
    #       required:
    #         - token
    #         - type
    #         - blikCode
    BlikChargeByAliasResponse:
      properties:
        data:
          properties:
            orderId:
              type: integer
              format: int64
            message:
              type: string
          type: object
    ChargeByAlias409:
      properties:
        error:
          type: object
          properties:
            message:
              type: string
            alternativeKeys:
              type: array
              items:
                $ref: "#/components/schemas/alternativeKeysItem"
        code:
          type: integer
          example: 51
    # ChargeByAlias409Item:
    #   properties:
    #     message:
    #       type: string
    #     alternativeKeys:
    #       type: array
    #       items:
    #         $ref: "#/components/schemas/alternativeKeysItem"
    alternativeKeysItem:
      properties:
        label:
          type: string
        alias:
          type: string
    cardinfores:
      properties:
        data:
          type: object
          properties:
            refId:
              type: string
              description: Unikalny token karty (kod referencyjny)
            bin:
              type: integer
              description: Numer BIN karty
            mask:
              type: string
              description: Numer maskowany karty
            cardType:
              type: string
              description: Typ karty (VISA, ECMC)
            cardDate:
              type: string
              description: Data ważności w formacie MMYYYY
            hash:
              type: string
              description: Unikatowy hash karty – unikatowy dla każdej karty              
        responseCode:
          type: number
    CardChargeRequestBody:
      properties:
        token:
          type: string
          description:  Token zarejestrowany metodą <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b>transaction/register</b></a>. Numer referencyjny karty musi zostać przekazany w trakcie rejestracji w parametrze  <b>methodRefId</b>
    ChargeCard3dsSuccessResponse:
      properties:
        data:
          properties:
            orderId:
              type: integer
              format: int64
            redirectUrl:
              type: string
          type: object
        responseCode:
          type: number
          example: 0
    ChargeCardSuccessResponse:
      properties:
        data:
          properties:
            orderId:
              type: integer
              format: int64
              description: Registered transaction ID
          type: object
        responseCode:
          type: number
          default: 0
          example: 0
    CardRegisterRequestBody:
      type: object
      properties:
        transactionToken:
          type: string
          description: Token pozyskany w procesie rejestracji
        cardNumber:
          type: string
          description: Numer karty
          maxLength: 16
        cardDate:
          type: string
          description: Data ważności w formacie MMYYYY
        cvv:
          type: string
          description: Card CVV
        clientName:
          type: string
          description: Imię i nazwisko posiadacza karty
      required:
        - transactionToken
        - cardNumber
        - cardDate
        - cvv
        - clientName
    CardPayThreeDSecureResponse:
      properties:
        data:
          properties:
            orderId:
              type: integer
              format: int64
            redirectUrl:
              type: string
          type: object
        responseCode:
          type: number
          example: 0
    CardPayResponse409:
      properties:
        error:
          type: string
          example: Unable to make payment.
        code:
          type: number
    CardPaySuccessResponse:
      properties:
        data:
          properties:
            orderId:
              type: integer
              format: int64
            redirectUrl:
              type: string
          type: object
        responseCode:
          type: number
          example: 0
    blikadnotification:
      properties:
        email:
          type: string
          description: email klienta
        value:
          type: string
          description: wartość aliasu
        type:
          type: string
          description: UID dla 1-click, PAYID dla płatności cyklicznych
        status:
          type: string
          description: REGISTERED / UNREGISTERED / EXPIRED
    bliknotification:
      properties:
        data:
          properties:
            orderId:
              type: integer
              format: int64
              description: Order ID
            sessionId:
              type: string
              description: ID sesji
            method:
              type: integer
              description: ID metody płatności
            result:
              description: Tablica wartości
              type: object
              properties:
                error:
                  type: string
                  description: Kod błędu - 0 dla sukcesu
                message:
                  type: string
                  description: Komunikat błędu
                status:
                  type: string
                  description: Status transakcji
                trxRef:
                  type: string
                  description: Numer referencyjny transakcji BLIK
            sign:
              type: string
              description: <br>Suma kontrolna parametrów:<br>
                {<font color = "brown">"orderId":</font>int,
                <font color = "brown">"sessionId":</font>"string",
                <font color = "brown">"method":</font>int,
                <font color = "brown">"result":</font>array,
                <font color = "brown">"crc":</font>"string"}
                <br><br>liczona z użyciem sha384<br><br> <b><font color = "#DB2053">WAŻNE!:</font></b><br> przy wykorzystaniu funkcji json_encode należy dodać następujące atrybuty "JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES"
    CardNotificationExtN:
      properties:
        amount:
          type: integer
          description: Kwota transakcji
        3ds:
          type: boolean
          description: Czy podczas płatności był wykonywany 3ds?
        method:
          type: integer
          description: ID metody płatności
        orderId:
          type: integer
          format: int64
          description: Identyfikator transakcji nadany przez P24 dla dla próbkowania 1-click
        sessionId:
          type: string
          description: ID sesji merchanta
        errorCode:
          type: string
          description: Kod błędu
        errorMessage:
          type: string
          description: Opis błędu. 
        sign:
          type: string
          description: <br> Przed wyliczeniem signa, należy przekształcić wartość parametru w taki sposób, aby znaki alfanumeryczne zostały zamienione na diaktryczne.<br><br>Suma kontrolna parametrów:<br>
                {<font color = "brown">"amount":</font>int,<font color = "brown">"3ds":</font>boolean,<font color = "brown">"method":</font>int,<font color = "brown">"orderId":</font>int,<font color = "brown">"sessionId":</font>"str",<br/><font color = "brown">"errorCode":</font>"str",<font color = "brown">"errorMessage":</font>"str",<font color = "brown">"crc":</font>"str"}
                <br><br>Liczona z użyciem SHA384<br><br> <b><font color = "#DB2053">Ważne!:</font></b><br>  w przypadku wykorzystania funkcji json_encode, powinny zostać dodane następujące atrybuty <br> "JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES"
    CardNotificationExt:
      properties:
        amount:
          type: integer
          description: Kwota transakcji
        3ds:
          type: boolean
          description: Czy podczas płatności był wykonywany 3ds?
        method:
          type: integer
          description: ID metody płatności
        refId:
          type: string
          description: Numer referencyjny karty
        orderId:
          type: integer
          format: int64
          description: Identyfikator transakcji nadany przez P24 dla dla próbkowania 1-click
        sessionId:
          type: string
          description: ID sesji merchanta
        bin:
          type: integer
          description: Numer BIN karty
        maskedCCNumber:
          type: string
          description: Numer maskowany karty
        ccExp:
          type: string
          description: Data ważności karty w formacie MMYYYY np. 122020
        hash:
          type: string
          description: Unikatowy hash karty – unikalny dla każdej karty
        cardCountry:
          type: string
          description: Kod kraju zgodny z ISO, np. PL
          example: "PL"
        risk:
          type: integer
          description: 0 – bezpieczna, 1 – podejrzana, 2 – niebezpieczna. Wynik obliczany na podstawie narzędzia do oceny ryzyka płatności kartą.
        liabilityshift:
          type: boolean
          description: Liability Shift oznacza przeniesienie odpowiedzialności  za transakcje oszukańcze ze sprzedawcy na wystawcę karty lub podmiot przetwarzający płatności. 1 – Tak, 0 – Nie
          example: false
        sign:
          type: string
          description: <br>Suma kontrolna parametrów:<br>
                {<font color = "brown">"amount":</font>int,<font color = "brown">"3ds":</font>boolean,<font color = "brown">"method":</font>int,<font color = "brown">"refId":</font>"str",<font color = "brown">"orderId":</font>int,<font color = "brown">"sessionId":</font>"str",<br/><font color = "brown">"bin":</font>int,<font color = "brown">"maskedCCNumber":</font>"str",<font color = "brown">"ccExp":</font>"str",<font color = "brown">"hash":</font>"str",<br/><font color = "brown">"cardCountry":</font>"str",<font color = "brown">"risk":</font>int,<font color = "brown">"liabilityshift":</font>boolean,<font color = "brown">"crc":</font>"str"}
                <br><br>liczona z użyciem sha384<br><br> <b><font color = "#DB2053">Ważne!:</font></b><br>  w przypadku wykorzystania funkcji json_encode, powinny zostać dodane następujące atrybuty <br> "JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES"
    cardpayjson:
      properties:
        cardHolderLabel:
          type: string
        cardNumberLabel:
          type: integer
        cvvLabel:
          type: integer
        expDateLabel:
          type: string
        payButtonCaption:
          type: string
        threeDSAuthMessage:
          type: string
    TransactionRefundResult:
      type: object
      properties:
        orderId:
          type: integer
          format: int64
          description: ID zwracanej transakcji w systemie P24
        sessionId:
          type: string
          description: ID zwracanej transakcji w systemie Partnera
        merchantId:
          type: integer
          description: ID Merchanta, na rzecz którego został wykonany zwrot
        requestId:
          type: string
          description: ID żądania zwrotu przekazane w <a href="#tag/Additional-API-functionality/paths/~1api~1v1~1transaction~1refund/post"><b>transaction/refund</b></a>
        refundsUuid:
          type: string
          description: ID żądania zwrotu w systemie Partnera przekazane w <a href="#tag/Additional-API-functionality/paths/~1api~1v1~1transaction~1refund/post"><b>transaction/refund</b></a>
        amount:
          type: integer
          description: Wartość kwoty wykonanego zwrotu wyrażona w groszach
        currency:
          type: string
          example: PLN
          description: Waluta wykonanego zwrotu
        timestamp:
          type: integer
          description: Czas wysłania notyfikacji w formacie UNIX timestamp
        status:
          type: integer
          description: Status zrealizowanego zwrotu. 0 - zrealizowany, 1 - odrzucony
          enum:
            - 0
            - 1 
        sign:
          type: string
          description: <br>Suma kontrolna parametrów:<br>
            {<font color = "brown">"orderId":</font>int,<font color = "brown">"sessionId":</font>"str",<font color = "brown">"refundsUuid":</font>"str",<font color = "brown">"merchantId":</font>int,<font color = "brown">"amount":</font>int,<br/><font color = "brown">"currency":</font>"str",<font color = "brown">"status":</font>int,<font color = "brown">"crc":</font>"str"}
            <br><br> liczona z użyciem sha384<br><br> <b><font color = "#DB2053">WAŻNE!:</font></b><br>  przy wykorzystaniu funkcji json_encode należy dodać następujące atrybuty <br> "JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES"
    TransactionResult:
      type: object
      properties:
        merchantId:
          name: merchantId
          in: formData
          description: ID Merchanta
          type: integer
        posId:
          name: posId
          in: formData
          description: ID Sklepu (domyślnie ID Merchanta)
          type: integer
        sessionId:
          name: sessionId
          in: formData
          description: Unikalny identyfikator z systemu sprzedawcy
          type: string
          maxLength: 100
        amount:
          name: amount
          in: formData
          description: Wartość opłaconej transakcji wyrażona w groszach, np. 1.23 PLN = 123
          type: integer
        originAmount:
          name: originAmount
          in: formData
          description: Wartość transakcji podczas rejestracji tokenu wyrażona w groszach, np. 1.23 PLN = 123
          type: integer
        currency:
          name: currency
          in: formData
          description: Wartość zgodna z ISO np. PLN
          type: string
          maxLength: 3
          default: PLN
        orderId:
          name: orderId
          in: formData
          description: Numer transakcji przypisany przez P24
          type: integer
          format: int64
        methodId:
          name: methodId
          in: formData
          description: Metoda płatności, z której skorzystał klient
          type: integer
        statement:
          name: statement
          in: formData
          description: Tytuł płatności
          type: string
        sign:
          name: sign
          in: formData
          description: <br>Suma kontrolna parametrów:<br>
            {<font color = "brown">"merchantId":</font>int,<font color = "brown">"posId":</font>int,<font color = "brown">"sessionId":</font>"string",<font color = "brown">"amount":</font>int,<font color = "brown">"originAmount":</font>int,<font color = "brown">"currency":</font>"string",
            <font color = "brown">"orderId":</font>int,<font color = "brown">"methodId":</font>int,<font color = "brown">"statement":</font>"string",<font color = "brown">"crc":</font>"string"}
            <br><br>liczona z użyciem sha384<br><br> <b><font color = "#DB2053">WAŻNE!:</font></b><br> przy wykorzystaniu funkcji json_encode należy dodać następujące atrybuty
            <br> "JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES"
          type: string
    BatchDetails200ResponseBody:
      properties:
        token:
          type: string
          description: Token needed to request next page
        responseCode:
          type: integer
          description: 0 if correct
        pageInformation:
          description: Array of page information
          properties:
            recordsOnPage:
              type: integer
              description: Amount records on current page
            recordsAll:
              type: integer
              description: Amount of all records
            pageCount:
              type: integer
              description: Amount of pages
        data:
          description: Array of transactions, refunds and batch
          items:
            $ref: "#/components/schemas/DataBatchDetailsObject"        
    DataBatchDetailsObject:
      properties:
        overall:
          description: Batch overall information
          items:
          $ref: "#/components/schemas/OverallObject"
        transactions:
          description: List of transactions
          type: array
        refunds:
          description: List of refunds
          type: array              
    OverallObject:
      oneOf:
        - $ref: "#/components/schemas/Batch"
        - $ref: "#/components/schemas/Transaction"
        - $ref: "#/components/schemas/Refund"
      discriminator:
        propertyName: details
    HistoryResponse200Body:
      properties:
        data:
          description: Tablica obiektów (paczki, transakcje, zwroty)
          items:
            $ref: "#/components/schemas/HistoryDataObject"
        token:
          type: string
          description: Token potrzebny do wywołania następnej strony
        responseCode:
          type: integer
          description: 0 jeśli poprawne
        pageInformation:
          description: Informacja o stronicowaniu
          items:
            $ref: "#/components/schemas/PageInformationObject"
    PageInformationObject:
      properties:
        recordsOnPage:
          type: integer
          description: Liczba rekordów na bieżącej stronie
        recordsAll:
          type: integer
          description: Liczba wszystkich rekordów
        pageCount:
          type: integer
          description: Liczba stron
    HistoryDataObject:
      oneOf:
        - $ref: "#/components/schemas/Batch"
        - $ref: "#/components/schemas/Transaction"
        - $ref: "#/components/schemas/Refund"
      discriminator:
        propertyName: details
    HistoryError400Body:
      properties:
        error:
          type: string
          example: Invalid data provided
        code:
          type: string
          example: 400
        validation:
          items:
            $ref: "#/components/schemas/ValidationObject"        
    ValidationObject:
      properties:
        type:
          type: array
          example: Provided type is unknown                              
    Batch:
      properties:
        type:
          type: string
          description: 'Możliwe wartości: batch, refund, transaction'
        amount:
          type: integer
          description: Kwota
        currency:
          type: string
          description: Waluta
          example: PLN
        details:
          description: Tablica obiektów, zależy od typu
          items:
            $ref: "#/components/schemas/BatchObject"
    BatchObject:
      properties:
        dateIn:
          type: string
          description: 'Data utworzenia paczki. Format: “YYYY-MM-DD HH:MM:SS”'
        dateOut:
          type: string
          description: 'Date of withdrawal. Format: “YYYY-MM-DD HH:MM:SS”'
        batchId:
          type: integer
          description: Unique id of withdrawal
        commision:
          type: integer
          description: Sum of commisions
        charge:
          type: integer
          description: Charge
        refund:
          type: integer
          description: Sum of refunds
    Transaction:
      properties:
        type:
          type: string
          description: 'Possible values: batch, refund, transaction'
        amount:
          type: integer
          description: Amount
        currency:
          type: string
          description: Currency
        details:
          description: Array of objects depended of type
          items:
            $ref: "#/components/schemas/TransactionObject"
    TransactionObject:
      properties:
        settledAmount:
          type: integer
          description: Amount without commision
        ordrId:
          type: integer
          description: Unique id of transaction
        sessionId:
          type: string
          description: Id of transaction used by merchant
        status:
          type: integer
          description: 'Status of transaction: 0 – not paid, 1 – paid, 2 – paid and verified, 3 – payment returned'
        date:
          type: string
          description: 'Creation date of transaction. Format: “YYYY-MM-DD HH:MM:SS”'
        dateOfTransaction:
          type: string
          description: Transaction registration date
        dateOfVerification:
          type: string
          description: Date of verification
        clientEmail:
          type: string
          description: Client's email
        accountChecksum:
          type: string
          description: Customer’s hashed bank account number
        paymentMethod:
          type: integer
          description: Payment method ID
        description:
          type: string
          description: Transaction description
        clientName:
          type: string
          description: Customer’s first name and surname
        clientAddress:
          type: string
          description: Customer's address
        clientCity:
          type: string
          description: Customer's city
        clientZip:
          type: string
          description: Customer's zip code
        statement:
          type: string
          description: Batch number in which the transaction was paid
        fee:
          type: integer
          descirption: Commision
    Refund:
      properties:
        type:
          type: string
          description: 'Possible values: batch, refund, transaction'
        amount:
          type: integer
          description: Amount
        currency:
          type: string
          description: Currency
          example: PLN
        details:
          description: Array of objects depended of type
          items:
            $ref: "#/components/schemas/RefundObject"
    RefundObject:
      properties:
        refundId:
          type: integer
          description: Unique id of refund
        orderId:
          type: integer
          format: int64
          descirption: Unique id of payment transaction
        requestId:
          type: string
          description: Unique request ID of refund. Empty when refund is done by P24 Panel.
        dateIn:
          type: string
          description: Refund registration date
        dateOut:
          type: string
          description: Refund payout date
        status:
          type: integer
          descirption: 'Status of refund: 1 – completed, 2 – pending, 3 – waiting to acceptance, 4 - rejected'
        description:
          type: string
          description: Additional description of refund    
    BatchDetailsError400Body:
      properties:
        code:
          type: string
          example: 400
        error:
          type: string
          example: Value for field batch is invalid    
    GeneralErrorResponse:
      properties:
        error:
          type: string
        code:
          type: string                    
####end components####

####descriptions####
tags:
####ADDITIONAL API####
  - name: Transaction service API
    x-displayName: Obsługa transakcji API
  - name: Additional API functionality
    x-displayName: Dodatkowa funkcjonalność API
  - name: Notification
    x-displayName: Notyfikacja
    description:
      <div id="PP">
      <h2>Wynik transakcji</h2>

      <SchemaDefinition schemaRef="#/components/schemas/TransactionResult" />

      <h2>Automatyczne przekazywanie wyniku transakcji</h2>
      W sytuacji, gdy pierwsze powiadomienie o wyniku transakcji nie zostanie poprawnie odebrane przez system sprzedawcy (nie wykona on prawidłowej weryfikacji), system P24 wyśle kolejne powiadomienia. Powiadomienia zostaną wysłane po 3, 5, 15, 30, 60, 150 i 450 minutach (+/- 5 min.), chyba że wcześniej nastąpi prawidłowa weryfikacja transakcji.<br><br>Parametry <b>POST</b> są takie same, jak w przypadku pierwszego powiadomienia.
      </div>


  - name: RefundNotification
    x-displayName: Notyfikacja o zwrocie
    description:
      <div id="PP">
      <h2>Wynik zwrotu</h2>

      Notyfikacja o zwrocie wysyłana jest w sposób asynchroniczny na adres URL podany w żądaniu wykonania zwrotu <a href="#tag/Additional-API-functionality/paths/~1api~1v1~1transaction~1refund/post"><b>transaction/refund</b></a> w parametrze <b>urlStatus</b>. Jeśli nie zostanie przekazana wartość w <b>urlStatus</b>, to notyfikacja zostanie przesłana na domyślny adres ustawiony w panelu P24 (o ile taki adres został skonfigurowany).
      <br/><br/>
      <div id="note"> Aby skonfigurować domyślny adres URL w panelu, proszę o kontakt z Biurem Obsługi Klienta poprzez <a href="https://www.przelewy24.pl/centrum-pomocy/sprzedaje-z-przelewy24/metody-platnosci-konto/brakuje-odpowiedzi-na-twoje-pytanie"><b>formularz kontaktowy</b></a></div><br>

      <SchemaDefinition schemaRef="#/components/schemas/TransactionRefundResult" />
      </div>


  - name: Przypadki użycia metod płatności
    x-displayName: Przypadki użycia metod płatności
    description: >
       ## PayPo

        Metoda płatności PayPo nie jest domyślnie uruchomioną formą płatności i jest dostępna po kontakcie z naszym działem Merchant Success poprzez <a href="https://www.przelewy24.pl/centrum-pomocy/sprzedaje-z-przelewy24/metody-platnosci-konto/brakuje-odpowiedzi-na-twoje-pytanie"><b>formularz kontaktowy</b></a>.

        Po uruchomieniu usługi na Państwa koncie, aby prawidłowo zarejestrować transakcję należy w żądaniu <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b>rejestracji transakcji </b></a> przekazać dodatkowe parametry, które domyślnie są opcjonalne:
        <code>client</code>, <code>city</code>, <code>zip</code>, <code>address</code>.



        Kwota przesyłana w żądaniu obecnie minimalnie wynosi 5zł, jej maksymalna wartość 5 000zł.

 

        Płatności PayPo wypłacane są po otrzymaniu środków od operatora. domyślnie merchant otrzyma środki do 5 dni roboczych.

       ## PayPal

       Aby metoda PayPal działała poprawnie na Państwa stronie musi zostać ona uruchomiona dla konta po stronie Przelewy24. W celu uruchomienia metody PayPal prosimy o kontakt wykorzystując adres mailowy przypisany w panelu Przelewy24 do konta poprzez <a href="https://www.przelewy24.pl/centrum-pomocy/sprzedaje-z-przelewy24/metody-platnosci-konto/brakuje-odpowiedzi-na-twoje-pytanie"><b>formularz kontaktowy</b></a>.

       

       Aby poprawnie wykonać transakcję dla wskazanej metody konieczne jest przesłanie pełnego obiektu <b><a href="https://developers.przelewy24.pl/index.php?pl#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><code>cart</code></a></b> z wymaganymi parametrami wysłanymi w żądaniu <a href="https://developers.przelewy24.pl/index.php?pl#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b>rejestracji transakcji</b></a>.

  - name: Calculating Sign
    x-displayName: Wyliczanie sumy kontrolnej
    description: >
      <div id="PP">

       ## Rejestracja transakcji

       Poniżej znajdują się fragmenty kodu dla 4 języków programowania, prezentujące prawidłowe wyliczanie sumy kontrolnej <b>sign</b> dla żądania <b><a href="#tag/Transaction-service-API">rejestracji transakcji</a></b>. 
       
       Aby prawidłowo wyliczać sign, należy pamiętać o poprawności danych (parametry merchantId oraz crc to wartości pobierane z panelu Przelewy24, a pozostałe wartości są ustalane indywidualnie dla każdej transakcji przez sprzedawcę) oraz o rozróżnieniu typów zmiennych (merchantId oraz amount to integer, pozostałe to string).
       
      
      <b><font color = "#DB2053">WAŻNE!</font></b><br> Należy pamiętać, że składowe sumy kontrolnej sign różnią się dla poszczególnych żądań wysyłanych lub odbieranych z Przelewy24. Wartość parametru sign, którą należy przekazać w żądaniu <b><a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post">rejestracji transakcji</a></b>, różni się od wartości sign przekazanej dla żądania <b><a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1verify/put">weryfikacji transakcji</a></b>.  
      
      

      <h3> Przykłady wyliczania sumy kontrolnej sign dla żądania rejestracji transakcji: </h3>
      <div class="container-to-registration">
      <div class="tabs">
          <div class="tab active">PHP</div>
          <div class="tab">JavaScript</div>
          <div class="tab">Java</div>
          <div class="tab">Python</div>
      </div>
      <div id="php-lang" class="code-container active">
      <pre><code class="language-php"><span class="token variable">$params</span> <span class="token operator">=</span> <span class="token punctuation">[</span>
          <span class="token string single-quoted-string">'sessionId'</span> <span class="token operator">=&gt;</span> <span class="token string single-quoted-string">'unikalne-id-sesji'</span><span class="token punctuation">,</span> <span class="token comment">// Tutaj należy umieścić unikalne wygenerowane ID sesji</span>
          <span class="token string single-quoted-string">'merchantId'</span> <span class="token operator">=&gt;</span> <span class="token number">999999</span><span class="token punctuation">,</span> <span class="token comment">// Tutaj należy umieścić ID Sprzedawcy z panelu Przelewy24</span>
          <span class="token string single-quoted-string">'amount'</span> <span class="token operator">=&gt;</span> <span class="token number">1234</span><span class="token punctuation">,</span> <span class="token comment">// Tutaj należy umieścić kwotę transakcji w groszach, 1234 oznacza 12,34 PLN</span>
          <span class="token string single-quoted-string">'currency'</span> <span class="token operator">=&gt;</span> <span class="token string single-quoted-string">'PLN'</span><span class="token punctuation">,</span> <span class="token comment">// Tutaj należy umieścić walutę transakcji</span>
          <span class="token string single-quoted-string">'crc'</span> <span class="token operator">=&gt;</span> <span class="token string single-quoted-string">'crc-z-panelu-p24'</span><span class="token punctuation">,</span> <span class="token comment">// Tutaj należy umieścić pobrany klucz CRC z panelu Przelewy24</span>
      <span class="token punctuation">]</span><span class="token punctuation">;</span>

      <span class="token comment">// Sklejanie parametrów w ciąg JSON</span>

      <span class="token variable">$combinedString</span> <span class="token operator">=</span> <span class="token function">json_encode</span><span class="token punctuation">(</span><span class="token variable">$params</span><span class="token punctuation">,</span> <span class="token class-name">JSON_UNESCAPED_UNICODE</span> <span class="token operator">|</span> <span class="token class-name">JSON_UNESCAPED_SLASHES</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

      <span class="token comment">// Hashowanie za pomocą SHA-384</span>

      <span class="token variable">$hash</span> <span class="token operator">=</span> <span class="token function">hash</span><span class="token punctuation">(</span><span class="token string single-quoted-string">'sha384'</span><span class="token punctuation">,</span> <span class="token variable">$combinedString</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

      <span class="token keyword">echo</span> <span class="token string single-quoted-string">'Suma kontrolna parametrów wynosi: '</span> <span class="token operator">.</span> <span class="token variable">$hash</span><span class="token punctuation">;</span>

      </code></pre>




      </div>
        <div id="javascript-lang" class="code-container">
      <pre><code class="language-javascript"><span class="token keyword">const</span> params <span class="token operator">=</span> <span class="token punctuation">{</span>
        <span class="token literal-property property">sessionId</span><span class="token operator">:</span> <span class="token string">"unikalne-id-sesji"</span><span class="token punctuation">,</span> <span class="token comment">// Tutaj należy umieścić unikalne wygenerowane ID sesji</span>
        <span class="token literal-property property">merchantId</span><span class="token operator">:</span> <span class="token number">999999</span><span class="token punctuation">,</span> <span class="token comment">// Tutaj należy umieścić ID Sprzedawcy z panelu Przelewy24</span>
        <span class="token literal-property property">amount</span><span class="token operator">:</span> <span class="token number">1234</span><span class="token punctuation">,</span> <span class="token comment">// Tutaj należy umieścić kwotę transakcji w groszach, 1234 oznacza 12,34 PLN</span>
        <span class="token literal-property property">currency</span><span class="token operator">:</span> <span class="token string">"PLN"</span><span class="token punctuation">,</span> <span class="token comment">// Tutaj należy umieścić walutę transakcji</span>
        <span class="token literal-property property">crc</span><span class="token operator">:</span> <span class="token string">"crc-z-panelu-p24"</span> <span class="token comment">// Tutaj należy umieścić pobrany klucz CRC z panelu Przelewy24</span>
      <span class="token punctuation">}</span><span class="token punctuation">;</span>

      <span class="token comment">// Sklejanie parametrów w ciąg</span>

      <span class="token keyword">const</span> combinedString <span class="token operator">=</span> <span class="token constant">JSON</span><span class="token punctuation">.</span><span class="token function">stringify</span><span class="token punctuation">(</span>params<span class="token punctuation">)</span><span class="token punctuation">;</span>

      <span class="token comment">// Hashowanie za pomocą SHA-384</span>

      <span class="token keyword">const</span> hash <span class="token operator">=</span> crypto<span class="token punctuation">.</span><span class="token function">createHash</span><span class="token punctuation">(</span><span class="token string">'sha384'</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">update</span><span class="token punctuation">(</span>combinedString<span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">digest</span><span class="token punctuation">(</span><span class="token string">'hex'</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

      console<span class="token punctuation">.</span><span class="token function">log</span><span class="token punctuation">(</span><span class="token string">'Suma kontrolna parametrów wynosi:'</span><span class="token punctuation">,</span> hash<span class="token punctuation">)</span><span class="token punctuation">;</span>

      </code></pre>
      </div>
      <div id="python-lang" class="code-container">
      <pre><code class="language-python"><span class="token keyword">import</span> hashlib

      <span class="token comment"># Parametry w formacie JSON</span>

      json_string <span class="token operator">=</span> <span class="token string">'{"sessionId":"sessionId","merchantId":999999,"amount":1000,"currency":"PLN","crc":"crc"}'</span>

      <span class="token comment"># Hashowanie za pomocą SHA-384</span>

      checksum <span class="token operator">=</span> hashlib<span class="token punctuation">.</span>sha384<span class="token punctuation">(</span>json_string<span class="token punctuation">.</span>encode<span class="token punctuation">(</span><span class="token string">'utf-8'</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">.</span>hexdigest<span class="token punctuation">(</span><span class="token punctuation">)</span>

      <span class="token keyword">print</span><span class="token punctuation">(</span><span class="token string">'Suma kontrolna parametrów wynosi:'</span><span class="token punctuation">,</span> checksum<span class="token punctuation">)</span>      

      </code></pre>
      </div>
      <div id="java-lang" class="code-container">
      <pre><code class="language-java"><span class="token keyword">import</span> <span class="token import"><span class="token namespace">com<span class="token punctuation">.</span>fasterxml<span class="token punctuation">.</span>jackson<span class="token punctuation">.</span>databind<span class="token punctuation">.</span></span><span class="token class-name">ObjectMapper</span></span><span class="token punctuation">;</span>

      <span class="token keyword">import</span> <span class="token import"><span class="token namespace">java<span class="token punctuation">.</span>nio<span class="token punctuation">.</span>charset<span class="token punctuation">.</span></span><span class="token class-name">StandardCharsets</span></span><span class="token punctuation">;</span>
      
      <span class="token keyword">import</span> <span class="token import"><span class="token namespace">java<span class="token punctuation">.</span>security<span class="token punctuation">.</span></span><span class="token class-name">MessageDigest</span></span><span class="token punctuation">;</span>
      
      <span class="token keyword">public</span> <span class="token keyword">class</span> <span class="token class-name">ChecksumExample</span> <span class="token punctuation">{</span>
            <span class="token keyword">public</span> <span class="token keyword">static</span> <span class="token keyword">void</span> <span class="token function">main</span><span class="token punctuation">(</span><span class="token class-name">String</span><span class="token punctuation">[</span><span class="token punctuation">]</span> args<span class="token punctuation">)</span> <span class="token keyword">throws</span> <span class="token class-name">Exception</span> <span class="token punctuation">{</span>
            <span class="token class-name">String</span> json <span class="token operator">=</span> <span class="token function">createJson</span><span class="token punctuation">(</span><span class="token string">"sessionId"</span><span class="token punctuation">,</span> <span class="token number">999999</span><span class="token punctuation">,</span> <span class="token number">1000</span><span class="token punctuation">,</span> <span class="token string">"PLN"</span><span class="token punctuation">,</span> <span class="token string">"crc"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
            <span class="token class-name">String</span> checksum <span class="token operator">=</span> <span class="token function">calculateChecksum</span><span class="token punctuation">(</span>json<span class="token punctuation">)</span><span class="token punctuation">;</span>
            <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span><span class="token string">"Suma kontrolna parametrow wynosi: "</span> <span class="token operator">+</span> checksum<span class="token punctuation">)</span><span class="token punctuation">;</span>
        <span class="token punctuation">}</span>
      
        <span class="token keyword">private</span> <span class="token keyword">static</span> <span class="token class-name">String</span> <span class="token function">createJson</span><span class="token punctuation">(</span><span class="token class-name">String</span> sessionId<span class="token punctuation">,</span> <span class="token keyword">int</span> merchantId<span class="token punctuation">,</span> <span class="token keyword">int</span> amount<span class="token punctuation">,</span> <span class="token class-name">String</span> currency<span class="token punctuation">,</span> <span class="token class-name">String</span> crc<span class="token punctuation">)</span> <span class="token keyword">throws</span> <span class="token class-name">Exception</span> <span class="token punctuation">{</span>
          <span class="token keyword">return</span> <span class="token keyword">new</span> <span class="token class-name">ObjectMapper</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">writeValueAsString</span><span class="token punctuation">(</span><span class="token class-name">Map</span><span class="token punctuation">.</span><span class="token function">of</span><span class="token punctuation">(</span>
              <span class="token string">"sessionId"</span><span class="token punctuation">,</span> sessionId<span class="token punctuation">,</span>
              <span class="token string">"merchantId"</span><span class="token punctuation">,</span> merchantId<span class="token punctuation">,</span>
              <span class="token string">"amount"</span><span class="token punctuation">,</span> amount<span class="token punctuation">,</span>
              <span class="token string">"currency"</span><span class="token punctuation">,</span> currency<span class="token punctuation">,</span>
              <span class="token string">"crc"</span><span class="token punctuation">,</span> crc
          <span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
      <span class="token punctuation">}</span>

        <span class="token keyword">private</span> <span class="token keyword">static</span> <span class="token class-name">String</span> <span class="token function">calculateChecksum</span><span class="token punctuation">(</span><span class="token class-name">String</span> json<span class="token punctuation">)</span> <span class="token keyword">throws</span> <span class="token class-name">Exception</span> <span class="token punctuation">{</span>
          <span class="token keyword">byte</span><span class="token punctuation">[</span><span class="token punctuation">]</span> hash <span class="token operator">=</span> <span class="token class-name">MessageDigest</span><span class="token punctuation">.</span><span class="token function">getInstance</span><span class="token punctuation">(</span><span class="token string">"SHA-384"</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">digest</span><span class="token punctuation">(</span>json<span class="token punctuation">.</span><span class="token function">getBytes</span><span class="token punctuation">(</span><span class="token class-name">StandardCharsets</span><span class="token punctuation">.</span><span class="token constant">UTF_8</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
          <span class="token class-name">StringBuilder</span> hexString <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">StringBuilder</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
          <span class="token keyword">for</span> <span class="token punctuation">(</span><span class="token keyword">byte</span> b <span class="token operator">:</span> hash<span class="token punctuation">)</span> <span class="token punctuation">{</span>
                  hexString<span class="token punctuation">.</span><span class="token function">append</span><span class="token punctuation">(</span><span class="token class-name">String</span><span class="token punctuation">.</span><span class="token function">format</span><span class="token punctuation">(</span><span class="token string">"%02x"</span><span class="token punctuation">,</span> b<span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
              <span class="token punctuation">}</span>
          <span class="token keyword">return</span> hexString<span class="token punctuation">.</span><span class="token function">toString</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
          <span class="token punctuation">}</span>
      <span class="token punctuation">}</span>
      </code>
      </pre>
      </div>
      </div>
      
      ## Weryfikacja transakcji
      
       Należy zwrócić szczególną uwagę przy implementacji kodu do wyliczania sumy kontrolnej dla żądania weryfikacji transakcji i nie tylko. Żądanie <b><a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1verify/put">weryfikacji transakcji</a></b> w odróżnieniu do żądania rejestracji transakcji zawiera jeden nowy parametr, czyli orderId.
       
       
       Parametr orderId jest parametrem ustalanym przez Przelewy24 i jest to numeryczny identyfikator transakcji (typu integer). Wartość orderId można przechwycić z <a href="#tag/Notification"><b>notyfikacji</b></a>, która jest wysyłana na adres urlStatus. 
       
  
      

      <h3> Przykłady wyliczania sumy kontrolnej sign dla żądania weryfikacji transakcji: </h3>

      <div class="container-to-verification">
      <div class="tabs-verify">
          <div class="tab-verify active">PHP</div>
          <div class="tab-verify">JavaScript</div>
          <div class="tab-verify">Java</div>
          <div class="tab-verify">Python</div>
      </div>


      <div id="php-verify-lang" class="code-container-verify active">
      <pre><code class="language-php"><span class="token variable">$params</span> <span class="token operator">=</span> <span class="token punctuation">[</span>
          <span class="token string single-quoted-string">'sessionId'</span> <span class="token operator">=&gt;</span> <span class="token string single-quoted-string">'unikalne-id-sesji'</span><span class="token punctuation">,</span> <span class="token comment">// Tutaj należy umieścić unikalne wygenerowane ID sesji</span>
          <span class="token string single-quoted-string">'orderId'</span> <span class="token operator">=&gt;</span> <span class="token number">999999</span><span class="token punctuation">,</span> <span class="token comment">// Tutaj należy umieścić numeryczne ID transakcji odebrany np. z notyfikacji</span>
          <span class="token string single-quoted-string">'amount'</span> <span class="token operator">=&gt;</span> <span class="token number">1234</span><span class="token punctuation">,</span> <span class="token comment">// Tutaj należy umieścić kwotę transakcji w groszach, 1234 oznacza 12,34 PLN</span>
          <span class="token string single-quoted-string">'currency'</span> <span class="token operator">=&gt;</span> <span class="token string single-quoted-string">'PLN'</span><span class="token punctuation">,</span> <span class="token comment">// Tutaj należy umieścić walutę transakcji</span>
          <span class="token string single-quoted-string">'crc'</span> <span class="token operator">=&gt;</span> <span class="token string single-quoted-string">'crc-z-panelu-p24'</span><span class="token punctuation">,</span> <span class="token comment">// Tutaj należy umieścić pobrany klucz CRC z panelu Przelewy24</span>
      <span class="token punctuation">]</span><span class="token punctuation">;</span>

      <span class="token comment">// Sklejanie parametrów w ciąg JSON</span>

      <span class="token variable">$combinedString</span> <span class="token operator">=</span> <span class="token function">json_encode</span><span class="token punctuation">(</span><span class="token variable">$params</span><span class="token punctuation">,</span> <span class="token class-name">JSON_UNESCAPED_UNICODE</span> <span class="token operator">|</span> <span class="token class-name">JSON_UNESCAPED_SLASHES</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

      <span class="token comment">// Hashowanie za pomocą SHA-384</span>

      <span class="token variable">$hash</span> <span class="token operator">=</span> <span class="token function">hash</span><span class="token punctuation">(</span><span class="token string single-quoted-string">'sha384'</span><span class="token punctuation">,</span> <span class="token variable">$combinedString</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

      <span class="token keyword">echo</span> <span class="token string single-quoted-string">'Suma kontrolna parametrów wynosi: '</span> <span class="token operator">.</span> <span class="token variable">$hash</span><span class="token punctuation">;</span>

      </code></pre>

      </div>
        <div id="javascript-verify-lang" class="code-container-verify">
      <pre><code class="language-javascript"><span class="token keyword">const</span> params <span class="token operator">=</span> <span class="token punctuation">{</span>
        <span class="token literal-property property">sessionId</span><span class="token operator">:</span> <span class="token string">"unikalne-id-sesji"</span><span class="token punctuation">,</span> <span class="token comment">// Tutaj należy umieścić unikalne wygenerowane ID sesji</span>
        <span class="token literal-property property">orderId</span><span class="token operator">:</span> <span class="token number">999999</span><span class="token punctuation">,</span> <span class="token comment">// Tutaj należy umieścić numeryczne ID transakcji odebrany np. z notyfikacji</span>/span>
        <span class="token literal-property property">amount</span><span class="token operator">:</span> <span class="token number">1234</span><span class="token punctuation">,</span> <span class="token comment">// Tutaj należy umieścić kwotę transakcji w groszach, 1234 oznacza 12,34 PLN</span>
        <span class="token literal-property property">currency</span><span class="token operator">:</span> <span class="token string">"PLN"</span><span class="token punctuation">,</span> <span class="token comment">// Tutaj należy umieścić walutę transakcji</span>
        <span class="token literal-property property">crc</span><span class="token operator">:</span> <span class="token string">"crc-z-panelu-p24"</span> <span class="token comment">// Tutaj należy umieścić pobrany klucz CRC z panelu Przelewy24</span>
      <span class="token punctuation">}</span><span class="token punctuation">;</span>

      <span class="token comment">// Sklejanie parametrów w ciąg</span>

      <span class="token keyword">const</span> combinedString <span class="token operator">=</span> <span class="token constant">JSON</span><span class="token punctuation">.</span><span class="token function">stringify</span><span class="token punctuation">(</span>params<span class="token punctuation">)</span><span class="token punctuation">;</span>

      <span class="token comment">// Hashowanie za pomocą SHA-384</span>

      <span class="token keyword">const</span> hash <span class="token operator">=</span> crypto<span class="token punctuation">.</span><span class="token function">createHash</span><span class="token punctuation">(</span><span class="token string">'sha384'</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">update</span><span class="token punctuation">(</span>combinedString<span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">digest</span><span class="token punctuation">(</span><span class="token string">'hex'</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

      console<span class="token punctuation">.</span><span class="token function">log</span><span class="token punctuation">(</span><span class="token string">'Suma kontrolna parametrów wynosi:'</span><span class="token punctuation">,</span> hash<span class="token punctuation">)</span><span class="token punctuation">;</span>

      </code></pre>
      </div>
      <div id="python-verify-lang" class="code-container-verify">
      <pre><code class="language-python"><span class="token keyword">import</span> hashlib

      <span class="token comment"># Parametry w formacie JSON</span>

      json_string <span class="token operator">=</span> <span class="token string">'{"sessionId":"sessionId","orderId":999999,"amount":1000,"currency":"PLN","crc":"crc"}'</span>

      <span class="token comment"># Hashowanie za pomocą SHA-384</span>

      checksum <span class="token operator">=</span> hashlib<span class="token punctuation">.</span>sha384<span class="token punctuation">(</span>json_string<span class="token punctuation">.</span>encode<span class="token punctuation">(</span><span class="token string">'utf-8'</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">.</span>hexdigest<span class="token punctuation">(</span><span class="token punctuation">)</span>

      <span class="token keyword">print</span><span class="token punctuation">(</span><span class="token string">'Suma kontrolna parametrów wynosi:'</span><span class="token punctuation">,</span> checksum<span class="token punctuation">)</span>      

      </code></pre>
      </div>
      <div id="java-verify-lang" class="code-container-verify">
      <pre><code class="language-java"><span class="token keyword">import</span> <span class="token import"><span class="token namespace">com<span class="token punctuation">.</span>fasterxml<span class="token punctuation">.</span>jackson<span class="token punctuation">.</span>databind<span class="token punctuation">.</span></span><span class="token class-name">ObjectMapper</span></span><span class="token punctuation">;</span>

      <span class="token keyword">import</span> <span class="token import"><span class="token namespace">java<span class="token punctuation">.</span>nio<span class="token punctuation">.</span>charset<span class="token punctuation">.</span></span><span class="token class-name">StandardCharsets</span></span><span class="token punctuation">;</span>
      
      <span class="token keyword">import</span> <span class="token import"><span class="token namespace">java<span class="token punctuation">.</span>security<span class="token punctuation">.</span></span><span class="token class-name">MessageDigest</span></span><span class="token punctuation">;</span>
      
      <span class="token keyword">public</span> <span class="token keyword">class</span> <span class="token class-name">ChecksumExample</span> <span class="token punctuation">{</span>
            <span class="token keyword">public</span> <span class="token keyword">static</span> <span class="token keyword">void</span> <span class="token function">main</span><span class="token punctuation">(</span><span class="token class-name">String</span><span class="token punctuation">[</span><span class="token punctuation">]</span> args<span class="token punctuation">)</span> <span class="token keyword">throws</span> <span class="token class-name">Exception</span> <span class="token punctuation">{</span>
            <span class="token class-name">String</span> json <span class="token operator">=</span> <span class="token function">createJson</span><span class="token punctuation">(</span><span class="token string">"sessionId"</span><span class="token punctuation">,</span> <span class="token number">999999</span><span class="token punctuation">,</span> <span class="token number">1000</span><span class="token punctuation">,</span> <span class="token string">"PLN"</span><span class="token punctuation">,</span> <span class="token string">"crc"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
            <span class="token class-name">String</span> checksum <span class="token operator">=</span> <span class="token function">calculateChecksum</span><span class="token punctuation">(</span>json<span class="token punctuation">)</span><span class="token punctuation">;</span>
            <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span><span class="token string">"Suma kontrolna parametrow wynosi: "</span> <span class="token operator">+</span> checksum<span class="token punctuation">)</span><span class="token punctuation">;</span>
        <span class="token punctuation">}</span>
      
        <span class="token keyword">private</span> <span class="token keyword">static</span> <span class="token class-name">String</span> <span class="token function">createJson</span><span class="token punctuation">(</span><span class="token class-name">String</span> sessionId<span class="token punctuation">,</span> <span class="token keyword">int</span> orderId<span class="token punctuation">,</span> <span class="token keyword">int</span> amount<span class="token punctuation">,</span> <span class="token class-name">String</span> currency<span class="token punctuation">,</span> <span class="token class-name">String</span> crc<span class="token punctuation">)</span> <span class="token keyword">throws</span> <span class="token class-name">Exception</span> <span class="token punctuation">{</span>
          <span class="token keyword">return</span> <span class="token keyword">new</span> <span class="token class-name">ObjectMapper</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">writeValueAsString</span><span class="token punctuation">(</span><span class="token class-name">Map</span><span class="token punctuation">.</span><span class="token function">of</span><span class="token punctuation">(</span>
              <span class="token string">"sessionId"</span><span class="token punctuation">,</span> sessionId<span class="token punctuation">,</span>
              <span class="token string">"orderId"</span><span class="token punctuation">,</span> orderId<span class="token punctuation">,</span>
              <span class="token string">"amount"</span><span class="token punctuation">,</span> amount<span class="token punctuation">,</span>
              <span class="token string">"currency"</span><span class="token punctuation">,</span> currency<span class="token punctuation">,</span>
              <span class="token string">"crc"</span><span class="token punctuation">,</span> crc
          <span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
      <span class="token punctuation">}</span>

        <span class="token keyword">private</span> <span class="token keyword">static</span> <span class="token class-name">String</span> <span class="token function">calculateChecksum</span><span class="token punctuation">(</span><span class="token class-name">String</span> json<span class="token punctuation">)</span> <span class="token keyword">throws</span> <span class="token class-name">Exception</span> <span class="token punctuation">{</span>
          <span class="token keyword">byte</span><span class="token punctuation">[</span><span class="token punctuation">]</span> hash <span class="token operator">=</span> <span class="token class-name">MessageDigest</span><span class="token punctuation">.</span><span class="token function">getInstance</span><span class="token punctuation">(</span><span class="token string">"SHA-384"</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">digest</span><span class="token punctuation">(</span>json<span class="token punctuation">.</span><span class="token function">getBytes</span><span class="token punctuation">(</span><span class="token class-name">StandardCharsets</span><span class="token punctuation">.</span><span class="token constant">UTF_8</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
          <span class="token class-name">StringBuilder</span> hexString <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">StringBuilder</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
          <span class="token keyword">for</span> <span class="token punctuation">(</span><span class="token keyword">byte</span> b <span class="token operator">:</span> hash<span class="token punctuation">)</span> <span class="token punctuation">{</span>
                  hexString<span class="token punctuation">.</span><span class="token function">append</span><span class="token punctuation">(</span><span class="token class-name">String</span><span class="token punctuation">.</span><span class="token function">format</span><span class="token punctuation">(</span><span class="token string">"%02x"</span><span class="token punctuation">,</span> b<span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
              <span class="token punctuation">}</span>
          <span class="token keyword">return</span> hexString<span class="token punctuation">.</span><span class="token function">toString</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
          <span class="token punctuation">}</span>
      <span class="token punctuation">}</span>
      </code>
      </pre>
      </div>
      </div>

      ## Kalkulator sumy kontrolnej
      

      <div class="container">
      <iframe class="responsive-iframe" src="https://developers.przelewy24.pl/html/calculate_sign.html"></iframe></div>

####END ADDITIONAL API####

####BLIK####
  - name: BLIK Use Cases
    x-displayName: Przypadki użycia BLIK
    description: >


       # Wprowadzenie

       Oprócz standardowej płatności bazującej na przekierowaniu do paymanetwall P24, na stronie Merchanta można również umieścić płatności BLIK.

       # Jak umieścić płatności BLIK na stronie Merchanta? (BLIK level 0)

       Po zarejestrowaniu transakcji z użyciem metody <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b> transaction/register</b></a>, wywołujemy metodę <a href="#tag/BLIK-API/paths/~1api~1v1~1paymentMethod~1blik~1chargeByCode/post"><b>paymentMethod/blik/chargeByCode</b></a>, z obowiązkowym wykorzystaniem parametrów <b>“token”</b> (zwracany w odpowiedzi z rejestracji transakcji) i <b>“blikCode”</b> (wpisany przez użytkownika).

       <!--Transakcję można zrealizować poprzez metodę <a href="#tag/BLIK-API/paths/~1api~1v1~1paymentMethod~1blik~1chargeByCode/post"><b>paymentMethod/blik/chargeByCode</b></a>. Konieczne jest uprzednie zarejestrowanie transakcji z użyciem metody<a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b> transaction/register</b></a>. W tym przypadku tylko parametry <b>“token”</b> i <b>“blikCode”</b> są obowiązkowe.<br><br><br>-->

       <img src="getfile/WHITE_LABEL_1_9.png" alt="Blik OneClick" class="center smallImg"><br><br><br>



         <img src="getfile/00_blik.png" alt="Blik" class="center smallImg">

       # Co to jest płatność BLIK 1-click?

       Jak sama nazwa sugeruje, płatność pozwala na wykonanie zakupu jednym kliknięciem. Nie wymaga to przepisania kodu BLIK, jedynie proste potwierdzenie w aplikacji mobilnej jednym kliknięciem.<br><br><br>

       <img src="getfile/ONE_CLICK_3.png" alt="Blik OneClick" class="center smallImg">



        # Jak uzyskać informacje o aliasie?

        Są dwa sposoby na uzyskanie informacji o aliasie:
        <ol>
        <li> Pozyskanie informacji poprzez obsłużenie <a href="#tag/Alias-Update-Notification"><b>dodatkowej notyfikacji.</b></a> (zalecane)</li>

        <li> W celu otrzymania aliasu dla kolejnych płatności, wywołaj metodę <a href="#tag/BLIK-API/paths/~1api~1v1~1paymentMethod~1blik~1getAliasesByEmail~1{email}/get"><b>getAliasesByEmail</b></a>.<br>
           Metoda zwraca listę aliasów (razem z typem i statusem) utworzonych dla danego adresu w zakresie danego merchanta.<br>
           Dla aliasów zarejestrowanych z parametrami <b>values</b> wywołaj metodę <a href="#tag/BLIK-API/paths/~1api~1v1~1paymentMethod~1blik~1getAliasesByEmail~1{email}~1custom/get"><b>getAliasesByEmail{email}/custom</b></a></li><br/>



        <div id="note">W związku z asynchronicznym charakterem przetwarzania statusu transakcji, czas zwrócenia aktualnego statusu aliasów przez metodę <a href="#tag/BLIK-API/paths/~1api~1v1~1paymentMethod~1blik~1getAliasesByEmail~1{email}/get"><b>getAliasesByEmail</b></a> może wynieść do 60 sekund po poprawnie dokonanej transakcji.</div>



       # Jak zarejestrować alias do wykorzystania w płatnościach 1-click?

       Transakcję można przetworzyć metodą <a href="#tag/BLIK-API/paths/~1api~1v1~1paymentMethod~1blik~1chargeByCode/post"><b>paymentMethod/blik/chargeByCode</b></a>. Usługa pozwala na przypisanie indywidualnych wartości <b>alias value</b> i <b>alias label</b> w parametrach wejściowych.

       Jeśli w procesie rejestracji transakcji parametr <b>“referenceRegister” = true</b>, to żądanie rejestracji aliasu zostanie przekazane do systemu BLIK, a klient otrzyma zaproszenie, wygenerowane przez aplikacje bankową, do płatności bez kodu T6 w sklepie merchanta.


       Po wywołaniu tej metody, powstanie obciążenie na kwotę przekazaną w rejestracji transakcji i zostanie zarejestrowany alias w systemie P24/BLIK.


       Utworzony alias może być wykorzystywany do przetwarzania płatności typu OneClick.


       Po zarejestrowaniu aliasu, klient nie będzie proszony o wprowadzanie kodu T6 podczas następnych płatności. <br><br><br>


       <img src="getfile/000_blik_rejestracja_aliasu.png" alt="Blik" class="center smallImg"><br><br><br>

        <div id="note">W celu zarejestrowania innej aplikacji mobilnej w systemie BLIK, należy skorzystać z metody <a href="#tag/BLIK-API/paths/~1api~1v1~1paymentMethod~1blik~1chargeByCode/post"><b>paymentMethod/blik/chargeByCode</b></a> wraz z 6-cyfrowym kodem BLIK, wygenerowanym przez aplikację. W systemie P24 transakcja musi być zarejestrowana na ten sam adres e-mail klienta.</div>

        <br>

        <div id="note"> Alias tworzony jest na podstawie adresu e-mail przekazanego w procesie rejestracji. Oznacza to, że o ile nie zostały wykorzystane parametry “aliasValue” i “aliasLabel”, to na ten sam adres e-mail może być zarejestrowany tylko jeden alias danego typu.</div>

        <br>

        <div id="note">Aby zarejestrować więcej niż jeden alias dla danego adresu e-mail, należy skorzystać z alias value i alias label. W ten sposób merchant zapewni, że aliasy są unikalne. Lista aliasów merchanta może być pozyskana za pomocą metody <a href="#tag/BLIK-API/paths/~1api~1v1~1paymentMethod~1blik~1getAliasesByEmail~1{email}/get"><b>getAliasesByEmail</b></a>. Możliwe jest rejestrowanie tego samego aliasu zdefiniowanego przez merchanta dla kilku różnych adresów e-mail. W tym przypadku metoda <a href="#tag/BLIK-API/paths/~1api~1v1~1paymentMethod~1blik~1getAliasesByEmail~1{email}/get"><b>getAliasesByEmail</b></a> zwraca ten sam alias dla każdego z adresów e-mail.</div>

        # Jak wykonać płatność 1-click (tylko 1-click)?

        <a href="#tag/BLIK-API/paths/~1api~1v1~1paymentMethod~1blik~1chargeByAlias/post"><b>ChargeByAlias</b></a> jest metodą płatności typu one click. Pozwala na obciążenie klienta korzystając z uprzednio pozyskanego aliasu. Pozyskany alias musi być przekazany w parametrze  <i><b>methodRefId</i></b> w trakcie rejestracji transakcji(<a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b>transaction/register</b></a>). Ustaw typ <i><b>type=alias</i></b>.<br><br><br>


        <img src="getfile/pl_blik_platnosc_z_aliasem.png" alt="Blik" class="center smallImg"><br>

        # Jak obsłużyć dwie zarejestrowane aplikacje na jeden alias (tylko 1-click)?

        Metoda<a href="#tag/BLIK-API/paths/~1api~1v1~1paymentMethod~1blik~1chargeByAlias/post"><b>ChargeByAlias</b></a> służy do wykonywania obciążeń środków klienta za pomocą wcześniej pobranego aliasu wraz z podaniem <b><i><b>“alternativeKey”</b></b></i>  klucza identyfikującego aplikację mobilną klienta Pojawia się dodatkowy parametr <i><b>"alternativeKey"</b></i>.<br><br>
        Metodę należy wykonywać tylko w przypadku otrzymania odpowiedzi z metody
        <b>chargeByAlias</b> z typem „alias” z kodem błędu 51 i httpcode 409 (Wybrany alias do identyfikacji jest niejednoznaczny!) i z listą alternatywnych kluczy identyfikujących aplikacje mobilne klienta – <i><b>"AliasAlternative"</b></i>.
        <br><br>
        Klient powinien wybrać aplikację mobilną, z której zostanie dokonane obciążenie. Alias powinien zostac wybrany z listy
        the <i><b>"AliasAlternative"</b></i>.
        <br><br>
        Metoda z typem
        <i><b>"alternativeKey"</b></i> ” będzie wykorzystywana tylko w przypadku, gdy klient posiada więcej niż jedną aplikację mobilną podpiętą pod ten sam alias typu UID.
        <br><br>
        Podczas obsługi błędu 51 sprzedawca nie powinien zapisywać alternatywnych kluczy i labeli. Dane te ulegają zmianie na poziomie bank / użytkownik aplikacji bankowej. <br><br><br>

        <img src="getfile/pl_blik_2app_1_alias.png" alt="Blik" class="center smallImg"><br>


        # Jak poradzić sobie z przeterminowanym aliasem (tylko 1-click)?

        <!--Metoda <a href="#tag/BLIK-API/paths/~1api~1v1~1paymentMethod~1blik~1chargeByAlias/post"><b>ChargeByAlias</b></a> pozwala na obciążenie środków klienta, korzystając z uprzednio zarejestrowanego aliasu oraz 6-cyfrowego kodu BLIK, wygenerowanego przez aplikację bankową użytkownika.
        <br><br>
        Metodę z typem <i><b>"blikCode"</b></i> należy wykonywać w przypadku:
       <ol>
        <li> Gdy transakcja zostanie odrzucona z powodu błędu 68 (przedawnienia aliasu klienta). </li>

        <li> Gdy klient, mimo że ma zapamiętany alias wymusi płatność z użyciem kodu BLIK (np. W przypadku gdy chce zarejestrować istniejący alias w innej aplikacji / banku). Należy w takim przypadku podać 6-cyfrowy kod BLIK w celu potwierdzenia autentyczności aliasu.</li></ol><br/>


        <img src="getfile/pl_blik_platnosc_ponowna_t6.png" alt="Blik" class="center smallImg"><br> -->

        Gdy transakcja zostanie odrzucona z powodu błędu 68 (przedawnienia aliasu klienta), należy zarejestrować ponownie transakcję wraz z nowym aliasem - zgodnie z informacjami zawartymi w sekcji o <a href="#section/Jak-zarejestrowac-alias-do-wykorzystania-w-platnosciach-1-click"><b>rejestracji aliasu</b></a>.<br>
        <img src="getfile/pl_blik_wygasniecie_aliasu.png" alt="Blik" class="center smallImg"><br>

       # Jak mogę przetestować BLIK (whitelabel) w Sandbox?

       Aby przetestować płatność BLIK Whitelabel za pomocą kodu T6 w środowisku Sandbox należy użyć 6 cyfrowego kodu BLIK w formacie <b>777XXX</b> dla udanej transakcji gdzie X to dowolna cyfra z zakresu od 0-9. Dla symulacji nieudanej transakcji należy użyć dowolnych 6 cyfr.  Zalecamy również nie korzystanie z tego samego kodu BLIK w krótkich odstępach czasu celem zapewnienia poprawnych odpowiedzi. 

       # Tytuł przelewu widoczny w aplikacji klienta?

       Domyślnie, w aplikacji bankowej klienta, jako główny tytuł widoczny jest numer transakcji P24. Dodatkowe linie pokazują równiez informacje przesłane w parametrze  <b>description</b> w żądaniu <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b>transaction/register</b></a>, jako pomocnicze dane.<br><br>
       Klient może również zobaczyć spersonalizowaną wartość przesłaną przez merchanta, zamiast numeru transkacji P24 w głównym tytule. W tym przypadku żądanie <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b>transaction/register</b></a> powinno zawierać parametr <b>transferLabel</b>, który nadpisze główny tytuł przelewu.<hr>
  - name: BLIK Additional
    x-displayName: Dodatkowa notyfikacja BLIK
    description: >
      Dla dowolnych transakcji realizowanych przez BLIK, została wprowadzona opcjonalna dodatkowa notyfikacja o statusie płatności.<br><br>
      Notyfikacja jest wysyłana na adres z parametru <b>"urlCardPaymentNotification"</b>, który należy dodać do metody<a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b> transaction/register </b></a> lub na stały zapisany adres w konfiguracji konta P24.  Nadrzędna jest wartość z tokenu, jeżeli została przesłana.

      <SchemaDefinition schemaRef="#/components/schemas/bliknotification" />
  - name: Alias Update Notification
    x-displayName: Notyfikacja uaktualnienia aliasu
    description: >
      Dodatkowa notyfikacja może być wysłana na określony adres URL, jeśli status został utworzony lub zmieniony. Adres jest konfigurowany poprzez usługę P24. Notyfikacja może być wykorzystana jako alternatywa do metody <a href="#tag/BLIK-API/paths/~1api~1v1~1paymentMethod~1blik~1getAliasesByEmail~1{email}/get"><b>getAliasesByEmail</b></a>.

      <SchemaDefinition schemaRef="#/components/schemas/blikadnotification" />
####END BLIK####

####CARD####
  - name: Card Description
    x-displayName: Przypadki użycia płatności kartą
    description:  >


      <h2>Wprowadzenie</h2>


      Do realizacji standardowych transakcji kartowych procesowanych poprzez paymentwall P24 wystarczy wykonać standardową integrację (payment service) i nie ma konieczności implementowania poniższych rozwiązań. Opisane poniżej rozwiązania są dodatkowymi funkcjonalnościami kartowymi.


      <div id="note"> 
      
      Funkcjonalności kartowe nie są domyślnie włączone, a ich zakres oraz sposób i możliwości testowania są zależne od Operatora. Skontaktuj się z Działem Obsługi Technicznej poprzez <a href="https://www.przelewy24.pl/centrum-pomocy/wsparcie-techniczne-api/brakuje-odpowiedzi-na-twoje-pytanie"><b>formularz kontaktowy</b></a>, aby uzyskać więcej informacji. 
      
      </div>
      

      # Jak uruchomić płatność kartą wewnątrz sklepu?

      Aby ograniczyć liczbę kroków procesu płatności, można umieścić formularz kartowy bezpośrednio na stronie sklepu. Implementacja rozwiązania nie wpływa na przetwarzanie danych kartowych - dane są nadal przetwarzane wyłącznie przez Przelewy24, co pozwala zachować wszystkie wymagania związane z bezpieczeństwem kart kredytowych i zachowuje zgodność ze standardem PCI DSS.


      <img src="getfile/WHITE_LABEL_1_5.png" alt="Card Payment" class="center smallImg">



      W celu wykonania płatności za pomocą kart płatniczych, konieczne jest zarejestrowanie transakcji w systemie Przelewy24 z użycie metody <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b>transaction/register</b></a>, a następnie przekazanie otrzymanego tokenu do wywołania w skrypcie JS Przelewy24. Dane wprowadzone w formularzu zostaną przekazane bespośrednio do systemu Przelewy24, w wyniku czego aktywowany zostanie skrypt (wskazany w konfiguracji) po stronie sklepu.


      <div id="note"> Do realizacji płatności za pomocą kart po stronie sklepu wymagana jest odpowiednia umowa – proszę o kontakt z Działem Handlowym Przelewy24 poprzez <a href="https://www.przelewy24.pl/centrum-pomocy/sprzedaje-z-przelewy24/metody-platnosci-konto/jak-uruchomic-karty"><b>formularz kontaktowy</b></a>. </div>



      <h2>Proces płatności kartą wewnątrz sklepu </h2>


      <img src="getfile/pl_inshop_card_payment.png" alt="Card payment" class="center smallImg"><br/><br/>


      - Rejestracja transakcji poprzez metodę <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b> transaction/register </b></a> i pobranie Tokenu transakcji

      - Przygotowanie elementu DIV w treści strony, gdzie ma zostać zamieszczony formularz płatności kartą

      - Przygotowanie skryptu Javascript, który zostanie wywołany po zakończeniu transakcji


      <h2> Przygotowanie pola do zamieszczenia formularza rejestracji karty </h2>

      Do przygotowania miejsca na stronie, gdzie ma zostać wyświetlony formularz rejestracji karty można wykorzystać tag DIV. Atrybut ID tego elementu należy ustawić na wartość "P24FormContainer". Kod pola wygląda następująco:


      ```html
        <div
          id="P24FormContainer"
          data-sign="{P24SIGN}"
          data-successCallback="{FinishPaymentFunction}"
          data-failureCallback="{PaymentErrorFunction}"
          data-dictionary='{DICTIONARY JSON}' >
        </div>
      ```


      Gdzie:

      - {P24SIGN} – suma kontrolna taka sama, jak użyta w żądaniu <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b>transaction/register</b></a>

      - {FinishpaymentFunction} – nazwa funkcji wywołanej w przypadku poprawnej transakcji z jednym parametrem wejściowym - ID transakcji (integer) nadanym przez Przelewy24

      - {PaymentErrorFunction} – nazwa funkcji wywołanej w przypadku błędnej transakcji, funkcja przyjmuje jeden parametr - kod błędu (integer)

      - {DICTIONARY JSON} – słownik terminów użytych w formularzu płatności, jak poniżej:


      <SchemaDefinition schemaRef="#/components/schemas/cardpayjson" />


      Skrypt generujący formularz w wewnątrz DIV#P24FormContainer należy załączyć do strony:<br/>

      <table border="0 px">
        <tr>
          <th bgcolor = "#0f6ab4"><font color = "white"><b>GET</b></font></th>
          <th bgcolor = "E7F0F7"><a href= 'https://secure.przelewy24.pl/inchtml/ajaxPayment/ajax.js?token={TOKEN}'>https://secure.przelewy24.pl/inchtml/ajaxPayment/ajax.js?token={TOKEN}</a></th>
        </tr>
      </table>

      Gdzie, w miejsce {TOKEN} należy wstawić Token otrzymany w wyniku działania metody <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b>transaction/register</b></a>. Opcjonalnie można wykorzystać style CSS dla formularza rejestracji karty, lub alternatywnie zastosować własne.

      <br>Adres URL domyślnych styli:<br/>


      <a href="https://secure.przelewy24.pl/inchtml/ajaxPayment/ajax.css">https://secure.przelewy24.pl/inchtml/ajaxPayment/ajax.css</a>


      W przypadku transakcji wymagającej dodatkowej autoryzacji (3DSecure) po wypełnieniu formularza na stronie pojawi się link prowadzący do nowego okna z formularzem autoryzacji (np. wpisanie SMSa wysłanego z banku). Po poprawnej autoryzacji okno zostanie zamknięte i nastąpi wywołanie funkcji Javascript dla poprawnej transakcji.<br/><br/>

      Adres powrotny przekazany w parametrze <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b>"urlReturn"</b></a>  powinien prowadzić do skryptu zamieszczonego na tej samej domenie co skrypt żądania. Powinien on uruchamiać następującą funkcję:

      ```javascript
        window.setTimeout(function(){
        opener.P24_Transaction.threeDSReturn(window);
        window.close();
        },1000);
      ```


      # Jak zarejestrować kartę lub wykonać płatność?

      1. Rejestrację karty należy wykonać jak przy zwykłej płatności.

      Płatność kartą można wykonać na 3 sposoby:

        - <a href="#section/System-platnosci"><b>paymentwall p24</b></a>

        - <a href="#tag/Card-API/paths/~1api~1v1~1card~1pay/post"><b>bezpośrednie API  (card / pay)</b></a> - jeżeli dane kartowe są procesowane przez zasoby Merchanta, rozwiązanie wymaga PCI DSS
        <img src="getfile/white_label_MOBILE_3_a.png" alt="Card Payment" class="center smallImg">



        - <a href="#section/Jak-uruchomic-platnosc-karta-wewnatrz-sklepu"><b>formularz wewnątrz sklepu </b></a>

        <img src="getfile/WHITE_LABEL_1_5.png" alt="Card Payment" class="center smallImg">




      2. Następnie poprzez<a href="#tag/Card-API/paths/~1api~1v1~1card~1info~1{orderId}/get"><b> card/info </b></a> lub <a href="#tag/Card-Notification"><b>dodatkową notyfikację</b></a>, można pobrać informację o karcie, w tym numer referencyjny, niezbędny do późniejszych obciążeń.


      3. Następnie, w zależności od tego, czy chcemy przyjąć płatność, wykonujemy <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1verify/put"><b> transaction/verify </b></a> lub <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1verify/put"><b> transaction/verify </b></a> a następnie <a href="#tag/Additional-API-functionality/paths/~1api~1v1~1transaction~1refund/post"><b> transaction/refund </b></a>, jeżeli była to tylko płatność do próbkowania np. na 1 PLN.

      <img src="getfile/pl_inshop_card_payment.png" alt="card pay" class="center smallImg">


      # Jak pozyskać informacje o karcie?


      Są dwa sposoby na pozyskanie informacji na temat karty:

        - Wywołać metodę <a href="#tag/Card-API/paths/~1api~1v1~1card~1info~1{orderId}/get"><b> card/info </b></a>

        - Obsłużyć dodatkową <a href="#tag/Card-Notification"><b>notyfikację kartową</b></a>


      Dla dowolnych transakcji kartowych notyfikacja może zostać użyta:

        - w procesie <a href="#tag/Card-API/paths/~1api~1v1~1card~1chargeWith3ds/post"><b>card/chargeWith3ds</b></a>, <a href="#tag/Card-API/paths/~1api~1v1~1card~1charge/post"><b>card/charge</b></a>, <a href="#tag/Card-API/paths/~1api~1v1~1card~1pay/post"><b>card/pay</b></a> opartym o REST, aby móc natychmiastowo wyświetlić komunikat klientowi o udanej/nieudanej transakcji
        - w procesie RISK po stronie Partnera, dla sprawdzenia karty klienta i uchronienia się przez fraudami

        - w przypadku zapisywania karty do procesu 1-click, nie ma konieczności dodatkowego wykonywania zapytania o numer referencyjny karty


      <img src="getfile/pl_1_click.png" alt="OneClick" class="center smallImg">


      # Jak wykonać płatność 1-click z 3ds?

      Do tego celu służy dedykowana metoda <a href="#tag/Card-API/paths/~1api~1v1~1card~1chargeWith3ds/post"><b>card/chargeWith3ds</b></a><br><br>
      Numer referencyjny karty musi zostać przekazany podczas rejestracji transakcji w parametrze <b>methodRefId</b>.<br><br>
      Metoda zwróci link do przekierowania klienta i obsłużenia 3ds.<br><br>

      <br><br>
      <img src="getfile/ONE_CLICK_4.png" alt="OneClick" class="center smallImg"><br><br>
      <br><br>

      <img src="getfile/pl_1_click_3ds.png" alt="OneClick 3ds" class="center smallImg">


      # Jak obsłużyć płatności bez udziału klienta (płatności rekurencyjne)?

      Metoda <a href="#tag/Card-API/paths/~1api~1v1~1card~1charge/post"><b>card/charge</b></a> umożliwia rekurencyjne obciążanie karty na podstawie przekazanego numeru referencyjnego. <br><br>
      Numer referencyjny karty musi zostać przekazany podczas rejestracji transakcji w parametrze <b>methodRefId</b>.<br><br>

      Wartość parametru refId otrzymana z transakcji opłaconych przez metody walletowe (np. Google Pay, Apple Pay, VISA Mobile) <b>nie może być zastosowana</b> w płatnościach rekurencyjnych. Próba opłacenia takiej transakcji będzie skutkowała błędem oraz ostatecznie brakiem wpłaty.<br><br>

      Do zainicjowania procesu nie jest wymagany udział klienta.<br><br>

      <img src="getfile/pl_1_click_recurringv1.png" alt="Recurring Charge" class="center smallImg">
      <br><br>

      <img src="getfile/ONE_CLICK_4.png" alt="OneClick" class="center smallImg"><br><br>

      # Jak obsłużyć 3ds (w tym 3ds 2.X)?

      Zarówno 3ds jak i 3ds 2.X obsługiwane są w ten sam sposób. Dla rozwiązania opartego o <a href="#section/System-platnosci"><b>paymentwall p24</b></a> czy formatkę wewnątrz sklepu, 3ds obsługiwany jest automatycznie.      <br><br> 
      
      W przypadku skorzystania z metody <a href="#tag/Card-API/paths/~1api~1v1~1card~1pay/post"><b>card/pay</b></a> lub <a href="#tag/Card-API/paths/~1api~1v1~1card~1chargeWith3ds/post"><b>card/chargeWith3ds</b></a> przekierowanie należy wykonać samemu, na adres URL uzyskany z odpowiedzi.<br><br>
      Pamiętaj, że po wykonaniu 3ds, klient zawsze zostanie przekierowany na stronę <b>urlReturn</b>. Merchant musi przeprocesowac powrót klienta ze strony banku do sklepu. Zwrócony link jest aktywny przez 15 minut.<br><br>

      # Jak zarejestrować kartę lub zapłacić w aplikacji mobilnej?

      Rejestrację karty lub płatność w aplikacji mobilnej można dokonać na dwa sugerowane sposoby. Można otworzyć <a href="#section/System-platnosci"><b>paymentwall p24</b></a> w WebView, najlepiej z wymuszoną formą płatności dla danych kart. Innym sposobem jest wykorzystanie metody  <a href="#tag/Card-API/paths/~1api~1v1~1card~1pay/post"><b>card/pay</b></a>. Należy pamiętać, aby metoda <a href="#tag/Card-API/paths/~1api~1v1~1card~1pay/post"><b>card/pay</b></a> była wywołana bezpośrednio z aplikacji do P24 bez udziału serwerów Merchanta. W innym przypadku niezbędne będzie posiadanie certyfikatu PCI DSS.


      # Jak przetestować karty w środowisku Sandbox?

      Aby przetestować płatność kartą w środowisku testowym należy skorzystać z numerów kart z <b><a href="https://docs.saferpay.com/home/integration-guide/testing-and-go-live#visa-and-v-pay" target="_blank">dokumentacji Saferpay</a></b> oraz dowolnej daty jako expiry date z przyszłości i losowego 3-cyfrowego CVV. 
      <br><br>
      Do testowania Google Pay zalecamy dołączenie do grupy developerskiej <b><a href="https://groups.google.com/g/googlepay-test-mode-stub-data?pli=1" target="_blank">Google Google Pay API Test Cards Allowlist - Google Groups</a> </b>. 
      <br><br>
      Po dołączeniu do grupy, do konta Google przypisanych zostanie kilka numerów kart testowych (od Google) wybieralnych po wciśnięciu przycisku do płatności Google Pay. 
      <br><br>
      Należy pamiętać, że usługi kartowe nie są domyślnie uruchomione dla środowiska produkcyjnego jak i środowiska Sandbox. 

      # Czy Merchant będzie przetwarzał pełne dane karty?

      Do przetwarzania pełnych danych kartowych niezbędny jest certyfikat PCI DSS. Rozwiązania P24 wspierają operacje wykonywane w ten sposób.<br><br>
      Jednakże istnieje szereg rozwiązań zapewniających merchantowi pełną funkcjonalność kartową, w których nie będzie posługiwał się pełnymi danymi kartowymi i nie ma potrzeby posiadania PCI DSS. W takich sytuacjach Merchant pozyskuje jedynie numer referencyjny karty służący, np. do późniejszych obciążeń typu 1-click czy recurring, oraz zestaw niewrażliwych danych, tj. data ważności czy BIN.<br><br><hr>

  - name: Card Notification
    x-displayName: Dodatkowa notyfikacja kartowa
    description:  >

         Notyfikacja jest wysyłana na adres z parametru <b>"urlCardPaymentNotification"</b>, który należy dodać do metody<a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b> transaction/register </b></a> lub na stały zapisany adres w konfiguracji konta P24.  Nadrzędna jest wartość z tokenu, jeżeli została przesłana.

          **Parametry dla pozytywnej autoryzacji**

          <SchemaDefinition schemaRef="#/components/schemas/CardNotificationExt" />

          **Parametry dla negatywnej autoryzacji**

          <SchemaDefinition schemaRef="#/components/schemas/CardNotificationExtN" />
  - name: Card API
    x-displayName: Karty API
####END CARD####

####GPAY####
  - name: GPay Description
    x-displayName: Opis Google Pay
    description:  >

      <img src="getfile/Gpay_logo.png" alt="GPay" class="center smallImg">


      Google Pay to szybki i prosty sposób płatności od Google. Dane karty są przechowywane bezpiecznie na serwerach firmy Google i pozwalają użytkownikowi wykonać proces płatności bez potrzeby manualnego wypełniania formularza kartowego lub kontaktowego.

      <br><br>
      Google Pay to produkt pozwalający na uzyskanie zaszyfrowanych danych karty płatniczej klienta umożliwiających obciążenie. Aby wykonać płatność przez Google Pay klient wcześniej musi zapisać kartę płatniczą pod swoim kontem Google, używając jakiejkolwiek platformy Google (np. kupując aplikację w Google Play, płacąc za przestrzeń dyskową na Google Drive, przypisując kartę do swojego konta AdWords) lub bezpośrednio na stronie  <a href="https://pay.google.com">https://pay.google.com</a>
      <br><br>
      <div id="note"> Usługa wymaga wcześniejszego podpisania umowy z operatorem kartowym. Aby uruchomić funkcjonalność, proszę o kontakt Biurem Obsługi Klienta poprzez <a href="https://www.przelewy24.pl/centrum-pomocy/sprzedaje-z-przelewy24/metody-platnosci-konto/jak-uruchomic-karty"></b>formularz kontaktowy</b></a>. </div><br>

      <img src="getfile/ONE_CLICK_33.png" alt="GPay" class="center smallImg">

      ## Schemat komunikacji Google Pay
        Po kliknięciu w przycisk "Zapłać z Google Pay" klientowi pojawia się na ekranie formatka Google Pay, na której potwierdza swoje konto Google i kartę, którą ma zamiar zapłacić (może również na tym etapie zmienić kartę na inną wcześniej zapisaną, lub dodać nową). Skrypt w tle przekazuje zakodowane dane karty przez funkcję postMessage, którą sklep musi przejąć, a następnie zakodować przez funkcję base64 ponownie i przesłać w parametrze methodRefId wraz z danymi transakcji.<br><br>

        Sklep na swojej stronie musi wywołać skrypt udostępniony przez Google. Szczegóły dostępne pod adresem&#x3A;<br><br>
        <a href=https://developers.google.com/pay/api/web/guides/tutorial>https://developers.google.com/pay/api/web/guides/tutorial</a><br><br>

        Aby dodać Przelewy24 należy w wywołaniu skryptu zmodyfikować dane Procesora&#x3A;

        ```javascript
          var tokenizationSpecification =
          {
          tokenizationType: 'PAYMENT_GATEWAY',
          parameters:
            {
              gateway: 'przelewy24',
              gatewayMerchantId: '[MerchantID from P24]'
            }
          }
        ```
      ## Rejestracja transakcji

        Rejestracja transakcji przez Google Pay polega na dodaniu dodatkowego parametru <b>"methodRefId"</b> z danymi otrzymanymi z Google przez **postMessage (paymentMethodToken.token)** i zakodowaniu ich funkcją base64.

        <table border="0 px">
          <tr>
            <th bgcolor = "#9FFF9F"><font color = "black"><b>POST</b></font></th>
            <th bgcolor = "#B8F0D0"><a href= 'https://secure.przelewy24.pl/api/v1/transaction/register'>https://secure.przelewy24.pl/api/v1/transaction/register</a></th>
          </tr>
          </table>

        Dodatkowy parametr <b>POST</b> wywołania

        | Field name   |      Type      |  Required | Description |
        |--------------|:--------------:|----------:|------------:|
        | methodRefId  |     STRING     | Y     |Token otrzymany z Google Pay zakodowany funkcją base64|

        Przed wysłaniem żądania transakcji należy zapisać jej dane do lokalnej bazy danych sprzedawcy. W szczególności należy zachować informacje o identyfikatorze sesji i kwocie transakcji.
      ## Implementacja dla systemu Android
        Aby zaimplementować Google Pay na urządzeniach z systemem Android zapoznaj się z dokumentacja Google Pay API:
        [https://developers.google.com/pay/api/android](https://developers.google.com/pay/api/android)

      ## Informacje dodatkowe
        Dla uspójnienia stylistyki stosowanej na stronie www oraz w aplikacji mobilnej udostępniony został zestaw dedykowanych wskazówek:
        [https://developers.google.com/pay/api/web/guides/brand-guidelines](https://developers.google.com/pay/api/web/guides/brand-guidelines)

        Zalecenia do tworzenia aplikacji mobilnych dostępne sa pod adresem:
        [https://developers.google.com/pay/api/android/guides/tutorial](https://developers.google.com/pay/api/android/guides/tutorial)

    x-codeSamples:
        - lang: javascript
          source: |
            <head>
              <meta charset="UTF-8">
              <meta name="viewport"
                    content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
              <meta http-equiv="X-UA-Compatible" content="ie=edge">
              <title>PayWithGoogle</title>
              <script src="https://secure.przelewy24.pl/bundle/payWithGoogle/{{TOKEN}}"></script>
            </head>
            <body>
            <script>
              document.addEventListener("DOMContentLoaded", function () {
                  Przelewy24PayWithGoogle.config({
                      errorCallback: function () {
                          alert("error");
                      },
                      exceptionCallback: function () {
                          alert("exception");
                      },
                      requestFailedCallback: function () {
                          alert('requestFailed');
                      },
                      completePaymentCallback: function () {
                          alert("success");
                      }
                  });
                  Przelewy24PayWithGoogle.charge();
              });
            </script>
            </body>
  - name: GPay API
    x-displayName: Google Pay API
####END GPAY####

####APAY####
  - name: APay Description
    x-displayName: Apple Pay
    description:  >

      <img src="getfile/Apple_Pay.png" alt="ApplePay" class="center smallImg">

      <h2>Wprowadzenie</h2>
      Dzięki Apple Pay nie musisz zakładać żadnych kont ani wypełniać długich formularzy podczas zakupów na stronach internetowych otwartych w Safari na iPhonie, iPadzie lub Macu. A ponieważ czytnik Touch ID dostępny jest też w MacBooku Air i MacBooku Pro, finalizacja transakcji wymaga tylko przyłożenia palca i jest szybsza, łatwiejsza i bezpieczniejsza niż dotąd.<br><br>

      <img src="getfile/white_label_MOBILE_6_a.png" alt="APay" class="center smallImg">


      ## Opis

      Podczas zakupów Apple Pay wykorzystuje numer przypisany konkretnemu urządzeniu i unikalny kod transakcji. Dzięki temu numer Twojej karty nigdy nie jest przechowywany ani na Twoim urządzeniu, ani na serwerach Apple. A w chwili dokonywania płatności Apple nigdy nie udostępnia numerów kart sprzedawcom

      <div id="note">Usługa wymaga wcześniejszego podpisania umowy z operatorem kartowym (po szczegółowe informacje należy kierować pytania do Działu Handlowego Przelewy24).</div>


      ## Tworzenie Merchant ID i certyfikacja domeny

      Procesowanie transakcji poprzez ApplePay wymaga od Sprzedawcy utworzenia merchanta, oraz przejścia certyfikacji domeny. Proces opisany jest pod adresem <a href="https://developer.apple.com/documentation/apple_pay_on_the_web/configuring_your_environment">https://developer.apple.com/documentation/apple_pay_on_the_web/configuring_your_environment</a>.


      ## Tworzenie Apple Pay Payment Processing Certificate

      <div id="note">	Przed przystąpieniem do procesu tworzenia certyfikatu należy pozyskać plik CSR (po szczegółowe informacje należy kierować pytania do Działu Wdrożeń Przelewy24 poprzez <a href="https://www.przelewy24.pl/centrum-pomocy/wsparcie-wdrozeniowe"><b>formularz kontaktowy</b></a>).</div>
      <br>
      Po zalogowaniu się do swojego konta Apple Developer należy:

      - wybrać opcję Certificates, IDs & Profiles,<br/>
      - wybrać opcję Identifiers/Merchant IDs,<br/>
      - wybrać utworzony w poprzednim kroku Merchant ID i przejść do opcji Edit,<br/>
      - wybrać opcję Create Certificate w sekcji Apple Pay Payment Processing Certificate,<br/>
      - wybrać opcję Continue,<br/>
      - załadować plik CSR otrzymany od Działu Wdrożeń Przelewy24, korzystając z opcji Choose File,<br/>
      - pobrać wygenerowany certyfikat i przekazać go do Działu Wdrożeń Przelewy24.<br/>


      ## Schemat komunikacji Apple Pay

      Po kliknięciu w przycisk "ApplePay" klientowi pojawia się na ekranie formatka Apple, na której może wybrać zapisaną na urządzeniu kartę. Skrypt w tle przekazuje zakodowane dane karty w obiekcie paymentData, którą sklep musi przejąć, a następnie zakodować przez funkcję base64 ponownie i przesłać w parametrze <b>methodRefId</b> wraz z danymi transakcji.

      Sklep na swojej stronie musi wywołać skrypt udostępniony przez Apple (szczegóły dostępne pod adresem: <a href="https://developer.apple.com/documentation/apple_pay_on_the_web">https://developer.apple.com/documentation/apple_pay_on_the_web</a>).


      Skrypt w tle przekazuje zakodowane dane karty, którą sklep musi przejąć, a następnie zakodować przez funkcję base64 ponownie i przesłać w parametrze <b>methodRefId</b> wraz z danymi transakcji.

      ## Rejestracja transakcji

        Rejestracja transakcji przez ApplePay polega na dodaniu dodatkowego parametru <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b>"methodRefId"</b></a>. Parametr może zostać uzyskany z Apple poprzez **postMessage (paymentMethodToken.token)** i powinien być zakodowany funkcją base64.

        <table border="0 px">
          <tr>
            <th bgcolor = "#9FFF9F"><font color = "black"><b>POST</b></font></th>
            <th bgcolor = "#B8F0D0"><a href= 'https://secure.przelewy24.pl/api/v1/transaction/register'>https://secure.przelewy24.pl/api/v1/transaction/register</a></th>
          </tr>
        </table>

        Additional **POST** call parameter

        | Field name   |      Type      |  Required | Description |
        |--------------|:--------------:|----------:|------------:|
        | methodRefId  |     STRING     | Y     |Token otrzymany z ApplePay zakodowany funkcją base64 |

        ##  Informacje dodatkowe

        W celu uspójnienia stylistyki stosowanej na stronie www oraz w aplikacji mobilnej dostępne są wskazówki, których należy się trzymać przy wdrażaniu usługi ApplePay.
        Opisy styli oraz oraz przycisków dla stron www dostepne są pod adresem <a href="https://developer.apple.com/apple-pay/acceptable-use-guidelines-for-websites/">https://developer.apple.com/apple-pay/acceptable-use-guidelines-for-websites/</a>.
  - name: APay API
    x-displayName: Apple Pay API
####END APAY####

####SYSTEM PŁATNOŚCI####
  - name: System płatności
    description: >

      Serwis Przelewy24 prowadzi system autoryzacji i rozliczeń oraz świadczy usługi płatnicze w charakterze krajowej instytucji płatniczej. <br/><br/>

      Poprzez API Przelewy24 możesz uzyskać dostęp do wszystkich usług oferowanych przez system. Poniższa dokumentacja zawiera najczęściej wykorzystywane funkcjonalności. Skontaktuj się z [Działem Handlowym](https://www.przelewy24.pl/pomoc/formularz-kontaktowy), aby poznać inne funkcjonalności. <br/><br/>

      Aby uzyskać dostęp do API Przelewy24, w pierwszej kolejności [załóż konto](https://panel.przelewy24.pl/rejestracja.php) w Panelu Administracyjnym P24.

      Po dokonanej rejestracji, sprzedawca ma możliwość śledzenia w panelu administracyjnym stanu swojego konta, wszystkich płatności klientów oraz wykonanych zwrotów na bieżąco. <br/>

      ## Przebieg transakcji

      Klient po skompletowaniu zamówienia klika na przycisk **"zapłać"**. System Sprzedawcy przesyła żądanie <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b>rejestracji transakcji</b></a> do systemu P24 i otrzymuje zwrotnie unikalny TOKEN. Następnie klient jest przekierowany na panel transakcyjny P24. <br/><br/>

      W przypadku anulowania płatności klient jest przekierowany na adres **“urlReturn"**.
      <br/><br/>
      Po poprawnej transakcji Klient jest kierowany na adres podany w parametrze **“urlReturn”**. System P24 wysyła <a href="#tag/Notification"><b>potwierdzenie transakcji</b></a> na adres podany w parametrze **"urlStatus"**. Notyfikacja z potwierdzeniem transakcji jest wysyłana w sposób **asynchroniczny**.
      <br/><br/>
      Dla potwierdzenia wiarygodności otrzymanego potwierdzenia w odpowiedzi na potwierdzenie wpłaty system sprzedawcy weryfikuje wynik <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1verify/put"><b>żądaniem zwrotnym</b></a>.
      <br/><br/>

      <img src="getfile/pl_payment_process.png" alt="Payment process" class="center smallImg">

      ## Wymagania programowe

      Aby prawidłowo przeprowadzić transakcję sprzedawca na swoich stronach WWW musi wprowadzić niżej opisaną obsługę wysyłania żądania transakcji oraz odbiór odpowiedzi o wyniku transakcji. <br/><br/>
      Cały proces przebiega w sposób automatyczny bez konieczności ingerencji obsługi sklepu w proces płatności. <br/><br/>
      Po poprawnie zakończonym procesie płatności status danego zamówienia w sklepie powinien automatycznie zmienić się na zapłacone/przyjęte do realizacji. W tym momencie obsługa sklepu może przystąpić do realizowania zamówienia.<br/><br/>

      <br><br>

      <img src="getfile/pl_transaction_process.png" alt="Environment" class="center smallImg">

####END SYSTEM PŁATNOŚCI####

####DEFINICJE####
  - name: Definicje
    description: >

      **CVV** – kod zabezpieczający karty.


      **Cyclic Redundancy Check (CRC)** – unikatowy klucz (String) otrzymany od Przelewy24 służący do generowania przesyłanej sumy kontrolnej.


      **Dynamic Currency Conversion (DCC)** –  proces, w którym kwota transakcji jest przeliczana na walutę karty płatnika.


      **Merchant** – firma lub osoba prywatna korzystająca z serwisu Przelewy24.


      **Session ID** – unikalny identyfikator służący do zidentyfikowania pojedynczej transakcji w systemie partnera.


      **Web Service** – endpoint, protokół, standard struktury informacji stosowany do wymiany danych między systemami.
####END DEFINICJE####

####PRZYPADKI UŻYCIA####
  - name: Przypadki użycia
    description: >

      ## Jak wyświetlić w sklepie pełen wybór metod płatności?

      Aby uprościć proces płatności, możliwe jest przeniesienie wyboru formy płatności przez klienta już na etapie składania zamówienia w sklepie.
      Jeżeli dodatkowo w sklepie klient zaakceptuje warunki regulaminu Przelewy24 (w żądaniu należy ustawić <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b>regulationAccept = true</b></a>), zostanie on po kliknięciu przycisku „zapłać”, przeniesiony bezpośrednio ze strony sklepu do banku / formularza kart płatniczych. Na stronie sklepu należy umieścić i wyświetlić klientowi następującą treść:<b> „Oświadczam, że zapoznałem się z [regulaminem](https://www.przelewy24.pl/regulamin) i [obowiązkiem informacyjnym](https://www.przelewy24.pl/obowiazek-informacyjny-platnik) serwisu Przelewy24”</b>. Pod słowem regulamin i obowiązek informacyjny musi być link do stron z tymi dokumentami. Checkbox nie może być odgórnie zaznaczony.<br><br>

      Aby pobrać liste płatności, skorzystaj z metody <a href="#tag/Additional-API-functionality/paths/~1api~1v1~1payment~1methods~1%7Blang%7D?amount=150&currency=PLN/get"><b>PaymentMethods</b></a>, opisanej w Dodatkowych Usługach.

      <img src="getfile/white_label1_14.png" alt="Payment Methods" class="center smallImg"><br>

      Pobraną listę można w dowolny sposób zaprezentować na swojej stronie.

      ## Jak przekierować klienta do konkretnej metody płatności?

      W celu przekierowania klienta bezpośrednio do wybranej metody płatności, należy przekazać identyfikator danej metody w polu <b>method</b> w żądaniu rejestracji transakcji. Dla przykładu, przy przekierowaniu do metody mTransfer, żądanie wygląda w ten sposób:

      ```json
          {
            "merchantId": {{merchantId}},
            "posId": {{posId}},
            "sessionId": "{{sessionId}}",
            "amount": {{amount}},
            "currency": "{{currency}}",
            "description": "{{description}}",
            "email": "{{email}}",
            "country": "PL",
            "language": "pl",
            "method": {{method}},
            "urlReturn": "{{urlReturn}}",
            "sign": "{{sign}}",
          }
      ```

      ## Jak ograniczyć klientowi czas dostępny na zrealizowanie płatności?

      W zależności od specyfiki danego systemu, może zachodzić potrzeba ograniczenia czasu, jaki klient ma na zrealizowanie płatności.  Do sterowania tym elementem służy parametr <b>timeLimit</b>. Ustawienie tego parametru na wartości z zakresu 1 - 99 określi limit czasu w minutach. Ustawienie parametru na 0 oznacza brak limitu.

      ## Jak umożliwić płynny powrót klienta do sklepu, bez konieczności oczekiwania na synchroniczne potwierdzenie płatności?

      W przypadku niektórych metod płatności, w szczególności e-przelewów, wykonana płatność zostaje potwierdzona w ciągu kilku minut. Istnieje możliwość "pozostawienia" klienta w serwisie transakcyjnym w celu oczekiwania na wynik transakcji i przekierowania go z powrotem do sklepu dopiero po otrzymaniu potwierdzenia (w ten sposób sklep będzie już posiadał potwierdzenie płatności) lub można od razu przekierować klienta do sklepu, bez oczekiwania na wynik transakcji. Wybór jednego z dwóch wariantów jest sterowany parametrem <a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post"><b>waitForResult</b></a>. Wariant pierwszy wymaga ustawienia tego parametru na "true", wariant drugi na "false".

      ## Jak zrealizować zwrot transakcji do klienta?

      Realizacja zwrotów, jak wszystkie inne usługi w Przelewy24 jest w pełni automatyczna i realizowana jest poprzez narzędzie w panelu administracyjnym Przelewy24 lub przez metodę <a href="#tag/Additional-API-functionality/paths/~1api~1v1~1transaction~1refund/post"><b>transaction/refund</b></a>. <br/><br/>

      Do jednej transakcji można zlecić wiele żądań zwrotu, jednak sumaryczna wartość zwrotów nie może przekroczyć pierwotnej wartości transakcji.

      ## Czy po wygaśnięciu sesji klient może dokończyć proces płatności?

      W sytuacji, gdy klient porzuci proces płatności, np. po przejściu na stronę banku, aby ułatwić mu dokończenie transakcji system Przelewy24 oferuje możliwość automatycznego wysłania do klienta maila z linkiem do dokończenia rozpoczętego procesu. Jeżeli klient skorzysta z tej opcji z punktu widzenia sklepu nie będzie różniło się to niczym od transakcji zrealizowanej w trybie on-line. <br><br>

      Aby włączyć taką funkcjonalność należy skontaktować się z opiekunem handlowym poprzez <a href="https://www.przelewy24.pl/centrum-pomocy/sprzedaje-z-przelewy24/metody-platnosci-konto/brakuje-odpowiedzi-na-twoje-pytanie"><b>formularz kontaktowy</b></a>.

####MATERIAŁY GRAFICZNE####
  - name: Materiały graficzne
    description: >

      P24 logo i bannery dostępne sa pod adresem:

      [https://www.przelewy24.pl/do-pobrania#materialy-graficzne](https://www.przelewy24.pl/do-pobrania#materialy-graficzne)
####END MATERIAŁY GRAFICZNE####

####WYTYCZNE API####
  - name: Wytyczne API
    description: >

      Prosimy o wykonanie poniższych kroków w celu zagwarantowania sprawnego działania płatności Przelewy24.

      ## Zweryfikowanie konfiguracji hostingu

      <b>Zalecamy korzystanie z systemu operacyjnego oraz PHP w wersji 64 bit, ze względu na większe możliwości obliczeniowe oraz większą wydajność.</b>

      W celu zweryfikowania wersji systemu operacyjnego, wersji PHP można wykorzystać m.in. kod phpinfo

      <a href="https://www.php.net/manual/en/function.phpinfo.php#refsect1-function.phpinfo-examples" target="_blank">https://www.php.net/manual/en/function.phpinfo.php#refsect1-function.phpinfo-examples</a>


      ```php
          <?php
          // Show all information, defaults to INFO_ALL
            phpinfo();

          // Show just the module information.
          // phpinfo(8) yields identical results.
            phpinfo(INFO_MODULES);
          ?>
      ```

      Następnie należy zapisać plik jako rozszerzenie PHP i wejść w ścieżkę / adres URL, na którym jest hostowany plik.

      Tak utworzony plik musi zostać umieszczony na Państwa hostingu internetowym - <b>adres tego pliku nie powinien być nikomu udostępniany</b>.

      <b><font color = "#DB2053">PAMIĘTAJ!</font><br>Po weryfikacji umieszczony plik powinien zostać usunięty z serwera.</b>

      ## Zakresy graniczne typu INT signed / unsigned

      Zakres INT signed = -2,147,483,648 do 2,147,483,647  


      Zakres INT unsigned = 0 do 4294 967 295  


      Zakres BIGINT singed = -9223372036854775808 do 9223372036854775807  


      Zakres BIGINT unsigned = 0 do 18446744073709551615  



      <br><b><font color = "#DB2053">PAMIĘTAJ!</font></b><br><b>Jeśli korzystają Państwo z OS lub PHP w wersji 32bit, to kod aplikacji może interpretować wartość większą niż (2147483647 - maksymalna wartość INT signed) jako typ float - co może spowodować problemy w procesowaniu płatności.</b>


      ```php
          $large_number = 2147483648;
          var_dump($large_number); // float(2147483648)
      ```


      <br><b>W takim przypadku należy zmienić zakres na BIGINT, w celu dopuszczenia wartości większej niż maksymalna wartość zakresu INT signed.</b>


      ## Baza danych
      
      Jeśli przechowują Państwo w bazie danych wartość order_id - ID zamówienia z systemu Przelewy24, prosimy o zweryfikowanie, czy ustawiony typ kolumny dopuści zapis/odczyt wartości większej niż maksymalna wartość INT signed = 2147483647.  


      <br><b>W takim przypadku należy zmienić zakres na BIGINT, w celu dopuszczenia wartości większej niż maksymalna wartość zakresu INT signed.</b>


      ## Rzutowanie parametru order_id

      Należy sprawdzić, czy Państwa kod aplikacji dopuści do zapisu/odczytu wartość większą niż maksymalną wartość tj. INT signed = 2147483647.  

      
      <br><b>W takim przypadku należy zmienić zakres na BIGINT, w celu dopuszczenia wartości większej niż maksymalna wartość zakresu INT signed</b>


      ## Środowiska programistyczne

      <h3> Środowisko produkcyjne </h3>

      Każde żądanie rozróżnione jest swoim własnym, unikalnym adresem URL. W ten sposób system P24 wie, z której funkcji API chcesz skorzystać. W połączeniu z bazowym adresem URL, dla za równo produkcyjnego jak i testowego środowiska, otrzymasz kompletny adres API-URL.


      Bazowy URL systemu produkcyjnego:<br/>
      https://secure.przelewy24.pl/api/v1


      Transakcje produkcyjne będą widoczne w panelu<br/>
      https://panel.przelewy24.pl/index.php

      <h3> Środowisko testowe </h3> 

      Podczas implementowania mechanizmów w Twoim systemie możesz skorzystać ze środowiska testowego. Środowisko to umożliwia zweryfikowanie poprawności instalacji bez konieczności dokonywania przelewów. <br><br>
      Adresy URL do połączeń do środowiska testowego: <br>
      https://sandbox.przelewy24.pl/api/v1<br><br>

      Transakcje testowe będą widoczne w panelu testowym:<br>
      https://sandbox.przelewy24.pl/panel/index.php<br><br>

      <b><u>Środowisko testowe nie może być wykorzystywane do realizacji transakcji produkcyjnych.</u></b>


      ## Adresy IP serwerów

      Zalecamy zabezpieczenie skryptów przed podejrzanymi wywołaniami, stosując filtrację adresów IP dla przychodzących połączeń. Zakresy IP serwerów Przelewy24 to: <br><br>
      <font class = "right"><b>5.252.202.255 , 5.252.202.254</b></font><br>
      <font class = "right"><b>20.215.81.124</b></font><br>


      ## Wymagania środowiskowe

      Transport Layer Security - TLS 1.2 (wymagane minimum)<br/><br/>

      https://wiki.mozilla.org/Security/Server_Side_TLS<br/>
      https://en.wikipedia.org/wiki/Transport_Layer_Security
      <br><br>

      OpenSSL 1.0.1 (wymagane minimum)<br/><br/>  https://www.openssl.org/news/changelog.html#x31<br><br>

      cURL 7.34.0<br/><br/> https://curl.haxx.se/docs/manpage.html#--tlsv12

      ## Możliwe kody błędów

        | ErrorCode | Opis                                                                                                                                                 |
        |-----------|------------------------------------------------------------------------------------------------------------------------------------------------------|
        | err00     | Nieprawidłowe wywołanie skryptu                                                                                                                      |
        | err01     | Nie uzyskano od sklepu potwierdzenia odebrania odpowiedzi autoryzacyjnej                                                                             |
        | err02     | Nie uzyskano odpowiedzi autoryzacyjnej                                                                                                               |
        | err03     | To zapytanie było już przetwarzane                                                                                                                   |
        | err04     | Zapytanie autoryzacyjne niekompletne lub niepoprawne                                                                                                 |
        | err05     | Nie udało się odczytać konfiguracji sklepu internetowego                                                                                             |
        | err06     | Nieudany zapis zapytania autoryzacyjnego                                                                                                             |
        | err07     | Inna osoba dokonuje płatności                                                                                                                        |
        | err08     | Nieustalony status połączenia ze sklepem.                                                                                                            |
        | err09     | Przekroczono dozwoloną liczbę poprawek danych.                                                                                                       |
        | err10     | Nieprawidłowa kwota transakcji!                                                                                                                      |
        | err49     | Zbyt wysoki wynik oceny ryzyka transakcji.                                                                                                           |
        | err51     | Nieprawidłowe wywołanie strony                                                                                                                       |
        | err52     | Błędna informacja zwrotna o sesji!                                                                                                                   |
        | err53     | Błąd transakcji !                                                                                                                                    |
        | err54     | Niezgodność kwoty transakcji!                                                                                                                        |
        | err55     | Nieprawidłowy kod odpowiedzi!                                                                                                                        |
        | err56     | Nieprawidłowa karta                                                                                                                                  |
        | err57     | Niezgodność flagi TEST!                                                                                                                              |
        | err58     | Nieprawidłowy numer sekwencji!                                                                                                                       |
        | err59     | Nieprawidłowa waluta transakcji!                                                                                                                     |
        | err101    | Błąd wywołania strony W żądaniu transakcji brakuje któregoś z wymaganych parametrów lub pojawiła się niedopuszczalna wartość.                        |
        | err102    | Minął czas na dokonanie transakcji                                                                                                                   |
        | err103    | Nieprawidłowa kwota przelewu                                                                                                                         |
        | err104    | Transakcja oczekuje na potwierdzenie.                                                                                                                |
        | err105    | Transakcja dokonana po dopuszczalnym czasie                                                                                                          |
        | err161    | Żądanie transakcji przerwane przez użytkownika Klient przerwał procedurę płatności wybierając przycisk "Powrót" na stronie wyboru formy płatności.   |
        | err162    | Żądanie transakcji przerwane przez użytkownika Klient przerwał procedurę płatności wybierając przycisk "Rezygnuj" na stronie z instrukcją płatności. |

####END WYTYCZNE API####

####AUTHENTICATION####
  - name: Authentication
    description: >

      P24 wspiera mechanizmy Basic Authentication.

      <!-- Redoc-Inject: <security-definitions> -->
####END AUTHENTICATION####

####INTEGRACJA####
  - name: Środowisko produkcyjne i sandbox
    description: >

      ## Rejestracja konta produkcyjnego

      Zarejestruj swoje konto w serwisie Przelewy24 - <a href="https://panel.przelewy24.pl/rejestracja.php" target="_blank">link</a><br><br>
      <img src="getfile/registration_pl.png" alt="Rejestracja konta produkcyjnego" class="center smallImg">

      ## Konfiguracja konta testowego (sandbox)

      Skonfiguruj konto sandbox. Jedynie mając dostęp do serwisu produkcyjnego masz możliwość uruchomienia konta sandbox. Z menu głównego wybierz <b>'Moje konto'</b>, a następnie <b>'Konto w SANDBOX'</b>.<br><br>
      <img src="getfile/sandbox-conf_pl.png" alt="Konfiguracja konta testowego (sandbox)" class="center smallImg">

      ## Konfiguracja konta użytkownika i członków zespołu

      Jeżeli zachodzi potrzeba, skonfiguruj konta członków zespołu - pozwoli to na odrębny dostęp do serwisu Przelewy24 z nadaniem odpowiednich ról użytkownikom w zależności od potrzeb.<br><br>
      <img src="getfile/user-conf_pl.png" alt="Konfiguracja konta użytkownika" class="center smallImg">

      ## Integracja API

      Skonfiguruj dostęp do konta, korzystając z danych uwierzytelniających API (wersja produkcyjna i sandbox serwisu Przelewy24):<br>
        <b>- user</b> (posId/login) - ID konta Przelewy24 - wysyłane w mailu potwierdzającym pomyślną rejestrację konta<br>
        <b>- CRC</b> - klucz CRC używany do wyliczania sign<br>
        <b>- secretId</b> (klucz API) - 'klucz do raportów'.
      <br><br>
      (wersja produkcyjna Przelewy24)
      <img src="getfile/creds-prod_pl.png" alt="Dane uwierzytelniające - wersja produkcyjna Przelewy24" class="center smallImg">
      (wersja sandbox Przelewy24)
      <img src="getfile/creds-sand_pl.png" alt="Dane uwierzytelniające - wersja sandbox Przelewy24" class="center smallImg">
      
      ## Testowanie połączenia API
      
      Korzystając z endpointu <a href="#tag/Transaction-service-API/paths/~1api~1v1~1testAccess/get">TestAccess</a> oraz danych dostępu (user oraz secretId), przetestuj połączenie.

      ## Adres IP i domyślne Web Service
      
      Uzupełnij pole 'Adres IP' (<b>'Moje konto'</b> - <b>'Moje dane'</b> - <b>'Dane API i konfiguracja'</b>), pod którym znajdują się Twoje zasoby, celem dostępu do Web Service Przelewy24.<br>
      Domyślne serwisy to:<br>
      <ul>
        <li><a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1register/post">TransactionRegister</a></li>
        <li><a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1verify/put">TransactionVerify</a></li>
        <li><a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1refund/post">TransactionRefund</a></li>
        <li><a href="#tag/Transaction-service-API/paths/~1api~1v1~1payment~1methods~1%7Blang%7D?amount=150&currency=PLN/get">PaymentsMethods</a></li>
        <li><a href="#tag/Transaction-service-API/paths/~1api~1v1~1transaction~1by~1sessionId~1%7BsessionId%7D/get">GetTransactionBySessionId</a>.</li>
      </ul>
      By włączyć inne niż domyślne, wymienione w specyfikacji, prośba o kontakt z opiekunem klienta.
####END INTEGRACJA####

####JAK ZINTEGROWAC RATY####

  - name: Buttony i bannery
    x-displayName: "Buttony i bannery"
    description: >
      


      ### Raty - wstęp

    
      Rozwiązania finansujące mogą być sposobem na zwiększenie obrotów i zmniejszenie odsetka porzucanych koszyków w Twoim sklepie. Jednak samo włączenie rat online na formatce płatniczej nie zadziała (albo zadziała w… mocno ograniczonym zakresie). 


      Kluczem do tego, by wykorzystać potencjał rat online jest ich właściwa ekspozycja w sklepie. Z tego przewodnika dowiesz się, jak to zrobić.


      Minimalizm to dobra praktyka w zakresie UX, ale zapomnij o nim, gdy chcesz, aby Twoi klienci wybierali płatność na raty. Jeśli chcesz dotrzeć do kupujących, którzy wybierają tę metodę opłacenia zamówienia, zadbaj o to, by dowiedzieli się o niej jeszcze przed jego finalizacją.
      
      
      Informuj klientów o możliwości rozłożenia płatności na raty na każdym etapie ścieżki zakupowej:<br>
      •	na stronie głównej,<br>
      •	na liście produktów,<br>
      •	na karcie produktu oraz<br>
      •	w checkoucie.<br>


      Pamiętaj o tym, że klient, który wybiera raty, zwykle dysponuje ograniczonymi środkami. Jest zdecydowany na zakup, ale szuka najkorzystniejszej oferty.


      Informuj o ratach już na stronie głównej. Wykorzystaj slider lub top banner.


      <img src="getfile/raty-slider.png" alt="raty-slider" class="center smallImg">


      W ten sposób dotrzesz do szerokiego grona klientów. Nowym odwiedzającym dasz sygnał, że mogą płacić na raty.
      
      
      Dodaj logo rat wśród metod płatności prezentowanych w stopce strony. To jedno z podstawowych miejsc, gdzie klienci szukają informacji o możliwych sposobach opłacenia zamówienia.


      <img src="getfile/raty-stopka.png" alt="raty-stopka" class="center smallImg">


      Jeśli Twoja witryna jest rozbudowana(kategorie, podkategorie), umieść przycisk „Tu kupisz na raty” także na podstronach sklepu.


      <img src="getfile/raty-tu-kupisz-na-raty.png" alt="raty-tu-kupisz-na-raty" class="center smallImg">


      Informowane Klienta o ratach na karcie produktu pomaga zwiększyć konwersję tej metody płatności do ponad 40%, podczas gdy konwersja ratalna przy informacji dopiero w koszyku czy na checkoucie to 8%. Opcja minimum to statyczne reklamy graficzne Dzięki nim poinformujesz klienta o dostępności usługi Przelewy24 Raty.


      <img src="getfile/raty-karta-produktu.png" alt="raty-karta-produktu" class="center smallImg">


      Lista produktów to kolejne miejsce, gdzie za pomocą informacji o ratach możesz skłonić klienta do podjęcia szybszej decyzji zakupowej lub do dodania do koszyka dodatkowych produktów.
      
      
      Koszyk / podsumowanie zamówienia - tutaj zdecydowanie nie powinno zabraknąć informacji o ratach. Ostatnia prosta. Nie chcesz, aby na tym etapie klient porzucił koszyk. Wyświetl jasny komunikat dotyczący finalizacji płatności ratalnych. Pamiętaj, że w tym miejscu klient prawdopodobnie wybrał już metodę płatności, więc raty komunikuj mu od samego początku jego podróży zakupowej.

      
      <img src="getfile/raty-koszyk.png" alt="raty-koszyk" class="center smallImg">


      Checkout - wyciągnij metodę płatności ratalnej do checkout.


      <img src="getfile/raty-checkout.png" alt="raty-checkout" class="center smallImg">

      Jak wyświetlić daną metodę płatności znajdziesz tutaj 

      <a href="https://developers.przelewy24.pl/extended/index.php?pl#section/Przypadki-uzycia/Jak-wyswietlic-w-sklepie-pelen-wybor-metod-platnosci">Jak wyswietlic w sklepie pełen wybór metod płatności?</a>
      
      
      Domyślnie metoda ratalna jest dostępna jako method=303. Przekierowanie należy wykonać zgodnie z <a href="https://developers.przelewy24.pl/extended/index.php?pl#section/Przypadki-uzycia/Jak-przekierowac-klienta-do-konkretnej-metody-platnosci">wskazanymi wytycznymi.</a> 

      
      Wszystkie materiały graficzne są dostępne tutaj (https://www.przelewy24.pl/storage/app/media/do-pobrania/p24_raty/p24_raty_materialy_graficzne.zip)



    
  - name: Widget
    x-displayName: Widget
    description: >
      
      Zaprezentuj najniższą możliwą ratę dla konkretnego produktu.


      <img src="get.php?file=raty-najnizsza.png" alt="raty-najnizsza" class="center smallImg">


      Po kliknięciu w widget może pojawić się dowolny element np. pop-up z informacjami o Przelewy24 | Raty

      Aby uruchomić widget należy wykonać javasript:


      <h3>Wersja MINI</h3>
      <p>Przykład widgetu MINI zaprezentowanego w sklepie:<br>


      <img src="get.php?file=raty-mini.png" alt="raty-mini" class="smallImg">

      <p>Kod niezbędny do wywołania powyższego widgetu:</p>
      

      ```javascript
        <body>
          <!-- Tutaj będzie wyświetlony widget z wersją mini -->
          <div id="installment-widget-mini"></div>
          <!-- Osadzenie tagu z paczką -->
          <script type="application/javascript" src="https://apm.przelewy24.pl/installments/installment-calculator-app.umd.sdk.js"></script>
          <script>
            document.addEventListener("DOMContentLoaded", async () => {
              const config = {
                sign: "string",
                posid: 'test', // Identyfikator punktu płatności posId.
                method: '303',
                amount: 1000, // grosze
                currency: "PLN", // Waluta tylko "PLN"
                lang: "pl",  // na ten moment tylko pl
                test: false  // Opcjonalnie, do wykorzystania podczas testów, przyjmuje wartość boolean
              }
              // Utworzenie konstruktora i podanie configu
              const installmentCalculatorApp = new InstallmentCalculatorApp(config);
              // Utworzenie komponentu miniWidget
              const miniWidget = await installmentCalculatorApp.create('mini-widget');
              // Wyrenderowanie komponentu miniWidget w tagu o id installment-widget-mini
              miniWidget.render('installment-widget-mini');
            });
          </script>
        </body>
      ```
      
      <h3>Wersja MAX</h3>
      <p>Przykład widgetu MAX zaprezentowanego w sklepie:<br>

      
      <img src="get.php?file=raty-max.png" alt="raty-max" class="smallImg">
      

      <p>Kod niezbędny do wywołania powyższego widgetu:</p>


      ```javascript
          <body>
          <!-- Tutaj będzie wyświetlony widget z wersją max -->
          <div id="installment-widget-max"></div>
          <!-- Osadzenie tagu z paczką -->
          <script type="application/javascript" src="https://apm.przelewy24.pl/installments/installment-calculator-app.umd.sdk.js"></script>
          <script>
            document.addEventListener("DOMContentLoaded", async () => {
              const config = {
                sign: "string",
                posid: 'test', // Identyfikator punktu płatności posId.
                method: '303',
                amount: 1000, // grosze
                currency: "PLN", // Waluta tylko "PLN"
                lang: "pl",  // na ten moment tylko pl
                test: false  // Opcjonalnie, do wykorzystania podczas testów, przyjmuje wartość boolean
              }
              // Utworzenie konstruktora i podanie configu
              const installmentCalculatorApp = new InstallmentCalculatorApp(config);
              // Utworzenie komponentu maxWidget
              const maxWidget = await installmentCalculatorApp.create('max-widget');
              // Wyrenderowanie komponentu maxWidget w tagu o id installment-calculator-max
              maxWidget.render('installment-widget-max');
            });
          </script>
        </body>
      ```


    

  - name: Symulator
    x-displayName: Symulator
    description: >

      To sposób na zwiększenie zaangażowania użytkownika. Kalkulator pozwala na zaprezentowanie bardziej szczegółowych informacji o dostępnych ratach.
    
      
      „Przeklikanie” różnych opcji ratalnych zbliży klienta do przejścia na kolejny etap ścieżki zakupowej.

      
      <img src="get.php?file=raty-symulator.png" alt="raty-symulator" class="center smallImg">

      
      
      <h3>Przykłady gotowych kodów do prezentacji symulatora na stronie</h3>

      <div class="container-to-snippets-for-simulator">
      <div class="tabs-for-simulator">
          <div class="tab-for-simulator active" id="mini-click">Wersja MINI z kliknięciem i wywołaniem kalkulatora w modalu</div>
          <div class="tab-for-simulator" id="maxi-click">Wersja MAX z kliknięciem i wywołaniem kalkulatora w modalu</div>
          <div class="tab-for-simulator" id="mini-link">MINI widget z kliknięciem i otrzymaniem linku do kalkulatora</div>
          <div class="tab-for-simulator" id="maxi-link">MAXI widget z kliknięciem i otrzymaniem linku do kalkulatora</div>
          <div class="tab-for-simulator" id="button-modal">Własny button z kliknięciem i wywołaniem kalkulatora w modalu</div>
          <div class="tab-for-simulator" id="button-link">Własny button z kliknięciem i otrzymaniem linku do kalkulatora</div>
      </div>


      <div id="code-mini-click" class="code-container-simulator active">
      
      <h3>Wersja MINI z kliknięciem i wywołaniem kalkulatora w modalu</h3>


      ```javascript
        <body>
          <!-- Tutaj będzie wyświetlony widget z wersją mini -->
          <div id="installment-widget-mini"></div>
          <!-- Kontener na modal należy dodać na końcu body -->
          <div id="calculator-modal"></div>
          <!-- Osadzenie tagu z paczką -->
          <script type="application/javascript" src="https://apm.przelewy24.pl/installments/installment-calculator-app.umd.sdk.js"></script>
          <script>
            document.addEventListener("DOMContentLoaded", async () => {
              const config = {
                sign: "string",
                posid: 'test', // Identyfikator punktu płatności posId.
                method: '303',
                amount: 1000, // grosze
                currency: "PLN", // Waluta tylko "PLN"
                lang: "pl",  // na ten moment tylko pl
                test: false  // Opcjonalnie, do wykorzystania podczas testów, przyjmuje wartość boolean
              }
              // Utworzenie konstruktora i podanie configu
              const installmentCalculatorApp = new InstallmentCalculatorApp(config);
              // Utworzenie komponentu calculatorModal
              const calculatorModal = await installmentCalculatorApp.create('calculator-modal');
              // Wyrenderowanie modal-a z kalkulatorem w tagu o id calculator-modal.
              // Uwaga!!!
              // 1. Nie używać id="installment-calculator-modal"
              // 2. calculatorModal musi być wyrenderowany przed miniWidget
              calculatorModal.render('calculator-modal');
              // Utworzenie komponentu miniWidget
              const miniWidget = await installmentCalculatorApp.create('mini-widget');
              // Wyrenderowanie komponentu miniWidget w tagu o id installment-widget-mini
              miniWidget.render('installment-widget-mini');
            });
          </script>
        </body>
        
        ```
      </div>



      <div id="code-maxi-click" class="code-container-simulator">

      <h3>Wersja MAX z kliknięciem i wywołaniem kalkulatora w modalu</h3>


      ```javascript
        <body>
          <!-- Tutaj będzie wyświetlony widget z wersją max -->
          <div id="installment-widget-max"></div>
          <!-- Kontener na modal należy dodać na końcu body -->
          <div id="calculator-modal"></div>
          <!-- Osadzenie tagu z paczką -->
          <script type="application/javascript" src="https://apm.przelewy24.pl/installments/installment-calculator-app.umd.sdk.js"></script>
          <script>
            document.addEventListener("DOMContentLoaded", async () => {
              const config = {
                sign: "string",
                posid: 'test', // Identyfikator punktu płatności posId.
                method: '303',
                amount: 1000, // grosze
                currency: "PLN", // Waluta tylko "PLN"
                lang: "pl",  // na ten moment tylko pl
                test: false  // Opcjonalnie, do wykorzystania podczas testów, przyjmuje wartość boolean
              }
              // Utworzenie konstruktora i podanie configu
              const installmentCalculatorApp = new InstallmentCalculatorApp(config);
              // Utworzenie komponentu calculatorModal
              const calculatorModal = await installmentCalculatorApp.create('calculator-modal');
              // Wyrenderowanie modal-a z kalkulatorem w tagu o id calculator-modal.
              // Uwaga!!!
              // 1. Nie używać id="installment-calculator-modal"
              // 2. calculatorModal musi być wyrenderowany przed miniWidget
              calculatorModal.render('calculator-modal');
              // Utworzenie komponentu maxWidget
              const maxWidget = await installmentCalculatorApp.create('max-widget');
              // Wyrenderowanie komponentu maxWidget w tagu o id installment-calculator-max
              maxWidget.render('installment-widget-max');
            });
          </script>
        </body>
      ```

      </div>

      <div id="code-mini-link" class="code-container-simulator">

      <h3>MINI widget z kliknieciem i otrzymaniem linku do kalkulatora</h3>
 

      ```javascript
        <!doctype html>
        <html class="no-js" lang="pl">
          <head>
            <meta charset="utf-8">
            <meta name="viewport" content="width=device-width, initial-scale=1">
            <title>Widget mini with calculator link</title>
            <meta name="theme-color" content="#fafafa">
            <style>
              .button {
                margin: 0;
                padding: 0;
                border: 0;
                background: 0;
                cursor: pointer;
              }
              /* The Modal (background) */
              .calculator-modal-custom {
                display: none;
                position: fixed;
                z-index: 1;
                left: 0;
                top: 0;
                width: 100%;
                height: 100%;
                overflow: auto;
                background-color: rgba(0,0,0,0.4);
              }

              /* Modal Content */
              .calculator-modal-custom__content {
                background: none;
                margin: auto;
                width: 100%;
                height: 100vh;
                display: flex;
                transform: translate(-50%, -50%);
                left: 50%;
                top: 50%;
                position: fixed;
              }
            </style>
          </head>
          <body>
            <!-- Customowy button -->
            <button class="button" id="calculator-btn-custom"></button>
            <!--  Kontener na wywołanie własnego modala z kalkulatorem  -->
            <div id="calculator-modal-custom" class="calculator-modal-custom">
              <div class="calculator-modal-custom__content">
                <iframe
                  id="calculator-modal-custom-iframe"
                  style="border: none; margin: 0; padding: 0; width: 100%; height: 100%;"
                  title="installment-calculator"></iframe>
              </div>
            </div>
            <!-- Osadzenie tagu z paczką -->
            <script type="application/javascript" src="https://apm.przelewy24.pl/installments/installment-calculator-app.umd.sdk.js"></script>
            <script>
              document.addEventListener("DOMContentLoaded", async () => {
                const config = {
                  sign: "string",
                  posid: 'test', // Identyfikator punktu płatności posId.
                  method: '303',
                  amount: 1000, // grosze
                  currency: "PLN", // Waluta tylko "PLN"
                  lang: "pl",  // na ten moment tylko pl
                  test: false  // Opcjonalnie, do wykorzystania podczas testów, przyjmuje wartość boolean
                }
                // Utworzenie konstruktora i podanie configu
                const installmentCalculatorApp = new InstallmentCalculatorApp(config);
                // Utworzenie komponentu miniWidget
                const miniWidget = await installmentCalculatorApp.create('mini-widget');
                // Wyrenderowanie komponentu miniWidget w tagu o id calculator-btn-custom
                miniWidget.render('calculator-btn-custom');

                // CUSTOM
                const modal = document.getElementById('calculator-modal-custom');
                const button = document.getElementById('calculator-btn-custom');
                const iframe = document.getElementById('calculator-modal-custom-iframe');
                button.onclick = function () {
                  modal.style.display = "block";
                  const customLink = installmentCalculatorApp.getCalculatorUrl();
                  if (!iframe.src) {
                    iframe.src = customLink;
                  }
                };

                const handleMessage = (event) => {
                  if (event.data?.type === 'READY') {
                    iframe.contentWindow.postMessage({ config }, '*');
                  }
                  if (event.data.action === 'closeModal') {
                    modal.style.display = 'none';
                  }
                };

                window.addEventListener('message', handleMessage);
              });
            </script>
          </body>
        </html>
      ```

      </div>

      <div id="code-maxi-link" class="code-container-simulator">
      
      <h3>MAXI widget z kliknieciem i otrzymaniem linku do kalkulatora</h3>


      ```javascript
        <!doctype html>
        <html class="no-js" lang="pl">
          <head>
            <meta charset="utf-8">
            <meta name="viewport" content="width=device-width, initial-scale=1">
            <title>Custom button with calculator link</title>
            <style>
              .button {
                margin: 0;
                padding: 0;
                border: 0;
                background: 0;
                cursor: pointer;
              }
              /* The Modal (background) */
              .calculator-modal-custom {
                display: none;
                position: fixed;
                z-index: 1;
                left: 0;
                top: 0;
                width: 100%;
                height: 100%;
                overflow: auto;
                background-color: rgba(0,0,0,0.4);
              }

              /* Modal Content */
              .calculator-modal-custom__content {
                background: none;
                margin: auto;
                width: 100%;
                height: 100vh;
                display: flex;
                transform: translate(-50%, -50%);
                left: 50%;
                top: 50%;
                position: fixed;
              }
            </style>
          </head>
          <body>
            <!-- Customowy button -->
            <button class="button" id="calculator-btn-custom"></button>
            <!--  Kontener na wywołanie własnego modala z kalkulatorem  -->
            <div id="calculator-modal-custom" class="calculator-modal-custom">
              <div class="calculator-modal-custom__content">
                <iframe
                  id="calculator-modal-custom-iframe"
                  style="border: none; margin: 0; padding: 0; width: 100%; height: 100%;"
                  title="installment-calculator"></iframe>
              </div>
            </div>
            <!-- Osadzenie tagu z paczką -->
            <script type="application/javascript" src="https://apm.przelewy24.pl/installments/installment-calculator-app.umd.sdk.js"></script>
            <script>
              document.addEventListener("DOMContentLoaded", async () => {
                const config = {
                  sign: "string",
                  posid: 'test', // Identyfikator punktu płatności posId. Identyfikator składa się z samych cyfr.
                  method: '303',
                  amount: 1000, // grosze
                  currency: "PLN", // Waluta tylko "PLN"
                  lang: "pl",  // na ten moment tylko pl
                  test: false  // Opcjonalnie, do wykorzystania podczas testów, przyjmuje wartość boolean
                }
                // Utworzenie konstruktora i podanie configu
                const installmentCalculatorApp = new InstallmentCalculatorApp(config);
                // Utworzenie komponentu maxWidget
                const maxWidget = await installmentCalculatorApp.create('max-widget');
                // Wyrenderowanie komponentu maxWidget w tagu o id installment-calculator-max
                maxWidget.render('calculator-btn-custom');
                // CUSTOM
                const modal = document.getElementById('calculator-modal-custom');
                const button = document.getElementById('calculator-btn-custom');
                const iframe = document.getElementById('calculator-modal-custom-iframe');
                button.onclick = function () {
                  modal.style.display = "block";
                  const customLink = installmentCalculatorApp.getCalculatorUrl();
                  if (!iframe.src) {
                    iframe.src = customLink;
                  }
                };

                const handleMessage = (event) => {
                  if (event.data?.type === 'READY') {
                    iframe.contentWindow.postMessage({ config }, '*');
                  }
                  if (event.data.action === 'closeModal') {
                    modal.style.display = 'none';
                  }
                };

                window.addEventListener('message', handleMessage);
              });
            </script>
          </body>
        </html>
      ```

      
      </div>

      <div id="code-button-modal" class="code-container-simulator">

      <h3>Własny button z kliknieciem i wywołaniem kalkulatora w modalu</h3>


      ```javascript
        <!doctype html>
          <html class="no-js" lang="pl">
          <head>
            <meta charset="utf-8">
            <meta name="viewport" content="width=device-width, initial-scale=1">
            <title>Custom button with calculator modal</title>
          </head>
          <body>
            <!-- Customowy button -->
            <button id="calculator-btn-custom">
              Kalkulator ratalny
            </button>
            <!-- Kontener na modal należy dodać na końcu body -->
            <div id="calculator-modal"></div>
            <!-- Osadzenie tagu z paczką -->
            <script type="application/javascript" src="https://apm.przelewy24.pl/installments/installment-calculator-app.umd.sdk.js"></script>
            <script>
              document.addEventListener("DOMContentLoaded", async () => {
                const config = {
                  sign: "string",
                  posid: 'test', // Identyfikator punktu płatności posid
                  method: '303',
                  amount: 1000, // grosze
                  currency: "PLN", // Waluta tylko "PLN"
                  lang: "pl",  // na ten moment tylko pl
                  test: false  // Opcjonalnie, do wykorzystania podczas testów, przyjmuje wartość boolean
                }
                // Utworzenie konstruktora i podanie configu
                const installmentCalculatorApp = new InstallmentCalculatorApp(config);
                // Utworzenie komponentu calculatorModal
                const calculatorModal = await installmentCalculatorApp.create('calculator-modal');
                // Wyrenderowanie modal-a z kalkulatorem w tagu o id calculator-modal. Uwaga!!! Nie używać id="installment-calculator-modal"
                calculatorModal.render('calculator-modal');

                const button = document.getElementById('calculator-btn-custom');
                button.onclick = function () {
                  const modal = document.getElementById('installment-calculator-modal');
                  if (modal) modal.style.display = "block";
                };
              });
            </script>
          </body>
          </html>
      ```

      </div>

      <div id="code-button-link" class="code-container-simulator">

      <h3>Własny button z kliknieciem i otrzymaniem linku do kalkulatora</h3>


        ```javascript
          <!doctype html>
          <html class="no-js" lang="pl">
          <head>
            <meta charset="utf-8">
            <meta name="viewport" content="width=device-width, initial-scale=1">
            <title>Custom button with calculator link</title>
            <style>
              /* The Modal (background) */
              .calculator-modal-custom {
                display: none;
                position: fixed;
                z-index: 1;
                left: 0;
                top: 0;
                width: 100%;
                height: 100%;
                overflow: auto;
                background-color: rgba(0,0,0,0.4);
              }

              /* Modal Content */
              .calculator-modal-custom__content {
                background: none;
                margin: auto;
                width: 100%;
                height: 100vh;
                display: flex;
                transform: translate(-50%, -50%);
                left: 50%;
                top: 50%;
                position: fixed;
              }
            </style>
          </head>
          <body>
            <!-- Customowy button -->
            <button id="calculator-btn-custom">
              Kalkulator ratalny
            </button>
            <!--  Kontener na wywołanie własnego modala z kalkulatorem  -->
            <div id="calculator-modal-custom" class="calculator-modal-custom">
              <div class="calculator-modal-custom__content">
                <iframe
                  id="calculator-modal-custom-iframe"
                  style="border: none; margin: 0; padding: 0; width: 100%; height: 100%;"
                  title="installment-calculator"></iframe>
              </div>
            </div>
            <!-- Osadzenie tagu z paczką -->
            <script type="application/javascript" src="https://apm.przelewy24.pl/installments/installment-calculator-app.umd.sdk.js"></script>
            <script>
              document.addEventListener("DOMContentLoaded", (event) => {
                const config = {
                  sign: "string",
                  posid: 'test', // Identyfikator punktu płatności posId.
                  method: '303',
                  amount: 1000, // grosze
                  currency: "PLN", // Waluta tylko "PLN"
                  lang: "pl",  // na ten moment tylko pl
                  test: false  // Opcjonalnie, do wykorzystania podczas testów, przyjmuje wartość boolean
                }
                // Utworzenie konstruktora i podanie configu
                const installmentCalculatorApp = new InstallmentCalculatorApp(config);

                // CUSTOM
                const modal = document.getElementById('calculator-modal-custom');
                const button = document.getElementById('calculator-btn-custom');
                const iframe = document.getElementById('calculator-modal-custom-iframe');
                button.onclick = function () {
                  modal.style.display = "block";
                  const customLink = installmentCalculatorApp.getCalculatorUrl();
                  if (!iframe.src) {
                    iframe.src = customLink;
                  }
                };

                const handleMessage = (event) => {
                  if (event.data?.type === 'READY') {
                    iframe.contentWindow.postMessage({ config }, '*');
                  }
                  if (event.data.action === 'closeModal') {
                    modal.style.display = 'none';
                  }
                };

                window.addEventListener('message', handleMessage);
              });
            </script>
          </body>
          </html>
        ```
        
        </div>

        <h3>Parametry niezbędne do wywołania widgetu lub symulatora:</h3>
         
        |  Parametr       |   Opis                     |
        |--------------|:----------------------|
        | sign |	Wyliczony jako <code>sha384({„crc”:”string”,”posId”:int,”method”:int})</code> |
        | posId | ID Sklepu (domyślnie ID Partnera) |
        | method | Domyślnie 303 |
        | amount | Kwota wyrażona w groszach | 
        | lang | Dozwolone: pl |
        | currency | Dozwolone: PLN | 

        <h3>Parametry opcjonalne do wywołania widgetu lub symulatora:</h3>
        
       |  Parametr       |   Opis                     |
        |--------------|:----------------------|
        | test |	Dozwolone: true, false |

        Wysłany parametr test z wartością <i>`true`</i> sprawia, że pola `sign`, `posId` oraz `method` nie są walidowane, muszą zostać natomiast przekazane w obiekcie `config`.