GhostsPays API

https://ghostspay.readme.io/reference
Admin
GhostsPays API é um gateway API RESTful projetado para integração simples e eficiente, oferecendo...
Tokens:24,295
Snippets:79
Trust Score:9.9
Update:9 months ago
Show doc for...
Tokens:
Raw
### Create Payment Request Examples (OpenAPI)

Source: https://ghostspay.readme.io/reference/post_transactions

Examples demonstrating the structure of payment creation requests for PIX, credit card with token, and credit card with full data. These examples are part of the OpenAPI definition and illustrate the expected JSON payload for the POST /transactions endpoint.

```json
{
  "openapi": "3.1.0",
  "info": {
    "title": "GhostsPays Payment API",
    "version": "1.0.0",
    "description": "API moderna para processamento de pagamentos com suporte a PIX, cartão de crédito e boleto bancário.",
    "contact": {
      "name": "Suporte GhostsPays",
      "url": "https://GhostsPays.com/suporte",
      "email": "suporte@GhostsPays.com"
    },
    "license": {
      "name": "MIT",
      "url": "https://opensource.org/licenses/MIT"
    }
  },
  "servers": [
    {
      "url": "https://api.ghostspayv2.com/functions/v1",
      "description": "Ambiente de desenvolvimento"
    },
    {
      "url": "https://api.ghostspayv2.com/functions/v1",
      "description": "Ambiente de produção"
    }
  ],
  "tags": [
    {
      "name": "Payments",
      "description": "Criação de pagamentos via PIX, cartão de crédito ou boleto bancário"
    }
  ],
  "paths": {
    "/transactions": {
      "post": {
        "tags": [
          "Payments"
        ],
        "summary": "Criar Pagamento",
        "description": "Cria um novo pagamento com suporte a PIX, cartão de crédito ou boleto bancário. Para cartões, você pode usar um token previamente gerado ou enviar os dados completos.",
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CreatePaymentRequest"
              },
              "examples": {
                "pix_payment": {
                  "summary": "Pagamento via PIX",
                  "value": {
                    "customer": {
                      "name": "João Silva",
                      "email": "joao.silva@example.com",
                      "phone": "11987654321",
                      "document": {
                        "number": "12345678901",
                        "type": "CPF"
                      }
                    },
                    "paymentMethod": "PIX",
                    "amount": 5000,
                    "items": [
                      {
                        "title": "Produto Exemplo",
                        "unitPrice": 5000,
                        "quantity": 1
                      }
                    ],
                    "pix": {
                      "expiresInDays": 1
                    }
                  }
                },
                "card_payment_with_token": {
                  "summary": "Pagamento com cartão tokenizado",
                  "value": {
                    "customer": {
                      "name": "Maria Santos",
                      "email": "maria@example.com",
                      "phone": "11987654321",
                      "document": {
                        "number": "12345678901",
                        "type": "CPF"
                      }
                    },
                    "paymentMethod": "CARD",
                    "amount": 10000,
                    "installments": 3,
                    "card": {
                      "id": "card_token_abc123"
                    },
                    "items": [
                      {
                        "title": "Produto Premium",
                        "unitPrice": 10000,
                        "quantity": 1
                      }
                    ]
                  }
                },
                "card_payment_with_data": {
                  "summary": "Pagamento com dados do cartão",
                  "value": {
                    "customer": {
                      "name": "Pedro Costa",
                      "email": "pedro@example.com",
                      "phone": "11987654321",
                      "document": {
                        "number": "12345678901",
                        "type": "CPF"
                      }
                    },
                    "paymentMethod": "CARD",
                    "amount": 7500,
                    "installments": 1,
                    "card": {
                      "number": "4111111111111111",
                      "holderName": "Pedro Costa",
                      "expirationMonth": 12,
                      "expirationYear": 2025,
                      "cvv": "123"
                    },
                    "items": [
                      {
                        "title": "Serviço Digital",
                        "unitPrice": 7500,
                        "quantity": 1
                      }
                    ]
                  }
                }
              }
            }
          }
        },
        "responses": {
          "201": {
            "description": "Pagamento criado com sucesso",
            "content": {
              "application/json": {
                "schema": {
                  "oneOf": [
                    {
                      "$ref": "#/components/schemas/PixPaymentResponse"
                    },
                    {

```

--------------------------------

### Create Payment Request - Ruby Example

Source: https://ghostspay.readme.io/reference/payments

Example of how to create a payment using Ruby. It uses the 'net/http' library to send a POST request with the payment details.

```ruby
require 'net/http'
require 'uri'
require 'json'

uri = URI.parse('https://api.ghostspaysv2.com/functions/v1/transactions')

request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request['Accept'] = 'application/json'

payment_data = {
  paymentMethod: 'PIX'
  # ... other payment details
}

request.body = payment_data.to_json

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end

puts "Status Code: #{response.code}"
puts "Response Body: #{response.body}"
```

--------------------------------

### Create Payment Request - Python Example

Source: https://ghostspay.readme.io/reference/payments

