Subir em produção
Uma vez finalizado o processo de configuração e dos testes, sua integração estará pronta para ser colocada em produção.
Veja abaixo as recomendações necessárias para realizar essa mudança de maneira eficaz e segura, garantindo que a integração esteja preparada para realizar transações reais.
Para garantir a segurança de suas transações Payouts, você deve realizar uma criptografia de ponta a ponta. Isso envolve a criação de um mecanismo de chave pública-privada, no qual um request é criptografado por meio de uma chave de segurança, e outra chave é usada para validá-lo.
Portanto, você deve enviar sua chave pública para o Mercado Pago para a validação de suas transações, e manter sua chave privada armazenada de forma segura para criptografar seus requests.
X-signature com o body do request criptografado como valor. Para ambientes de desenvolvimento ou de teste, não é obrigatório enviá-lo. Para mais informações, consulte nossa Referência de APIAPI.Para criar as chaves pública e privada no Linux ou MacOS, execute o seguinte comando em seu terminal:
terminalopenssl genpkey -algorithm ed25519 -out mpprivate.pem && openssl pkey -in mpprivate.pem -pubout -out mppublic.pem
Em resposta, serão gerados dois arquivos, um com sua chave pública, que você deve enviar ao Mercado Pago, e outro com a chave privada, que deve ser armazenada de forma segura em seu sistema.
Para enviar sua chave pública, você precisará se conectar com a equipe de Integrações. Abaixo, fornecemos o seguinte exemplo de requisição, no qual o arquivo private.key é lido, o request é criptografado e a assinatura é adicionada ao header.
package main
import (
"bytes"
"crypto/ed25519"
"crypto/x509"
"encoding/base64"
"encoding/pem"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
// Path to the file storing the private key
privateKeyFile := "private.key"
// Read the private key from the file
privateKeyBytes, err := ioutil.ReadFile(privateKeyFile)
if err != nil {
fmt.Println("Error reading private key:", err)
return
}
// Convert the private key bytes to a PrivateKey
privateKey := ed25519.PrivateKey(privateKeyBytes)
// Define your request body
requestBody := []byte(`{"key": "value"}`)
// Sign the request body with the private key
signature := ed25519.Sign(privateKey, requestBody)
// Encode the signature to base64
signatureBase64 := base64.StdEncoding.EncodeToString(signature)
// Create a new HTTP request
req, err := http.NewRequest("POST", "https://example.com/api/endpoint", bytes.NewBuffer(requestBody))
if err != nil {
fmt.Println("Error creating request:", err)
return
}
// Add the X-signature header with the base64 encoded signature
req.Header.Set("X-signature", signatureBase64)
// Send the request
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
fmt.Println("Error sending request:", err)
return
}
defer resp.Body.Close()
// Read the response body
responseBody, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println("Error reading response body:", err)
return
}
// Print the response body
fmt.Println("Response:", string(responseBody))
}
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import ed25519
import base64
import json
def main():
# PEM formatted private key
private_key_pem = b'''************************************************'''
try:
# Load the private key from PEM format
private_key = serialization.load_pem_private_key(
private_key_pem,
password=None # No password protection in this example
)
# Ensure we have an Ed25519 private key
if not isinstance(private_key, ed25519.Ed25519PrivateKey):
print("Error: The provided key is not a valid Ed25519 private key")
return
# Define request body as a Python dict
request_data = b'''{REQUEST_BODY}'''
# Use request_data directly as it's already in bytes
request_body = request_data
print("Request body that will be signed:")
print(request_data.decode('utf-8')) # Print the request body
print("\n---\n")
# Sign the request body
signature = private_key.sign(request_body)
# Get the public key
public_key = private_key.public_key()
# Encode signature to base64
signature_base64 = base64.b64encode(signature).decode('utf-8')
# Print results
print(f"Generated signature: {signature_base64}")
print(f"Signature size: {len(signature)} bytes")
# Get key sizes
private_bytes = private_key.private_bytes(
encoding=serialization.Encoding.Raw,
format=serialization.PrivateFormat.Raw,
encryption_algorithm=serialization.NoEncryption()
)
public_bytes = public_key.public_bytes(
encoding=serialization.Encoding.Raw,
format=serialization.PublicFormat.Raw
)
print(f"Private key size: {len(private_bytes)} bytes")
print(f"Public key size: {len(public_bytes)} bytes")
# Verify the signature
try:
public_key.verify(signature, request_body)
print("✓ Signature verified successfully!")
except Exception:
print("✗ Signature verification failed!")
except Exception as e:
print(f"Error: {str(e)}")
if __name__ == "__main__":
main()
Depois de realizar os testes da sua integração, ative o ambiente de produção antes de começar a processar transações reais.
Para ativar o ambiente de produção e obter as credenciais, siga estas etapas:
-
Acesse Integrações e selecione a aplicação.
-
Clique em Credenciais no menu lateral.
-
Selecione Produção no seletor de ambiente e clique em Ativar ambiente de produção.
-
Preencha o setor de atuação e o site do seu negócio.
-
Aceite a Declaração de Privacidade e os Termos e condições. Depois, clique em Ativar.
Após ativar o ambiente, você encontrará as credenciais de produção disponíveis para a aplicação: Public Key, Access Token, Client ID e Client Secret. Substitua a Public Key e o Access Token de teste pelos de produção antes de começar a processar operações reais.

A Public Key e o Access Token são utilizados para integrar os pagamentos. O Client ID e o Client Secret são utilizados principalmente em integrações que implementam OAuth, especialmente por meio do fluxo Client Credentials.
| Tipo | Descrição |
| Public Key | Chave pública vinculada a uma aplicação, utilizada no frontend para inicializar a integração durante operações reais. |
| Access Token | Chave privada de produção utilizada no backend para autenticar as solicitações às APIs do Mercado Pago. Nunca deve ser compartilhada nem exposta no frontend. |
| Client ID | Identificador único que representa a aplicação em integrações que implementam OAuth. |
| Client Secret | Chave privada utilizada junto com o Client ID para autenticar a aplicação. Nunca deve ser compartilhada nem exposta no frontend. |
Antes de copiar uma credencial, verifique se o seletor exibe o ambiente Produção.
Para mais informações, consulte a documentação de Credenciais.