Salir a producción
Una vez finalizado el proceso de configuración y pruebas, tu integración estará lista para ser colocada en producción.
A continuación, mira las recomendaciones necesarias para realizar este cambio de manera eficaz y segura, garantizando que tu integración esté preparada para realizar transacciones reales.
Para asegurar la seguridad de tus transacciones Payouts, deberás realizar un cifrado de extremo a extremo. Esto implica la creación de un mecanismo de clave pública-privada, en el que un request se cifra por medio de una clave de seguridad, y otra clave se usa para validarlo.
Por lo tanto, deberás enviar tu clave pública a Mercado Pago para la validación de tus transacciones, y mantener tu clave privada almacenada de forma segura para cifrar tus requests.
X-signature con el body del request cifrado como valor. Para ambientes de desarrollo o de prueba, no es obligatorio enviarlo. Para más información, consulta nuestra Referencia de APIAPI.Para crear las llaves pública y privada en Linux o MacOS, ejecuta el siguiente comando en tu terminal:
terminalopenssl genpkey -algorithm ed25519 -out mpprivate.pem && openssl pkey -in mpprivate.pem -pubout -out mppublic.pem
En respuesta, se generarán dos archivos, uno con tu clave pública, que debes enviar a Mercado Pago, y otro con la clave privada, que debes almacenar de forma segura en tu sistema.
Para enviar tu clave pública, deberás conectarte con el equipo de Integraciones. A continuación, te proporcionamos el siguiente ejemplo de solicitud, en el que se lee el archivo private.key, se cifra el request y se agrega la firma al 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()
Después de realizar las pruebas de tu integración, activa el entorno de producción antes de comenzar a procesar transacciones reales.
Para activar el entorno de producción y obtener las credenciales, sigue estos pasos:
-
Accede a Integraciones y selecciona la aplicación.
-
Haz clic en Credenciales en el menú lateral.
-
Selecciona Producción en el selector de entorno y haz clic en Activar ambiente de producción.
-
Completa el sector de actividad y el sitio web de tu negocio.
-
Acepta la Declaración de Privacidad y los Términos y condiciones. Luego, haz clic en Activar.
Una vez activado el entorno, encontrarás las credenciales de producción disponibles para la aplicación: Public Key, Access Token, Client ID y Client Secret. Reemplaza la Public Key y el Access Token de prueba por los de producción antes de comenzar a procesar operaciones reales.

La Public Key y el Access Token se utilizan para integrar los pagos. El Client ID y el Client Secret se utilizan principalmente en integraciones que implementan OAuth, especialmente mediante el flujo Client Credentials.
| Tipo | Descripción |
| Public Key | Clave pública vinculada a una aplicación, utilizada en el frontend para inicializar la integración durante operaciones reales. |
| Access Token | Clave privada de producción utilizada en el backend para autenticar las solicitudes a las APIs de Mercado Pago. Nunca debe compartirse ni exponerse en el frontend. |
| Client ID | Identificador único que representa la aplicación en integraciones que implementan OAuth. |
| Client Secret | Clave privada utilizada junto con el Client ID para autenticar la aplicación. Nunca debe compartirse ni exponerse en el frontend. |
Antes de copiar una credencial, verifica que el selector muestre el entorno Producción.
Para más información, consulta la documentación de Credenciales.