Example of how to create a payment using Python. It uses the 'requests' library to send a POST request with the payment details.

```python
import requests

url = "https://api.ghostspaysv2.com/functions/v1/transactions"

payment_data = {
    "paymentMethod": "PIX"
    # ... other payment details
}

headers = {
    "Content-Type": "application/json",
    "Accept": "application/json"
}

try:
    response = requests.post(url, json=payment_data, headers=headers)
    response.raise_for_status()  # Raise an exception for bad status codes
    print(f"Status Code: {response.status_code}")
    print(f"Response: {response.json()}")
except requests.exceptions.RequestException as e:
    print(f"Error creating payment: {e}")
```

--------------------------------

### Create Payment Request - Node.js Example

Source: https://ghostspay.readme.io/reference/payments

Example of how to create a payment using Node.js. It utilizes the 'axios' library to send a POST request with the payment details.

```javascript
const axios = require('axios');

const createPayment = async (paymentData) => {
  try {
    const response = await axios.post('https://api.ghostspaysv2.com/functions/v1/transactions', paymentData, {
      headers: {
        'Content-Type': 'application/json',
        'Accept': 'application/json'
      }
    });
    return response.data;
  } catch (error) {
    console.error('Error creating payment:', error);
    throw error;
  }
};

// Example usage:
const paymentDetails = {
  paymentMethod: 'PIX',
  // ... other payment details
};

createPayment(paymentDetails)
  .then(data => console.log('Payment created:', data))
  .catch(err => console.error('Failed to create payment'));
```

--------------------------------

### Create Payment Request - PHP Example

Source: https://ghostspay.readme.io/reference/payments

Example of how to create a payment using PHP. It uses cURL to send a POST request with the payment details.

```php
<?php

$url = 'https://api.ghostspaysv2.com/functions/v1/transactions';

$data = array(
    'paymentMethod' => 'PIX'
    // ... other payment details
);

$payload = json_encode($data);

$ch = curl_init($url);

curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_HTTPHEADER, array(
    'Content-Type: application/json',
    'Accept: application/json'
));

$response = curl_exec($ch);

if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}

$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

curl_close($ch);

echo "HTTP Status Code: " . $httpCode . "\n";
echo "Response: " . $response;

?>
```

--------------------------------

### List Transactions PHP Example

Source: https://ghostspay.readme.io/reference/transactions

Provides a PHP example for fetching a paginated list of transactions. Filters can be applied for status, payment method, and date range.

```php
// PHP example would go here, using cURL or file_get_contents
// Example structure:
/*
<?php
$url = 'https://api.ghostspaysv2.com/functions/v1/transactions';
$options = [
    'http' => [
        'method' => 'GET',
        'header' => 'Accept: application/json',
        // Add query parameters if needed, e.g., 'content' => http_build_query(['status' => 'paid', 'limit' => 10])
    ]
];
$context = stream_context_create($options);
$result = file_get_contents($url, false, $context);
if ($result === FALSE) {
    // Handle error
    echo "Error fetching transactions";
} else {
    $data = json_decode($result, true);
    print_r($data);
}
?>
*/
```

--------------------------------

### List Transactions Node.js Example

Source: https://ghostspay.readme.io/reference/transactions

Demonstrates how to fetch a paginated list of transactions using Node.js. It allows filtering by status, payment method, and date range.

```javascript
// Node.js example would go here, using a library like axios or node-fetch
// Example structure:
/*
const axios = require('axios');

const listTransactions = async (params) => {
  try {
    const response = await axios.get('https://api.ghostspaysv2.com/functions/v1/transactions', {
      params: params,
      headers: { 'accept': 'application/json' }
    });
    return response.data;
  } catch (error) {
    console.error('Error listing transactions:', error);
    throw error;
  }
};

// Example usage:
// listTransactions({ status: 'paid', limit: 10 }).then(data => console.log(data));
*/
```

--------------------------------

### Create Payment Request - cURL Example

Source: https://ghostspay.readme.io/reference/payments

Example of how to make a POST request to create a payment using cURL. It specifies the URL, headers, and a sample JSON payload for a PIX payment.

```Shell
curl --request POST \
     --url https://api.ghostspaysv2.com/functions/v1/transactions \
     --header 'accept: application/json' \
     --header 'content-type: application/json' \
     --data '{
  "paymentMethod": "PIX"
}'
```

--------------------------------

### Node.js: Authenticate and Prepare API Request

Source: https://ghostspay.readme.io/reference/introdu%C3%A7%C3%A3o

Example of how to construct the Authorization header using Basic Authentication in Node.js. It encodes the secret key and company ID into a Base64 string, suitable for API requests.

```typescript
const secretKey = "sua_secret_key_aqui";
const companyId = "seu_company_id_aqui";

const credentials = Buffer.from(`${secretKey}:${companyId}`).toString("base64");

const options = {
    method: "POST",
    url: "https://api.ghostspaysv2.com/functions/v1/transactions",
    headers: {
        "Authorization": `Basic ${credentials}`,
        "Content-Type": "application/json"
    },
};
```

