---
updatedAt: 2026-04-06T17:18:33.000Z
agentTools:
  projectIndex: https://docs.pagar.me/v2/llms.txt
---

# Gerando card_hash manualmente

O card_hash representa uma versão criptografada das dados holder_name, expiration date, cvv, e number de um cartão. Nesta seção você vai aprender mais sobre como o hash é criado, e quais algoritmos utilizar.

## Utilizando a Pagar.me JS

```javascript JS
const pagarme = require('pagarme')

pagarme.client.connect({ encryption_key: 'SUA_ENCRYPTION_KEY' })
  .then(client => {
    return client.security.encrypt({
      card_number: '4111111111111111',
      card_holder_name: 'abc',
      card_expiration_date: '1225',
      card_cvv: '123',
    })
  })
  .then(card_hash => console.log(card_hash))
```

A maneira mais fácil de gerar um card\_hash é utilizando a nossa biblioteca de Javascript *Pagar.me JS*. O método acima funciona tanto com api quanto com encryption key. Como essa operação normalmente é feita no cliente, utilize a encryption key para proteger a sua chave de api.

## Passo a passo

O card\_hash consiste de uma string gerada a partir dos dados do cartão de crédito. Essa string é encriptada por RSA usando uma chave pública que deve ser requisitada ao servidor a cada novo card\_hash gerado. Essa chave é invalidada assim que o servidor lê as informações contidas no card\_hash, e por isso só pode ser utilizada uma única vez. Ela também é temporária, expirando 5 minutos após ter sido gerada. As bibliotecas do Pagar.me sempre utilizam o card\_hash para enviar os dados para o servidor, o que aumenta consideravelmente a segurança da transação.

## 1. Gerando uma nova chave para encriptação

Essa rota deverá ser utilizada para obtenção de uma chave pública de encriptação dos dados do cartão de seu cliente:

```shell
curl -X GET https://api.pagar.me/1/transactions/card_hash_key -H 'content-type: application/json' -d '{
    "encryption_key": "SUA_ENCRYPTION_KEY"
}'
```

A resposta terá o formato:

```json
{
  "date_created": "2017-06-29T18:27:35.266Z",
  "id": 652477,
  "ip": "000.000.000.000",
  "public_key": "-----BEGIN PUBLIC KEY----- ... -----END PUBLIC KEY-----\n"
}
```

Sendo:

<Table align={["left","left"]}>
  <thead>
    <tr>
      <th>
        Propriedade
      </th>

      <th>
        Descrição
      </th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td>
        **id**
        `Number`
      </td>

      <td>
        id retornado e que será utilizado para compor o card\_hash, logo, é importante que você o reserve.
      </td>
    </tr>

    <tr>
      <td>
        **public\_key**\
        `String`
      </td>

      <td>
        Chave pública utilizada para criptografar os dados do cartão.
      </td>
    </tr>

    <tr>
      <td>
        **ip**\
        `String`
      </td>

      <td>
        IP de onde a request foi originada.
      </td>
    </tr>
  </tbody>
</Table>

## 2. Encriptando os dados do cartão de crédito

Agora você vai ter que criar uma `QueryString` com valores `URLEncoded` para os parâmetros do cartão de crédito. Vamos pegar os seguintes dados abaixo como exemplo:

card\_number = 4901720080344448\
card\_holder\_name = "Aardvark Silva"\
card\_expiration\_date = 1213\
card\_cvv = 314

A querystring ficará composta na seguinte forma:

```markdown querystring data
card_number=4901720080344448&card_holder_name=AardvarK%20Silva&card_expiration_date=1213&card_cvv=314
```

Agora você vai fazer uma criptografia pública com `RSA` e o padding `PKCS1Padding` usando a `public_key` que você recebeu na request passando a QueryString construída.

Após criptografar esses dados você deve converter o resultado para base64. Como resultado você terá:

```markdown hash criado a partir de RSA e PKCS1Padding
FFtwikzg/FC1mH7XLFU5fjPAzDsP0ogeAQh3qXRpHzkIrgDz64lITBUGwio67zm2CQXwbKRjGdRi5J1xFNpQLWnxQsUJAQELcTSGaGtF6RGSu6sq1stp8OLRSNG7wp+xGe8poqxw4S1gOL5JYO7XZp/Uz7rTpKXh3IcRshmX36hh66J6+7l5j0803cGIfMZu3T7nbMjQYIf+yLi8r0O6vL9DQPmqSZ9FBerqFGxWHrxScneaaMVzMpNX/5eneqveVBt88RccytyJG5+HYRHcRyKIbLfmX48L/C22HJeAm3PyzehGHdOmDcsxPtVB+Fgq7SDuB4tHWBT8j6wihOO7ww==
```

Agora com o id vindo da request inicial, e os dados criptografados convertidos para base64, seu card\_hash deverá ser formatado da seguinte maneira:

**card*hash = id + "*" + encrypted\_string\_base64**, com o resultado na seguinte forma:

```markdown card_hash - formato final
111111_FFtwikzg/FC1mH7XLFU5fjPAzDsP0ogeAQh3qXRpHzkIrgDz64lITBUGwio67zm2CQXwbKRjGdRi5J1xFNpQLWnxQsUJAQELcTSGaGtF6RGSu6sq1stp8OLRSNG7wp+xGe8poqxw4S1gOL5JYO7XZp/Uz7rTpKXh3IcRshmX36hh66J6+7l5j0803cGIfMZu3T7nbMjQYIf+yLi8r0O6vL9DQPmqSZ9FBerqFGxWHrxScneaaMVzMpNX/5eneqveVBt88RccytyJG5+HYRHcRyKIbLfmX48L/C22HJeAm3PyzehGHdOmDcsxPtVB+Fgq7SDuB4tHWBT8j6wihOO7ww==
```

> 📘 Por que preciso do card\_hash?
>
> Partindo da definição do card\_hash: 'uma string gerada a partir dos dados de cartão', a principal função do card\_hash é criar uma forma de transmissão segura para dados tão sensíveis quanto o que estamos tratando. Ou seja, sempre que as informações de cobrança do cartão precisarem trafegar entre o client-side e seus servidores, indicamos a utilização de card\_hash, para uma camada a mais de segurança.