--------------------------------

### List Transactions Python Example

Source: https://ghostspay.readme.io/reference/transactions

Illustrates how to list transactions with Python, allowing for filtering by status, payment method, and date range. Uses the 'requests' library.

```python
import requests

def list_transactions(params=None):
    url = "https://api.ghostspaysv2.com/functions/v1/transactions"
    headers = {'accept': 'application/json'}
    try:
        response = requests.get(url, params=params, headers=headers)
        response.raise_for_status()  # Raise an exception for bad status codes
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error listing transactions: {e}")
        return None

# Example usage:
# query_params = {
#     'status': 'paid',
#     'limit': 10,
#     'startDate': '2023-01-01',
#     'endDate': '2023-12-31'
# }
# transactions = list_transactions(query_params)
# if transactions:
#     print(transactions)
```

--------------------------------

### List Transactions cURL Request

Source: https://ghostspay.readme.io/reference/transactions

Example of how to make a GET request to list transactions using cURL. It specifies the URL and the expected JSON content type.

```shell
curl --request GET \
     --url https://api.ghostspaysv2.com/functions/v1/transactions \
     --header 'accept: application/json'
```

--------------------------------

### List Transactions Ruby Example

Source: https://ghostspay.readme.io/reference/transactions

Shows how to retrieve a paginated list of transactions using Ruby. Supports filtering by status, payment method, and date range.

```ruby
# Ruby example would go here, using a library like Net::HTTP or Faraday
# Example structure:
/*
require 'net/http'
require 'uri'

uri = URI.parse('https://api.ghostspaysv2.com/functions/v1/transactions')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri.request_uri)
request['accept'] = 'application/json'
# Add query parameters if needed, e.g., request.set_form_data({'status' => 'paid', 'limit' => '10'})

response = http.request(request)
puts response.body
*/
```

--------------------------------

### cURL: Authenticate and Make API Request

Source: https://ghostspay.readme.io/reference/introdu%C3%A7%C3%A3o

Example of making a POST request to the GhostsPays API using cURL with Basic Authentication. It demonstrates how to encode credentials and set necessary headers and data.

```bash
curl -X POST \
  https://api.ghostspaysv2.com/functions/v1/transactions \
  -H "Authorization: Basic $(echo -n 'SECRET_KEY:COMPANY_ID' | base64)" \
  -H "Content-Type: application/json" \
  -d '{"data": "example"}'
```

--------------------------------

### POST /payments

Source: https://ghostspay.readme.io/reference/post_transactions

Cria um novo pagamento com suporte a PIX, cartão de crédito ou boleto bancário. Para cartões, você pode usar um token previamente gerado ou enviar os dados completos.

```APIDOC
## POST /payments

### Description
Cria um novo pagamento com suporte a PIX, cartão de crédito ou boleto bancário. Para cartões, você pode usar um token previamente gerado ou enviar os dados completos.

### Method
POST

### Endpoint
/payments

### Parameters
#### Request Body
- **payment_method** (string) - Required - O método de pagamento (PIX, credit_card, boleto).
- **amount** (number) - Required - O valor do pagamento.
- **card_token** (string) - Optional - O token do cartão de crédito, se o método for 'credit_card'.
- **card_data** (object) - Optional - Os dados completos do cartão de crédito, se o método for 'credit_card' e nenhum token for fornecido.
  - **number** (string) - Required - Número do cartão.
  - **expiry_month** (string) - Required - Mês de expiração do cartão.
  - **expiry_year** (string) - Required - Ano de expiração do cartão.
  - **cvv** (string) - Required - Código de segurança do cartão.
  - **holder_name** (string) - Required - Nome do titular do cartão.

### Request Example
```json
{
  "payment_method": "credit_card",
  "amount": 100.50,
  "card_data": {
    "number": "1111222233334444",
    "expiry_month": "12",
    "expiry_year": "25",
    "cvv": "123",
    "holder_name": "João Silva"
  }
}
```

### Response
#### Success Response (201)
- **payment_id** (string) - O ID do pagamento criado.
- **status** (string) - O status do pagamento.

#### Response Example
```json
{
  "payment_id": "pay_12345abcde",
  "status": "pending"
}
```
```

--------------------------------

### POST /transactions

Source: https://ghostspay.readme.io/reference/post_transactions

Cria um novo pagamento com suporte a PIX, cartão de crédito ou boleto bancário. Para cartões, você pode usar um token previamente gerado ou enviar os dados completos.

```APIDOC
## POST /transactions

### Description
Cria um novo pagamento com suporte a PIX, cartão de crédito ou boleto bancário. Para cartões, você pode usar um token previamente gerado ou enviar os dados completos.

### Method
POST

### Endpoint
/transactions

### Parameters
#### Request Body
- **customer** (object) - Required - Informações do cliente.
  - **name** (string) - Required - Nome completo do cliente.
  - **email** (string) - Required - Endereço de e-mail do cliente.
  - **phone** (string) - Required - Número de telefone do cliente.
  - **document** (object) - Required - Documento do cliente.
    - **number** (string) - Required - Número do documento.
    - **type** (string) - Required - Tipo do documento (CPF ou CNPJ).
- **paymentMethod** (string) - Required - Método de pagamento (PIX, CARD, BOLETO).
- **amount** (integer) - Required - Valor total do pagamento em centavos.
- **installments** (integer) - Optional - Número de parcelas (para pagamentos com cartão).
- **items** (array) - Required - Lista de itens do pedido.
  - **title** (string) - Required - Título do item.
  - **unitPrice** (integer) - Required - Preço unitário do item em centavos.
  - **quantity** (integer) - Required - Quantidade do item.
- **pix** (object) - Optional - Configurações específicas para PIX.
  - **expiresInDays** (integer) - Optional - Dias para expiração do PIX.
- **card** (object) - Optional - Informações do cartão de crédito.
  - **id** (string) - Required if using tokenization - Token do cartão.
  - **number** (string) - Required if not using tokenization - Número do cartão.
  - **holderName** (string) - Required if not using tokenization - Nome do titular do cartão.
  - **expirationMonth** (integer) - Required if not using tokenization - Mês de expiração do cartão.
  - **expirationYear** (integer) - Required if not using tokenization - Ano de expiração do cartão.
  - **cvv** (string) - Required if not using tokenization - Código de segurança do cartão.

### Request Example
```json
{
  "customer": {
    "name": "João Silva",
    "email": "joao.silva@example.com",
    "phone": "11987654321",
    "document": {
      "number": "12345678901",
      "type": "CPF"
    }
  },
  "paymentMethod": "PIX",
  "amount": 5000,
  "items": [
    {
      "title": "Produto Exemplo",
      "unitPrice": 5000,
      "quantity": 1
    }
  ],
  "pix": {
    "expiresInDays": 1
  }
}
```

### Response
#### Success Response (201)
- **paymentId** (string) - ID único do pagamento.
- **status** (string) - Status atual do pagamento.
- **pixCode** (string) - Código PIX (se applicable).
- **pixQrCode** (string) - QR Code PIX (se applicable).
- **boletoUrl** (string) - URL do boleto (se applicable).

#### Response Example
```json
{
  "paymentId": "pay_abc123",
  "status": "PENDING",
  "pixCode": "00020126580014br.gov.bcb.pix0136...",
  "pixQrCode": "https://qr-code-generator.com/api/v1/generate?data=...",
  "boletoUrl": null
}
```
```

--------------------------------

### GET /transactions

Source: https://ghostspay.readme.io/reference/get_transactions

Retrieves a paginated list of transactions with optional filters for status, payment method, and date range.

```APIDOC
## GET /transactions

### Description
Lists transactions with optional filters.

### Method
GET

### Endpoint
/transactions

### Parameters
#### Query Parameters
- **page** (integer) - Optional - Page number (starts at 1), default: 1
- **limit** (integer) - Optional - Number of records per page (max 100), default: 10
- **status** (string) - Optional - Filter by transaction status (pending, paid, failed, refunded, expired)
- **paymentMethod** (string) - Optional - Filter by payment method (PIX, CARD, BOLETO)
- **startDate** (string) - Optional - Start date in YYYY-MM-DD format
- **endDate** (string) - Optional - End date in YYYY-MM-DD format

### Request Example
```json
{
  "example": "GET /transactions?status=paid&paymentMethod=PIX&startDate=2023-01-01&endDate=2023-12-31"
}
```

### Response
#### Success Response (200)
- **data** (array) - List of transactions
- **pagination** (object) - Pagination details

#### Response Example
```json
{
  "example": "{\n  \"data\": [\n    {\n      \"id\": \"txn_12345\",\n      \"status\": \"paid\",\n      \"amount\": 100.00,\n      \"paymentMethod\": \"PIX\",\n      \"createdAt\": \"2023-10-27T10:00:00Z\",\n      \"updatedAt\": \"2023-10-27T10:05:00Z\"\n    }\n  ],\n  \"pagination\": {\n    \"currentPage\": 1,\n    \"totalPages\": 10,\n    \"totalRecords\": 100,\n    \"limit\": 10\n  }\n}"
}
```
```

--------------------------------

### PHP: Authenticate and Make API Request

Source: https://ghostspay.readme.io/reference/introdu%C3%A7%C3%A3o

Demonstrates how to implement Basic Authentication for API requests in PHP. It encodes credentials using base64 and sets up a cURL request to the specified API endpoint.

```php
<?php
$secretKey = "sua_secret_key_aqui";
$companyId = "seu_company_id_aqui";

$credentials = base64_encode($secretKey . ':' . $companyId);

$headers = [
    'Authorization: Basic ' . $credentials,
    'Content-Type: application/json'
];

$data = json_encode([
    "data" => "example"
]);

$curl = curl_init();
curl_setopt_array($curl, [
    CURLOPT_URL => "https://api.ghostspaysv2.com/functions/v1/transactions",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => $data,
    CURLOPT_HTTPHEADER => $headers
]);

$response = curl_exec($curl);
$httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
curl_close($curl);

if ($httpCode === 200) {
    $result = json_decode($response, true);
    // Processar resposta
} else {
    // Tratar erro
    echo "Erro na requisição: " . $httpCode;
}
?>
```

--------------------------------

### GET /transactions/{id}

Source: https://ghostspay.readme.io/reference/get_transactions-id

Retrieves the complete details of a specific transaction by its ID. This endpoint supports fetching details for PIX, credit card, and boleto bancário transactions.

```APIDOC
## GET /transactions/{id}

### Description
Obtém os detalhes completos de uma transação específica pelo ID.

### Method
GET

### Endpoint
/transactions/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - ID único da transação

### Request Example
```json
{
  "example": "This is a placeholder for a GET request example"
}
```

### Response
#### Success Response (200)
- **PixPaymentResponse** (object) - Details of a PIX transaction.
- **CardPaymentResponse** (object) - Details of a credit card transaction.
- **BoletoPaymentResponse** (object) - Details of a boleto bancário transaction.

#### Response Example
```json
{
  "example": "This is a placeholder for a successful response example"
}
```

#### Error Responses
- **401**: Unauthorized
- **404**: Not Found
- **500**: Internal Server Error
```

--------------------------------

### Webhook Best Practices

Source: https://ghostspay.readme.io/reference/eventos-e-webhooks

Follow these best practices to ensure reliable and efficient handling of GhostPay webhooks.

```APIDOC
## Webhook Best Practices

### Description
Implementing these guidelines will help ensure that your system correctly and efficiently processes incoming webhooks from GhostPay.

### Practices

1.  **Respond Quickly**: Acknowledge receipt of the webhook with a `200 OK` status as soon as possible, ideally within 5 seconds. Perform heavy processing asynchronously.
2.  **Idempotency**: Design your webhook handler to be idempotent. This means that receiving the same webhook multiple times should not result in duplicate processing or unintended side effects.
3.  **Retry Mechanism**: Be aware that GhostPay will retry sending a webhook up to 3 times if an initial attempt fails (i.e., does not receive a `200 OK` response).
4.  **Logging**: Maintain comprehensive logs of all incoming webhooks. This is crucial for debugging issues and tracking the flow of events.
```

--------------------------------

### cURL: Basic Authentication for API Requests

Source: https://ghostspay.readme.io/reference/index

This cURL command demonstrates how to make an API request with Basic Authentication. It constructs the Authorization header by encoding the Secret Key and Company ID in Base64 and sends a POST request with a JSON payload.

```Bash
curl -X POST \
  https://api.ghostspaysv2.com/functions/v1/transactions \
  -H "Authorization: Basic $(echo -n 'SECRET_KEY:COMPANY_ID' | base64)" \
  -H "Content-Type: application/json" \
  -d '{"data": "example"}'

```

--------------------------------

### Item Object

Source: https://ghostspay.readme.io/reference/post_transactions

Represents an item in a purchase, including its title, unit price, and quantity.

```APIDOC
## Item Object

### Description
Represents an item in a purchase.

### Properties
- **title** (string) - Required - Nome/descrição do item. Min 1, Max 100 characters.
- **unitPrice** (integer) - Required - Preço unitário em centavos. Must be at least 1.
- **quantity** (integer) - Required - Quantidade do item. Must be at least 1.

### Example
```json
{
  "title": "Produto Digital Premium",
  "unitPrice": 2500,
  "quantity": 1
}
```
```

--------------------------------

### Node.js: Basic Authentication for API Requests

Source: https://ghostspay.readme.io/reference/index

This Node.js snippet demonstrates how to construct the Authorization header for API requests using Basic Authentication. It requires a Secret Key and Company ID, encodes them in Base64, and sets the 'Authorization' and 'Content-Type' headers for a POST request.

```TypeScript
const secretKey = "sua_secret_key_aqui";
const companyId = "seu_company_id_aqui";

const credentials = Buffer.from(`${secretKey}:${companyId}`).toString("base64");

const options = {
    method: "POST",
    url: "https://api.ghostspaysv2.com/functions/v1/transactions",
    headers: {
        "Authorization": `Basic ${credentials}`,
        "Content-Type": "application/json"
    },
};

```

--------------------------------

### Incluir Biblioteca de Tokenização JavaScript

Source: https://ghostspay.readme.io/reference/tokeniza%C3%A7%C3%A3o-de-cart%C3%A3o-de-cr%C3%A9dito

Adiciona a biblioteca de tokenização da Ghostpays ao cabeçalho de uma página HTML para habilitar a funcionalidade de geração de tokens de cartão de crédito.

```html
<script src="https://api.ghostspaysv2.com/functions/v1/js"></script>
```

--------------------------------

### Authentication

Source: https://ghostspay.readme.io/reference/post_transactions

Details on how to authenticate your requests to the Ghostspay API using HTTP Basic authentication with an API Key.

```APIDOC
## Authentication

### Description

This API uses HTTP Basic authentication. You should use your API Key as the username and leave the password field empty.

### Method

HTTP Basic

### Endpoint

N/A

### Parameters

N/A

### Request Example

N/A

### Response

N/A
```

--------------------------------

### BoletoConfig Object

Source: https://ghostspay.readme.io/reference/post_transactions

Configuration for Boleto payments, specifying the expiration period in days.

```APIDOC
## BoletoConfig Object

### Description
Configuration for Boleto payments.

### Properties
- **expiresInDays** (integer) - Required - Dias para vencimento do boleto. Must be between 1 and 30.

### Example
```json
{
  "expiresInDays": 3
}
```
```

--------------------------------

### PHP: Basic Authentication and Transaction Request

Source: https://ghostspay.readme.io/reference/index

This PHP script illustrates how to perform API requests with Basic Authentication. It encodes credentials in Base64, sets up cURL to send a POST request with appropriate headers and JSON payload, and handles the response or errors.

```PHP
<?php
$secretKey = "sua_secret_key_aqui";
$companyId = "seu_company_id_aqui";

$credentials = base64_encode($secretKey . ':' . $companyId);

$headers = [
    'Authorization: Basic ' . $credentials,
    'Content-Type: application/json'
];

$data = json_encode([
    "data" => "example"
]);

$curl = curl_init();
curl_setopt_array($curl, [
    CURLOPT_URL => "https://api.ghostspaysv2.com/functions/v1/transactions",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => $data,
    CURLOPT_HTTPHEADER => $headers
]);

$response = curl_exec($curl);
$httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
curl_close($curl);

if ($httpCode === 200) {
    $result = json_decode($response, true);
    // Processar resposta
} else {
    // Tratar erro
    echo "Erro na requisição: " . $httpCode;
}
?>

```

--------------------------------

### Payment Schemas and Responses

Source: https://ghostspay.readme.io/reference/post_transactions

This section details the data schemas used for payment requests and responses, including credit card details, boleto information, and error structures. It also outlines common HTTP responses like BadRequest, Unauthorized, and InternalError.

```APIDOC
## Payment API Schemas and Responses

### Schemas

#### CreditCardPaymentResponse
Represents the response for a credit card payment.

*   **holderName** (string) - Nome do titular
*   **lastDigits** (string) - Últimos 4 dígitos
*   **expirationMonth** (integer)
*   **expirationYear** (integer)

#### BoletoPaymentResponse
Represents the response for a boleto payment.

*   **boleto** (object)
    *   **bankSlipUrl** (string, uri) - URL do boleto em PDF
    *   **digitableLine** (string) - Linha digitável do boleto
    *   **barcode** (string) - Código de barras do boleto
    *   **expirationDate** (string, date) - Data de vencimento

#### ErrorResponse
Represents a general error response structure.

*   **error** (object)
    *   **code** (string) - Código identificador do erro
    *   **message** (string) - Mensagem descritiva do erro
    *   **details** (array of strings) - Detalhes específicos do erro

### Responses

#### BadRequest (400)
Requisição inválida - parâmetros malformados.

*   **Response Body Example**
    ```json
    {
      "error": {
        "code": "BAD_REQUEST",
        "message": "A requisição contém parâmetros inválidos",
        "details": [
          "O campo 'amount' deve ser um número inteiro"
        ]
      }
    }
    ```

#### Unauthorized (401)
Não autorizado - credenciais inválidas.

*   **Response Body Example**
    ```json
    {
      "error": {
        "code": "UNAUTHORIZED",
        "message": "Credenciais de autenticação inválidas"
      }
    }
    ```

#### ValidationError (422)
Erro de validação - dados não atendem aos requisitos.

*   **Response Body Example**
    ```json
    {
      "error": {
        "code": "VALIDATION_ERROR",
        "message": "Dados de entrada inválidos",
        "details": [
          "O e-mail deve ter um formato válido",
          "O valor mínimo é R$ 1,00"
        ]
      }
    }
    ```

#### InternalError (500)
Erro interno do servidor.

```

--------------------------------

### Authentication API

Source: https://ghostspay.readme.io/reference/introdu%C3%A7%C3%A3o

Details on how to authenticate requests to the GhostsPays API using Basic Authorization with Secret Key and Company ID.

```APIDOC
## Authentication API

### Description
This section describes the authentication method for accessing the GhostsPays API. All requests must be authenticated using Basic Authorization with your Secret Key and Company ID.

### Method
Authorization Basic

### Credentials
- **Username**: Secret Key
- **Password**: Company ID

### How to Obtain Credentials
1. Access the gateway panel.
2. Navigate to **Integrations → API Keys**.
3. Copy the **Secret Key** (used as username).
4. Copy the **Company ID** (used as password).

### Implementation
Include the credentials in the HTTP `Authorization` header using Basic Authentication.

#### Header Format
```
Authorization: Basic {base64_encoded_credentials}
```
Where `{base64_encoded_credentials}` is the Base64 encoding of `{SECRET_KEY}:{COMPANY_ID}`.

### Request Example (Node.js)
```javascript
const secretKey = "sua_secret_key_aqui";
const companyId = "seu_company_id_aqui";

const credentials = Buffer.from(`${secretKey}:${companyId}`).toString("base64");

const options = {
    method: "POST",
    url: "https://api.ghostspaysv2.com/functions/v1/transactions",
    headers: {
        "Authorization": `Basic ${credentials}`,
        "Content-Type": "application/json"
    }
};
```

### Request Example (PHP)
```php
<?php
$secretKey = "sua_secret_key_aqui";
$companyId = "seu_company_id_aqui";

$credentials = base64_encode($secretKey . ':' . $companyId);

$headers = [
    'Authorization: Basic ' . $credentials,
    'Content-Type: application/json'
];

$data = json_encode([
    "data" => "example"
]);

$curl = curl_init();
curl_setopt_array($curl, [
    CURLOPT_URL => "https://api.ghostspaysv2.com/functions/v1/transactions",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => $data,
    CURLOPT_HTTPHEADER => $headers
]);

$response = curl_exec($curl);
$httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
crl_close($curl);

if ($httpCode === 200) {
    $result = json_decode($response, true);
    // Processar resposta
} else {
    // Tratar erro
    echo "Erro na requisição: " . $httpCode;
}
?>
```

### Request Example (cURL)
```bash
curl -X POST \
  https://api.ghostspaysv2.com/functions/v1/transactions \
  -H "Authorization: Basic $(echo -n 'SECRET_KEY:COMPANY_ID' | base64)" \
  -H "Content-Type: application/json" \
  -d '{"data": "example"}'
```

### Error Handling
In case of invalid credentials, the API will return:

*   **Status Code**: `401 Unauthorized`
*   **Response**: `Unauthorized`
```

--------------------------------

### Address Object

Source: https://ghostspay.readme.io/reference/post_transactions

Defines the structure for address information, including street, number, zip code, neighborhood, city, state, and country. A complement field is also available.

```APIDOC
## Address Object

### Description
Defines the structure for address information.

### Properties
- **street** (string) - Required - Nome da rua/avenida
- **streetNumber** (string) - Required - Número do endereço
- **complement** (string) - Optional - Complemento (opcional)
- **zipCode** (string) - Required - CEP no formato 12345-678 ou 12345678
- **neighborhood** (string) - Required - Bairro
- **city** (string) - Required - Cidade
- **state** (string) - Required - Estado (UF), must be 2 uppercase letters
- **country** (string) - Required - País (código ISO), must be 2 uppercase letters

### Example
```json
{
  "street": "Rua das Flores",
  "streetNumber": "123",
  "complement": "Apartamento 101",
  "zipCode": "01234-567",
  "neighborhood": "Centro",
  "city": "São Paulo",
  "state": "SP",
  "country": "BR"
}
```
```

--------------------------------

### PixConfig Object

Source: https://ghostspay.readme.io/reference/post_transactions

Configuration for Pix payments, specifying the expiration period in days.

```APIDOC
## PixConfig Object

### Description
Configuration for Pix payments.

### Properties
- **expiresInDays** (integer) - Required - Dias para expiração do PIX. Must be between 1 and 7.

### Example
```json
{
  "expiresInDays": 1
}
```
```

--------------------------------

### Gerar Token de Cartão de Crédito com JavaScript

Source: https://ghostspay.readme.io/reference/tokeniza%C3%A7%C3%A3o-de-cart%C3%A3o-de-cr%C3%A9dito

Gera um token_id para um cartão de crédito VISA utilizando a biblioteca Ghostpays. Requer a definição da chave pública e a passagem dos dados detalhados do cartão, incluindo informações de pagamento.

```typescript
GhostsPays.setPublicKey("publicKey");
var token_id = await GhostsPays.encrypt({
    number: "4111111111111111",
    holderName: "João Silva",
    expMonth: 1,
    expYear: 2026,
    cvv: "456",
    amount: 1000,
    installments: 12
});
```

--------------------------------

### OpenAPI Definition for GhostsPays Payment API

Source: https://ghostspay.readme.io/reference/delete_transactions-id

This is the main OpenAPI 3.1.0 definition file for the GhostsPays Payment API. It describes the API's structure, including info, servers, tags, paths, and components. It supports PIX, credit card, and bank slip payments.

```json
{
  "openapi": "3.1.0",
  "info": {
    "title": "GhostsPays Payment API",
    "version": "1.0.0",
    "description": "API moderna para processamento de pagamentos com suporte a PIX, cartão de crédito e boleto bancário.",
    "contact": {
      "name": "Suporte GhostsPays",
      "url": "https://GhostsPays.com/suporte",
      "email": "suporte@GhostsPays.com"
    },
    "license": {
      "name": "MIT",
      "url": "https://opensource.org/licenses/MIT"
    }
  },
  "servers": [
    {
      "url": "https://api.ghostspaysv2.com/functions/v1",
      "description": "Ambiente de desenvolvimento"
    },
    {
      "url": "https://api.ghostspaysv2.com/functions/v1",
      "description": "Ambiente de produção"
    }
  ],
  "tags": [
    {
      "name": "Transactions",
      "description": "Gerenciamento do ciclo de vida das transações (consulta, estorno, entrega)"
    }
  ],
  "paths": {
    "/transactions/{id}": {
      "delete": {
        "tags": [
          "Transactions"
        ],
        "summary": "Estornar Transação",
        "description": "Realiza o estorno total ou parcial de uma transação paga. Apenas transações com status 'paid' podem ser estornadas.",
        "parameters": [
          {
            "name": "id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "format": "uuid"
            },
            "description": "ID único da transação"
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/RefundRequest"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Estorno processado com sucesso",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/RefundResponse"
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "500": {
            "$ref": "#/components/responses/InternalError"
          }
        },
        "security": [
          {
            "basicAuth": []
          }
        ]
      }
    }
  },
  "components": {
    "schemas": {
      "RefundRequest": {
        "type": "object",
        "properties": {
          "amount": {
            "type": "integer",
            "minimum": 1,
            "description": "Valor a ser estornado em centavos. Se omitido, estorna o valor total.",
            "example": 2500
          },
          "reason": {
            "type": "string",
            "maxLength": 500,
            "description": "Motivo do estorno",
            "example": "Produto não entregue"
          }
        }
      },
      "RefundResponse": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "format": "uuid",
            "description": "ID do estorno"
          },
          "transactionId": {
            "type": "string",
            "format": "uuid",
            "description": "ID da transação original"
          },
          "amount": {
            "type": "integer",
            "description": "Valor estornado em centavos"
          },
          "status": {
            "type": "string",
            "enum": [
              "processing",
              "completed",
              "failed"
            ],
            "description": "Status do estorno"
          },
          "createdAt": {
            "type": "string",
            "format": "date-time"
          }
        }
      },
      "ErrorResponse": {
        "type": "object",
        "required": [
          "error"
        ],
        "properties": {
          "error": {
            "type": "object",
            "required": [
              "code",
              "message"
            ],
            "properties": {
              "code": {
                "type": "string",
                "description": "Código identificador do erro",
                "example": "INVALID_CARD"
              },
              "message": {
                "type": "string",
                "description": "Mensagem descritiva do erro",
                "example": "Os dados do cartão são inválidos"
              },
              "details": {
                "type": "array",
                "description": "Detalhes específicos do erro",
                "items": {
                  "type": "string"
                },
                "example": [
                  "O CVV deve ter 3 ou 4 dígitos"
                ]
              }
            }
          }
        }
      }
    },
    "responses": {
      "BadRequest": {
        "description": "Requisição inválida"
      },
      "NotFound": {
        "description": "Recurso não encontrado"
      },
      "ValidationError": {
        "description": "Erro de validação"
      },
      "InternalError": {
        "description": "Erro interno do servidor"
      }
    }
  }
}

```

--------------------------------

### Webhook Event Statuses

Source: https://ghostspay.readme.io/reference/eventos-e-webhooks

This section lists the possible statuses a transaction can have, along with a description of each status and recommended actions for your system.

```APIDOC
## Transaction Statuses

### Description
Webhooks can indicate various states of a transaction. Understanding these statuses allows for appropriate actions within your system.

### Statuses

- **`waiting_payment`**: Transaction created, awaiting payment.
  * **Recommended Action**: Wait for the client to complete the payment.

- **`paid`**: Transaction paid successfully.
  * **Recommended Action**: Confirm delivery of the product/service.

- **`refused`**: Transaction was refused.
  * **Recommended Action**: Check the reason for refusal and notify the client.

- **`canceled`**: Transaction was canceled.
  * **Recommended Action**: Update your system and notify the client.

- **`refunded`**: Transaction was refunded.
  * **Recommended Action**: Update your system and check the reason for the refund.

- **`chargedback`**: Transaction experienced a chargeback.
  * **Recommended Action**: Initiate the chargeback dispute process.

- **`failed`**: Transaction failed.
  * **Recommended Action**: Check the reason for failure and attempt to retry.

- **`expired`**: Transaction expired.
  * **Recommended Action**: Offer the client a new payment option.

- **`in_analisys`**: Transaction is currently under analysis.
  * **Recommended Action**: Wait for the analysis result.

- **`in_protest`**: Transaction is under dispute.
  * **Recommended Action**: Initiate the dispute resolution process.
```

--------------------------------

### Authentication

Source: https://ghostspay.readme.io/reference/put_transactions-id-delivery

Details on the security schemes available for authenticating with the API.

```APIDOC
## Security Schemes

### Basic Authentication

**Type**: http
**Scheme**: basic
**Description**: Autenticação HTTP Basic usando API Key como username e deixando password vazio.
```
Tokens:
Raw