NAV Navbar
Logo
shell ruby python javascript

Introducción

Bienvenido a nuestra guía completa de implementación de la API Etomin. Aquí podrás encontrar todos los pasos e información necesaria para la correcta implementación en tu comercio o negocio.

Antes de comenzar, es importante mencionar que todas las respuestas provenientes de nuestra API están en formato JSON, por lo que es muy importante conocer los temas siguientes para hacer una implementación exitosa:

REST API - http://asiermarques.com/2013/conceptos-sobre-apis-rest/

JSON - https://geekytheory.com/json-i-que-es-y-para-que-sirve-json/

¿Por dónde comienzo?

Ahora que ya tienes estos conocimientos básicos, estás más cerca de poder disfrutar de toda las ventajas y flexibilidad que Etomin puede darle a tu comercio o negocio. A continuación te presentamos los pasos a seguir para la implementación de nuestra API.

Activación de cuenta

Figura 1:

Figura 2:

Por el momento, ya estamos registrados pero aún la cuenta no se encuentra activa como podemos ver en la parte superior de nuestra pantalla (barra amarilla y switch en test). Es importante mencionar, que la implementación y las pruebas, pueden seguir aún sin la activación de la cuenta. (Figura 1)

Para solicitar la activación de nuestra cuenta, primero debemos de cargar nuestros datos a la plataforma. Para esto es necesario ir a parte superior derecha y hacer click en la imagen redonda, y del menú desplegable, elegir la opción “Configuración”. (Figura 2)

A continuación es necesario llenar la información pertinente acerca de tu negocio. Es muy importante completar de forma adecuada y con los datos correctos los campos, ya que estos serán la información utilizada para los pagos, facturación, etc.

Una vez que la información ha sido enviada, la implementación puede iniciar, aunque queda aclarar, que aún se espera la respuesta del administrador para la activación de la cuenta.

Llaves API

Figura 3:

A continuación, seguiremos con la configuración tanto del ambiente productivo como el de pruebas. En la misma pantalla de configuración, existe un apartado donde podemos encontrar nuestras API KEYs. (Figura 3)

En esta sección te proporcionamos dos llaves para cada modo, una pública y una privada:

Llave pública

La llave pública se utiliza para cifrar los datos que nos envías (por ejemplo, para tokenizar la información de la tarjeta) y puedes utilizarla en el front-end.

LLave privada

La llave privada permite autenticarte en la aplicación y generar los cargos. Esta llave se utiliza únicamente en el back-end y no debes compartirla con nadie.

Conexión al ambiente

Para que tu negocio se pueda comunicar con nuestra API, es necesario definir la dirección del ambiente. En nuestro caso, y para comodidad tuya, el ambiente de pruebas y el de producción comparten la misma dirección.

Dirección de ambientes

https://api.etomin.com/

Operaciones básicas

Tipo de operación Función URL
GET getPaymentMethod https://api.etomin.com/API/v1.0/seller/:public_key/payment_methods
GET getPayment https://api.etomin.com/API/v1.0/seller/:public_key/payment/:id
POST makePayment https://api.etomin.com/API/v1.0/payment
POST makeRefund https://api.etomin.com/API/v1.0/payment/refund

Antes de comenzar con los movimientos, es importante saber que solamente hay dos tipos de servicios disponibles a través de nuestra API: POST y GET. A continuación te brindamos algunos ejemplos para utilizar estos servicios:

Tipo de operación Función Descripción
GET getPaymentMethod Regresa los tipos de pago disponibles del vendedor.
GET getPayment Regresa un pago en específico.
POST makePayment Realiza una transacción de pagos.
POST makeRefund Genera la devolución de un pago.

Sesión de Pago

<script>type=“text/javascript” src=“https://api.etomin.com/API/v1.0/js/etomin.out.min.js”></script>

    $("#payment-form").on("submit", function(event){
        event.preventDefault();

        etomin.autentication(function(err, session) {
            if (err) {
                console.log('err', err);
                return;
            };

            let _deviceSessionId = session;
            $.post([API.ENVIROMENT]/API/v1.0/payment, {
                "transaction": {
                    "payer": {...},
                    "order": {...},
                    "payment": {...},
                    "device_session_id": _deviceSessionId
                }
            });
        });

        return false;
    });

Las sesión de pago es un requisito fundamental para generar un cobro en etomin, ya que esta nos permite tener mucho mas control en los pagos que se generan desde tu negocio.

Para empezar incluye el siguiente script etomin.out.min.js dentro de la etiqueta <HEAD> de tu pagina web, esto te permitirá generar una sesión para realizar un cobro.

Recuerda que cada cobro que generes debe tener una sesión de pago única, para poder generarla se debe ejecutar la siguiente función etomin.autentication() y debe ser asignada a la variable device_session_id requerida en los parámetros necesarios para generar un cargo.

Pagos

    Tarjeta de Crédito/Débito
{
  "public_key": [type: string, required: true],
  "transaction": {
      "order": {
        "external_reference": [type: string, required: true],
      },
      "payer": {
            "email": [type: string, required: true],
        },
        "payment": {
            "amount": [type: number, required: true],
            "payment_method": [type: string, required: true],
            "currency": [type: string, required: true],
            "payment_country": [type: string, required: true],
            "token":"6195dc41083440b643de97458aa0c6da",
        },
        "ip_address": [type: string, required: true],
        "device_session_id": [type: string, required: true]
  }
}

OXXO Y SPEI

{
  "public_key": [type: string, required: true],
  "transaction": {
      "order": {
        "external_reference": [type: string, required: true],
      },
      "payer": {
            "email": [type: string, required: true],
        },
        "payment": {
            "amount": [type: number, required: true],
            "payment_method": [type: string, required: true],
            "currency": [type: string, required: true],
            "payment_country": [type: string, required: true],
            "limit_date_payment": [type: string, required: true, only: 'offline', format: DD-MM-YYYY],
        },
        "ip_address": [type: string, required: true],
        "device_session_id": [type: string, required: true]
  }

Parámetros Disponibles 

}
  "public_key": [type: string, required: true],
  "transaction": {
      "order": {
        "external_reference": [type: string, required: true],
        "description": [type: string, required: true],
        "notification_url": "https://www.notification.com/example",
        "success_url": "https://www.succes.com/example",
        "failure_url": "https://www.failure.com/example"
      },
      "payer": {
            "email": [type: string, required: true],
            "firstName": [type: string, required: true],
            "lastName": [type: string, required: true],
            "dni_number": [type: number, required: true],
            "tax_number": [type: number, required: true],
            "shippingAddress": {
                "description": [type: string, required: true],
                "street_name": [type: string, required: true],
                "street_number": [type: number, required: true],
                "apartment_number": [type: string, required: true],
                "neighbour": [type: string, required: true],
                "city": [type: string, required: true],
                "state": [type: string, required: true],
                "zipcode": [type: number, required: true],
                "address_type":[type: number, required: true],
                "country": [type: string, required: true]
            },
            "billingAddress": {
                "description": [type: string, required: true],
                "street_name": [type: string, required: true],
                "street_number": [type: number, required: true],
                "apartment_number": [type: string, required: true],
                "neighbour": [type: string, required: true],
                "city": [type: string, required: true],
                "state": [type: string, required: true],
                "zipcode": [type: number, required: true],
                "address_type": [type: number, required: true],
                "country": [type: string, required: true]
            }  
        },
        "items": [{
            "sku": [type: string, required: true],
            "quantity": [type: number, required: true],
            "unit_price": [type: number, required: true],
            "description": [type: number, required: true],
            "picture_url": "https://www.bekko.com.mx/assets/img/etomin-d4d3841fd35a552511924e3e961a0fcc.png",
            "category_id": [type: number, required: true]
        }],
        "payment": {
            "amount": [type: number, required: true],
            "payment_method": [type: string, required: true],
            "currency": [type: string, required: true],
            "payment_country": [type: string, required: true],
            "limit_date_payment": [type: string, required: true, only: 'offline', format: DD-MM-YYYY],
            "token": [type: string, required: true]

        },
        "extraParameters": {
            "plan": [type: int, required: false],
            "installments": [type: int, required: false],
            "statement_descriptor": [type: string, required: false]
        },
        "ip_address": [type: int, required: false],
        "cookie": [type: string, required: false],
        "user_agent": [type: string, required: false],
        "payment_pending": [type: bolean, required: true],
        "device_session_id": [type: string, required: true]
     },
     "test": [type: bolean, required: false]
    }
}



Con nuestra plataforma podrás hacer 3 tipos de pagos con diferentes métodos dentro de la pasarela:

Para todos los pagos, independientemente del tipo, deberás ejecutar las siguientes funciones:

  1. Obtener el ID de la sesión que deberás devolver junto con la información del pago. Este ID será único para cada movimiento
  2. Generar pago, enviando la información requerida según el tipo de pago:
    1. “transaction”: Datos de la transacción de pago
      1. “order”: Con esta función se envía una referencia para identificar cada pago y se especifican las URL en las que se recibirán las respuestas de la aplicación
      2. “payment”: Información específica del pago; los parámetros dependerán del tipo de pago
      3. “payer”: Datos del comprador y dirección de envío de mercancía
      4. “billingAddress”: Datos de facturación del comprador
    2. “ítems”: Esta función es opcional y envía a Etomin la información de los artículos comprados
    3. “extraParameters”: Parámetros adicionales de la operación, por ejemplo, cantidad de pagos diferidos o plan de suscripción en el cual el comprador será incluido
    4. Datos adicionales de la sesión, como dirección IP del comprador
  3. Configurar el webhook para recibir la respuesta cuando esta no es inmediata (cuando el pago queda pendiente, devolución, contracargo)

Parámetros Obligatorios

Para la generación de un pagos con Tarjeta de Crédito/Débito, OXXO, SPEI, Bancomer o Paynet es fundamental que cuentes con los siguientes parámetros obligatorios.

Parámetros Disponibles

todos los parámetros disponibles para hacer una transacción

REQUEST

Parámetros Descripción
order array (requerido)
Contiene parámetros para generar un pago
description string (requerido)
Descripción de pago
notification_url string
succes_url string
failure_url string
payer array (requerido)
Contiene parámetros sobre la información del cliente
firstName string (requerido)
Nombre(s) del cliente
lastName string (requerido)
Apellidos del cliente
email string (requerido)
Email del cliente
dni_number string
Documento Nacional de Identidad del cliente
tax_number string
Número de identificación tributaria del cliente
shippingAddress array (requerido)
Contiene parámetros para la dirección de envío
billingAddress array
Contiene parámetros para la dirección de facturación
description string (requerido)
Descripción de la dirección del cliente
street_name string (requerido)
Nombre de la calle del cliente
street_number string (requerido)
Número exterior del la dirección
apartment_number string
Número interior de la dirección del cliente
neighbour string (requerido)
Colonia del cliente
city string (requerido)
Delegación/Municipio del cliente
state string (requerido)
Estado del cliente
zipcode string (requerido)
Codigo postal del cliente
addres_type number
country string (requerido)
País del cliente
items array (requerido)
Contiene parámetros sobre la información de los productos
sku string (requerido)
Identificador del producto
quatity number (requerido)
Cantidad de productos seleccionados
unit_price number (requerido)
Precio unitario del producto
description string
Descripción del producto seleccionado
picture_url string
URL de la imágen del producto
category_id number
extraParameters array
Contiene parámetros opcionales
installments number
statement_descriptor string
ip_address string
cookie string
user_agent string

Tarjeta de crédito o débito

GENERAR PAGO: [POST] https://api.etomin.com/API/v1.0/payment

    curl -H "Content-Type: application/json" -X POST -d file.json https://api.etomin.com/API/v1.0/payment

    JSON simple para generar pagos con tarjetas "VISA/MASTERCARD" :

{
    "public_key": "public_key",
    "transaction": {
                "payer": {
                    "email": "test@test.com"
                },
        "order": {
            "external_reference": "reference-0001"
        },
        "payment": {
            "amount": 100,
            "payment_method": "VISA",
            "currency": "MXN",
            "payment_country": "MEX",
           "token":"6195dc41083440b643de97458aa0c6da"
        },
        "payment_pending": false,
        "device_session_id": "149073421142142231262335",
    },
    "test": true
}


#Respuesta de pago con tarjeta VISA/MASTERCARD

{
    "status": "APPROVED",
    "transaction": "11976",
    "authorization_code": "531765D",
    "payment_method": "VISA",
    "payment_token": "ee2453e5fc84c75f41fc73005db28972",
    "code": 201,
    "error": "0",
    "message": "Approved+by+Payworks+%28test+mode%29",
    "credit_card": "************1111",
    "order": "13010"
}

//generando pago con tarjeta VISA/MASTERCARD

var http_auth = new XMLHttpRequest();
var http_charge = new XMLHttpRequest();

http_auth.open("GET", "https://api.etomin.com/API/v1.0/kount/auth", true);
http_charge.open("POST", "https://api.etomin.com/API/v1.0/payment",true);

var params = {
    "public_key": "PB_key_tst_",
    "transaction": {
                            "payer": {
                                    "email": "test@test.com"
                            },
            "order": {
                    "external_reference": "reference-0001-res"
            },
            "payment": {
                    "amount": 100,
                    "payment_method": "VISA",
                    "currency": "MXN",
                    "payment_country": "MEX",
                    "number": "4111111111111111",
                    "securityCode": "123",
                    "expirationDate": "03/18",
                    "name": "Luis Cruz",
            },
            "payment_pending": false,
            "device_session_id": "",
    },
    "test": true
}

http_auth.onreadystatechange = function() {
    if (this.readyState == 4 && this.status == 200) {
         var result = JSON.parse(this.responseText);
         params.transaction.device_session_id = result.session_id; // se agrega el session id
         http_charge.send(JSON.stringify(params)); // se manda a generar el pago
    }
};

http_charge.onreadystatechange = function() {
    if (this.readyState == 4 &&  this.status == 201) {
         console.log(this.responseText);
    }
};

http_auth.send();


//Respuesta de pago con tarjeta VISA/MASTERCARD

{
    "status": "APPROVED",
    "transaction": "11976",
    "authorization_code": "531765D",
    "payment_method": "VISA",
    "payment_token": "ee2453e5fc84c75f41fc73005db28972",
    "code": 201,
    "error": "0",
    "message": "Approved+by+Payworks+%28test+mode%29",
    "credit_card": "************1111",
    "order": "13010"
}

#generando pago con tarjeta VISA/MASTERCARD

import requests
import json

headers = {'content-type': 'application/json'}
url = 'https://api.etomin.com/API/v1.0/kount/auth'
url_charge = 'https://api.etomin.com/API/v1.0/payment'

data = {}
params = {
    "public_key": "PB_key_tst_d861621e313dc98dad0a2f0678a2d36f",
    "transaction": {
                            "payer": {
                                    "email": "test@test.com"
                            },
            "order": {
                    "external_reference": "reference-0001-res-1"
            },
            "payment": {
                    "amount": 100,
                    "payment_method": "VISA",
                    "currency": "MXN",
                    "payment_country": "MEX",
                    "number": "4111111111111111",
                    "securityCode": "123",
                    "expirationDate": "03/18",
                    "name": "Luis Cruz"
            },
            "payment_pending": False,
            "device_session_id": ""
    },
    "test": True
}

auth = requests.get(url);
if auth.status_code == 200:
    obj = json.loads(auth.text)
    params["transaction"]["device_session_id"] = obj["session_id"]
    charge = requests.post(url_charge, params={}, data=json.dumps(params), headers=headers)
    obj_charge = json.loads(charge.text)
    print obj_charge


#Respuesta de pago con tarjeta VISA/MASTERCARD

{
    "status": "APPROVED",
    "transaction": "11976",
    "authorization_code": "531765D",
    "payment_method": "VISA",
    "payment_token": "ee2453e5fc84c75f41fc73005db28972",
    "code": 201,
    "error": "0",
    "message": "Approved+by+Payworks+%28test+mode%29",
    "credit_card": "************1111",
    "order": "13010"
}

#generando pago con tarjeta VISA/MASTERCARD

require 'net/http'
require 'json'

uri = URI('https://api.etomin.com/API/v1.0/kount/auth')
uri_charge = URI.parse('https://api.etomin.com/API/v1.0/payment')
res = Net::HTTP.get_response(uri)


params = {
    :public_key => "PB_key_tst_d861621e313dc98dad0a2f0678a2d36f",
    :transaction => {
                            :payer => {
                                    :email => "test@test.com"
                            },
            :order=> {
                    :external_reference=> "reference-0004-res"
            },
            :payment => {
                    :amount => 100,
                    :payment_method =>"VISA",
                    :currency =>"MXN",
                    :payment_country =>"MEX",
                    :number =>"4111111111111111",
                    :securityCode =>"123",
                    :expirationDate =>"03/18",
                    :name =>"Luis Cruz",
            },
            :payment_pending => false,
            :device_session_id => ""
    },
    :test => true
}

if res.code == "200"
  result_auth = JSON.parse(res.body);
  params[:transaction][:device_session_id] = result_auth["session_id"]
  http = Net::HTTP.new(uri_charge.host, uri_charge.port)
  http.use_ssl = true
  header = {'Content-Type'=> 'text/json'}
  request = Net::HTTP::Post.new(uri_charge.request_uri, header)
  request.body = params.to_json
    # Send the request
   response = http.request(request)
   puts response.read_body;
end


#Respuesta de pago con tarjeta VISA/MASTERCARD

{
    "status": "APPROVED",
    "transaction": "11976",
    "authorization_code": "531765D",
    "payment_method": "VISA",
    "payment_token": "ee2453e5fc84c75f41fc73005db28972",
    "code": 201,
    "error": "0",
    "message": "Approved+by+Payworks+%28test+mode%29",
    "credit_card": "************1111",
    "order": "13010"
}

Cuando envías desde tu sistema a Etomin los datos de la tarjeta de crédito o débito, la información es tokenizada, analizada por nuestro motor antifraude y posteriormente procesada para que la institución bancaria confirme el pago.

En la función “payment” deberás enviar la información que se muestra:

Nota: Para ver los valores posibles de los parámetros “payment_method”, “currency” y “payment_country” consulta la sección Datos ISO de esta documentación.

Nota: Para efectuar pruebas de las diferentes respuestas que puedes recibir al procesar un pago, utiliza los siguientes valores en el nombre del tarjetahabiente en modo Test:

“name”: “APPROVED” Pago Aprobado

“name”: “DECLINED” Pago Declinado

“name”: “PENDING” Pago Pendiente

tokenización de tarjetas

Es necesario tokenizar la tarjeta antes de generar la petición de pago.

Para la tokenización se debe generar un petición via POST con los datos de la tarjeta al siguiente servicio:

JSON para generar token de la tarjeta con el método POST a https://api.etomin.com/API/v1.0/seller/:api_key/card/token

REQUEST
curl -i -X POST https://api.etomin.com/API/v1.0/seller/:public_key/card/token -H 'Content-Type: application/json' -d '{"card": {"cardholder": "Nombre del tajetahabiente", "number": "4111111111111111", "cvv": "123", "expirationDate":"10/20"}}'

RESPONSE
{

  "error": 0,

  "card": "4111 ****** 1111",

  "token": "6195dc41083440b643de97458aa0c6da"

}

JSON para generar pagos con el método POST a https://api.etomin.com/API/v1.0/payment.

Card Type:Object Descripcion
cardholder string Titular de la tarjeta
number string Número de la tarjeta
cvv string Código de tarjeta
expirationDate string Fecha de expiración
plan string Identificador de plan de pago a suscribirse

REQUEST

Parámetros Descripción
public_key string (requerido)
Llave pública que se encuentra en la cuenta del seller
transaction array (requerido)
Contiene parámetros para realizar la transacción
payer array (requerido)
Contiene parámetros para realizar un pago
email string (requerido)
Email del cliente que realizará el pago
order array (requerido)
Contiene parámetros acerca de la orden
external_reference string (requerido)
Referencia para identificar el pago
payment array (requerido)
Contiene información sobre el pago
amount number (requerido)
Cantidad que se va a pagar
payment_method string (requerido)
Tipo de tarjeta con la que se realizará el pago. Se cuenta con Visa y Master Card
currency string (requerido)
Tipo de moneda con la que se va a realizar el pago. Solo se cuenta con MXN
payment_country string (requerido)
País donde se realiza el pago. Puede ser México, Colombia y Estados Unidos
number string (requerido)
Número de la tarjeta con la que se realiza el pago
securityCode string (requerido)
Código de seguridad de la tarjeta con la que se realiza el pago
expirationDate date (requerido)
Fecha de expiración de la tarjeta con l que se realiza el pago
name string (requerido)
Nombre del tarjetahabiente
payment_pending float (requerido)
Se refiere si el pago se mostrará como pendiente
device_session_id string (requerido)
Es un número único que Etomin asigna al usuario para la duración de la visita
test float (requerido)
Se refiere que si el pago será en modo test o live

Transferencia (SPEI) o depósito bancario

GENERAR PAGO: [POST] https://api.etomin.com/API/v1.0/payment

    curl -H "Content-Type: application/json" -X POST -d file.json https://api.etomin.com/API/v1.0/payment

    JSON simple para generar pagos con referencia "SPEI"  :

    {
        "public_key": "public_key",
        "transaction": {
                    "payer": {
                        "email": "test@test.com"
                    },
            "order": {
                "external_reference": "reference-0002"
            },
            "payment": {
                "amount": 100,
                "payment_method": "SPEI",
                "currency": "MXN",
                "payment_country": "MEX",
                "limit_date_payment": "10-04-2017"
            },
            "payment_pending": false,
            "device_session_id": "149073421142142231262336",
        },
        "test": true
    }


#Respuesta de pago con SPEI

{
    "status": "PENDING",
    "transaction": "11978",
    "authorization_code": 0,
    "payment_method": "SPEI",
    "code": 201,
    "deposit_account": "646180122420000046",
    "error": "0",
    "order": "13012"
}

//generando pago con SPEI

var http_auth = new XMLHttpRequest();
var http_charge = new XMLHttpRequest();

http_auth.open("GET", "https://api.etomin.com/API/v1.0/kount/auth", true);
http_charge.open("POST", "https://api.etomin.com/API/v1.0/payment",true);

var params = {
    "public_key": "PB_key_tst_",
    "transaction": {
                            "payer": {
                                    "email": "test@test.com"
                            },
            "order": {
                    "external_reference": "reference-0001-res"
            },
            "payment": {
                    "amount": 100,
                    "payment_method": "SPEI",
                    "currency": "MXN",
                    "payment_country": "MEX",
                    "limit_date_payment": "10-04-2017"
            },
            "payment_pending": false,
            "device_session_id": "",
    },
    "test": true
}

http_auth.onreadystatechange = function() {
    if (this.readyState == 4 && this.status == 200) {
         var result = JSON.parse(this.responseText);
         params.transaction.device_session_id = result.session_id; // se agrega el session id
         http_charge.send(JSON.stringify(params)); // se generara el pago
    }
};

http_charge.onreadystatechange = function() {
    if (this.readyState == 4 &&  this.status == 201) {
         console.log(this.responseText);
    }
};

http_auth.send(); //se manda a obtener el session id


// Respuesta de pago con SPEI

{
    "status": "PENDING",
    "transaction": "11978",
    "authorization_code": 0,
    "payment_method": "SPEI",
    "code": 201,
    "deposit_account": "646180122420000046",
    "error": "0",
    "order": "13012"
}

#generando pago con SPEI

import requests
import json

headers = {'content-type': 'application/json'}
url = 'https://api.etomin.com/API/v1.0/kount/auth'
url_charge = 'https://api.etomin.com/API/v1.0/payment'

params = {
    "public_key": "PB_key_tst_d861621e313dc98dad0a2f0678a2d36f",
    "transaction": {
                            "payer": {
                                    "email": "test@test.com"
                            },
            "order": {
                    "external_reference": "reference-0001-res-1"
            },
                        "payment": {
                                "amount": 100,
                                "payment_method": "SPEI",
                                "currency": "MXN",
                                "payment_country": "MEX",
                                "limit_date_payment": "10-04-2017"
                        },
            "payment_pending": False,
            "device_session_id": ""
    },
    "test": True
}

auth = requests.get(url);
if auth.status_code == 200:
    obj = json.loads(auth.text)
    params["transaction"]["device_session_id"] = obj["session_id"]
    charge = requests.post(url_charge, params={}, data=json.dumps(params), headers=headers)
    obj_charge = json.loads(charge.text)
    print obj_charge


#Respuesta de pago con SPEI

{
    "status": "PENDING",
    "transaction": "11978",
    "authorization_code": 0,
    "payment_method": "SPEI",
    "code": 201,
    "deposit_account": "646180122420000046",
    "error": "0",
    "order": "13012"
}
#generando pago con SPEI

require 'net/http'
require 'json'

uri = URI('https://api.etomin.com/API/v1.0/kount/auth')
uri_charge = URI.parse('https://api.etomin.com/API/v1.0/payment')
res = Net::HTTP.get_response(uri)


params = {
    :public_key => "PB_key_tst_d861621e313dc98dad0a2f0678a2d36f",
    :transaction => {
                            :payer => {
                                    :email => "test@test.com"
                            },
            :order=> {
                    :external_reference=> "reference-0004-res"
            },
            :payment => {
                    :amount => 100,
                    :payment_method =>"SPEI",
                    :currency =>"MXN",
                    :payment_country =>"MEX",
                    :limit_date_payment =>"10-04-2017",
            },
            :payment_pending => false,
            :device_session_id => ""
    },
    :test => true
}

if res.code == "200"
  result_auth = JSON.parse(res.body);
  params[:transaction][:device_session_id] = result_auth["session_id"]
  http = Net::HTTP.new(uri_charge.host, uri_charge.port)
  http.use_ssl = true
  header = {'Content-Type'=> 'text/json'}
  request = Net::HTTP::Post.new(uri_charge.request_uri, header)
  request.body = params.to_json
    # Send the request
   response = http.request(request)
   puts response.read_body;
end


#Respuesta de pago con SPEI

{
    "status": "PENDING",
    "transaction": "11978",
    "authorization_code": 0,
    "payment_method": "SPEI",
    "code": 201,
    "deposit_account": "646180122420000046",
    "error": "0",
    "order": "13012"
}

Cuando mandas desde tu sistema la información, la API genera una referencia de pago para que la envíes a tu cliente. Una vez que el pago es confirmado por la institución bancaria, se generará una notificación en Etomin y el estado del pago cambiará de Pendiente a Aprobado.

En la función “payment” deberás enviar la información que se muestra:

REQUEST

Parámetros Descripción
public_key string (requerido)
Llave pública que se encuentra en la cuenta del seller
transaction array (requerido)
Contiene parámetros para realizar la transacción
payer array (requerido)
Contiene parámetros para realizar un pago
email string (requerido)
Email del cliente que realizará el pago
order array (requerido)
Contiene parámetros acerca de la orden
external_reference string (requerido)
Referencia para identificar el pago
payment array (requerido)
Contiene información sobre el pago
amount number (requerido)
Cantidad que se va a pagar
payment_method string (requerido)
Método con el que se realizará el pago.
currency string (requerido)
Tipo de moneda con la que se va a realizar el pago. Solo se cuenta con MXN
payment_country string (requerido)
País donde se realiza el pago. Puede ser México, Colombia y Estados Unidos
limit_date_payment date (requerido)
Fecha límite para realizar el pago
payment_pending float (requerido)
Se refiere si el pago se mostrará como pendiente
device_session_id string (requerido)
Es un número único que Etomin asigna al usuario para la duración de la visita
test float (requerido)
Se refiere que si el pago será en modo test o live

Depósitos en efectivo en comercios (OXXO)

GENERAR PAGO: [POST] https://api.etomin.com/API/v1.0/payment

    curl -H "Content-Type: application/json" -X POST -d file.json https://api.etomin.com/API/v1.0/payment

    JSON simple para generar pagos con referencia "OXXO"  :

    {
        "public_key": "public_key",
        "transaction": {
                    "payer": {
                        "email": "test@test.com"
                    },
            "order": {
                "external_reference": "reference-0003"
            },
            "payment": {
                "amount": 100,
                "payment_method": "OXXO",
                "currency": "MXN",
                "payment_country": "MEX",
                "limit_date_payment": "10-04-2017"
            },
            "payment_pending": false,
            "device_session_id": "149073421142142231269182",
        },
        "test": true
    }


#Respuesta de pago con OXXO

{
    "status": "PENDING",
    "transaction": "11979",
    "authorization_code": 0,
    "payment_method": "OXXO",
    "urlPrint": "https://seller.etomin.com/voucher.html#/order/print/13013",
    "order_deposit_id": "8800000130130210420170000100007",
    "code": 201,
    "error": "0",
    "order": "13013"
}

//generando pago con OXXO

var http_auth = new XMLHttpRequest();
var http_charge = new XMLHttpRequest();

http_auth.open("GET", "https://api.etomin.com/API/v1.0/kount/auth", true);
http_charge.open("POST", "https://api.etomin.com/API/v1.0/payment",true);

var params = {
    "public_key": "PB_key_tst_",
    "transaction": {
                            "payer": {
                                    "email": "test@test.com"
                            },
            "order": {
                    "external_reference": "reference-0001-res"
            },
            "payment": {
                    "amount": 100,
                    "payment_method": "OXXO",
                    "currency": "MXN",
                    "payment_country": "MEX",
                    "limit_date_payment": "10-04-2017"
            },
            "payment_pending": false,
            "device_session_id": "",
    },
    "test": true
}

http_auth.onreadystatechange = function() {
    if (this.readyState == 4 && this.status == 200) {
         var result = JSON.parse(this.responseText);
         params.transaction.device_session_id = result.session_id; // se agrega el session id
         http_charge.send(JSON.stringify(params)); // se generara el pago
    }
};

http_charge.onreadystatechange = function() {
    if (this.readyState == 4 &&  this.status == 201) {
         console.log(this.responseText);
    }
};

http_auth.send(); //se manda a obtener el session id


//Respuesta de pago con OXXO

{
    "status": "PENDING",
    "transaction": "11979",
    "authorization_code": 0,
    "payment_method": "OXXO",
    "urlPrint": "https://seller.etomin.com/voucher.html#/order/print/13013",
    "order_deposit_id": "8800000130130210420170000100007",
    "code": 201,
    "error": "0",
    "order": "13013"
}

#generando pago con OXXO

import requests
import json

headers = {'content-type': 'application/json'}
url = 'https://api.etomin.com/API/v1.0/kount/auth'
url_charge = 'https://api.etomin.com/API/v1.0/payment'

params = {
    "public_key": "PB_key_tst_d861621e313dc98dad0a2f0678a2d36f",
    "transaction": {
                            "payer": {
                                    "email": "test@test.com"
                            },
            "order": {
                    "external_reference": "reference-0001-res-1"
            },
                        "payment": {
                                "amount": 100,
                                "payment_method": "OXXO",
                                "currency": "MXN",
                                "payment_country": "MEX",
                                "limit_date_payment": "10-04-2017"
                        },
            "payment_pending": False,
            "device_session_id": ""
    },
    "test": True
}

auth = requests.get(url);
if auth.status_code == 200:
    obj = json.loads(auth.text)
    params["transaction"]["device_session_id"] = obj["session_id"]
    charge = requests.post(url_charge, params={}, data=json.dumps(params), headers=headers)
    obj_charge = json.loads(charge.text)
    print obj_charge


#Respuesta de pago con OXXO

{
    "status": "PENDING",
    "transaction": "11979",
    "authorization_code": 0,
    "payment_method": "OXXO",
    "urlPrint": "https://seller.etomin.com/voucher.html#/order/print/13013",
    "order_deposit_id": "8800000130130210420170000100007",
    "code": 201,
    "error": "0",
    "order": "13013"
}
#generando pago con OXXO

require 'net/http'
require 'json'

uri = URI('https://api.etomin.com/API/v1.0/kount/auth')
uri_charge = URI.parse('https://api.etomin.com/API/v1.0/payment')
res = Net::HTTP.get_response(uri)


params = {
    :public_key => "PB_key_tst_d861621e313dc98dad0a2f0678a2d36f",
    :transaction => {
                            :payer => {
                                    :email => "test@test.com"
                            },
            :order=> {
                    :external_reference=> "reference-0004-res"
            },
            :payment => {
                    :amount => 100,
                    :payment_method =>"OXXO",
                    :currency =>"MXN",
                    :payment_country =>"MEX",
                    :limit_date_payment =>"10-04-2017",
            },
            :payment_pending => false,
            :device_session_id => ""
    },
    :test => true
}

if res.code == "200"
  result_auth = JSON.parse(res.body);
  params[:transaction][:device_session_id] = result_auth["session_id"]
  http = Net::HTTP.new(uri_charge.host, uri_charge.port)
  http.use_ssl = true
  header = {'Content-Type'=> 'text/json'}
  request = Net::HTTP::Post.new(uri_charge.request_uri, header)
  request.body = params.to_json
    # Send the request
   response = http.request(request)
   puts response.read_body;
end


#Respuesta de pago con OXXO

{
    "status": "PENDING",
    "transaction": "11979",
    "authorization_code": 0,
    "payment_method": "OXXO",
    "urlPrint": "https://seller.etomin.com/voucher.html#/order/print/13013",
    "order_deposit_id": "8800000130130210420170000100007",
    "code": 201,
    "error": "0",
    "order": "13013"
}

Cuando mandas desde tu sistema la información, la API genera una ficha de pago para que la envíes a tu cliente. Una vez que el pago es confirmado por el comercio y se confirma, Etomin emitirá una notificación y el estado del pago cambiará de Pendiente a Aprobado.

En la función “payment” deberás enviar la información que se muestra:

REQUEST


Parámetros Descripción
public_key string (requerido)
Llave pública que se encuentra en la cuenta del seller
transaction array (requerido)
Contiene parámetros para realizar la transacción
payer array (requerido)
Contiene parámetros para realizar un pago
email string (requerido)
Email del cliente que realizará el pago
order array (requerido)
Contiene parámetros acerca de la orden
external_reference string (requerido)
Referencia para identificar el pago
payment array (requerido)
Contiene información sobre el pago
amount number (requerido)
Cantidad que se va a pagar
payment_method string (requerido)
Método con el que se realizará el pago.
currency string (requerido)
Tipo de moneda con la que se va a realizar el pago. Solo se cuenta con MXN
payment_country string (requerido)
País donde se realiza el pago. Puede ser México, Colombia y Estados Unidos
limit_date_payment date (requerido)
Fecha límite para realizar el pago
payment_pending float (requerido)
Se refiere si el pago se mostrará como pendiente
device_session_id string (requerido)
Es un número único que Etomin asigna al usuario para la duración de la visita
test float (requerido)
Se refiere que si el pago será en modo test o live

Botón de Pago

Optimiza tus ventas y ofrece a tus clientes mas opciones de pago.

Nuestro botón de pago te permite generar de forma segura cobros a tus clientes pasando directamente la información a los servidores de etomin.

Generar un botón de pago en etomin es muy sencillo y bastante amigable de implementar en tu sitio web, para generarlo es necesario que ingreses al detalle del producto que deseas promover, y dentro del detalle del producto en la sección “Botones de Pago” puedes dar de alta esta funcionalidad.

Para generar el botón de pago es necesario la siguiente información:

Una vez generado tu botón de pago en la opción podrás obtener el código necesario para insertar el botón en tu pagina web.

Esta ventana te devolverá el código que deberás insertar dentro de la etiqueta <head> de tu pagina web y el html del botón para que puedas implementarlo al html de tu pagina web.

Devolución

TOTALES/PARCIALES: [POST] https://api.etomin.com/API/v1.0/payment/refund

    curl -H "Content-Type: application/json" -X POST -d file.json https://api.etomin.com/API/v1.0/payment/refund

    JSON para generar devolución total  :

    {
        "public_key": "public_key",
        "mode": true,
        "payment_id": "12078",
        "external_reference": "reference-0001"
    }

    JSON para generar devolución parcial :

    {
        "public_key": "public_key",
        "mode": true,
        "payment_id": "12078",
        "external_reference": "reference-0001",
        "amount": 50
    }


#Respuesta de devolución de pago

{
    "message": "Ok",
    "code": 201,
    "detail": {
                "status": "PENDING",
                "payment_id": 13010,
                "payment_transaction_id": 11976,
                "terminal_id': 3, 'seller_id": 1,
                "created_date": "2017-04-19T00:00:00.000Z",
                "return_date": "2017-04-19T05:00:00.000Z",
                "reconcilation_id": 0,
                "hold_rate_amount": 0,
                "amount": 100,
                "consolidate_id": 0,
                "mode": 0,
                "payer_id": 1489,
                "updatedAt": "2017-04-19T17:42:40.564Z",
                "id": 392,
                "createdAt": "2017-04-19T17:42:40.564Z"
            },
    "error": 0
}

//generando devolución

var http_refund = new XMLHttpRequest();
http_refund.open("POST", "https://api.etomin.com/API/v1.0/payment/refund",true);

var params = {
        "public_key": "PB_key_tst_",
        "mode": true,
        "payment_id": "12078",
        "external_reference": "reference-0002"
}

/*
    Nota: para generar una devolución parcial se agrega el amount a params y se pone el monto a devolver,
    no debe ser mayor al cargo generado
*/

http_refund.onreadystatechange = function() {
    if (this.readyState == 4 && this.status == 200) {
         console.log(this.responseText);
    }
};

http_refund.send(JSON.stringify(params));


//Respuesta de devolución de pago

{
    "message": "Ok",
    "code": 201,
    "detail": {
                "status": "PENDING",
                "payment_id": 13010,
                "payment_transaction_id": 11976,
                "terminal_id': 3, 'seller_id": 1,
                "created_date": "2017-04-19T00:00:00.000Z",
                "return_date": "2017-04-19T05:00:00.000Z",
                "reconcilation_id": 0,
                "hold_rate_amount": 0,
                "amount": 100,
                "consolidate_id": 0,
                "mode": 0,
                "payer_id": 1489,
                "updatedAt": "2017-04-19T17:42:40.564Z",
                "id": 392,
                "createdAt": "2017-04-19T17:42:40.564Z"
            },
    "error": 0
}

#generando devolución

import requests
import json

headers = {'content-type': 'application/json'}
url_refund = 'https://api.etomin.com/API/v1.0/payment/refund'

params = {
        "public_key": "PB_key_tst_",
        "mode": True,
        "payment_id": "12078",
        "external_reference": "reference-0002"
}

refund = requests.post(url_refund, params={}, data=json.dumps(params), headers=headers)
obj_refund = json.loads(refund.text)
print obj_refund


#Respuesta de devolución de pago

{
    "message": "Ok",
    "code": 201,
    "detail": {
                "status": "PENDING",
                "payment_id": 13010,
                "payment_transaction_id": 11976,
                "terminal_id': 3, 'seller_id": 1,
                "created_date": "2017-04-19T00:00:00.000Z",
                "return_date": "2017-04-19T05:00:00.000Z",
                "reconcilation_id": 0,
                "hold_rate_amount": 0,
                "amount": 100,
                "consolidate_id": 0,
                "mode": 0,
                "payer_id": 1489,
                "updatedAt": "2017-04-19T17:42:40.564Z",
                "id": 392,
                "createdAt": "2017-04-19T17:42:40.564Z"
            },
    "error": 0
}
require 'net/http'
require 'json'

uri_refund = URI.parse('https://api.etomin.com/API/v1.0/payment')

params = {
    :public_key => "PB_key_tst_",
    :mode => true,
    :payment_id => "12078",
    :external_reference => "reference-0002"
}

http = Net::HTTP.new(uri_refund.host, uri_refund.port)
http.use_ssl = true
header = {'Content-Type'=> 'text/json'}
request = Net::HTTP::Post.new(uri_refund.request_uri, header)
request.body = params.to_json
response = http.request(request)
puts response.read_body;


#Respuesta de devolución de pago

{
    "message": "Ok",
    "code": 201,
    "detail": {
                "status": "PENDING",
                "payment_id": 13010,
                "payment_transaction_id": 11976,
                "terminal_id': 3, 'seller_id": 1,
                "created_date": "2017-04-19T00:00:00.000Z",
                "return_date": "2017-04-19T05:00:00.000Z",
                "reconcilation_id": 0,
                "hold_rate_amount": 0,
                "amount": 100,
                "consolidate_id": 0,
                "mode": 0,
                "payer_id": 1489,
                "updatedAt": "2017-04-19T17:42:40.564Z",
                "id": 392,
                "createdAt": "2017-04-19T17:42:40.564Z"
            },
    "error": 0
}

Esta función permite devolver parcial o totalmente un pago realizado con tarjeta de crédito o débito exclusivamente. Para ello debes enviar a la API el identificador del pago original.

REQUEST

Parámetros Descripción
public_key string (requerido)
Llave pública que se encuentra en la cuenta del seller
mode float (requerido)
Se refiere si la devolución se hará en modo test o live
payment_id string (requerido)
Id del pago al que se le hará devolución
external_reference string (requerido)
Referencia del pago al que se le hará la devolución. La referencia debe ser la misma
amount number (requerido)
Se agrega este parámetro sólo cuando se haga una devolución parcial

Suscripción

GENERAR PAGO/SUSCRIPTOR: [POST] https://api.etomin.com/API/v1.0/payment

    curl -H "Content-Type: application/json" -X POST -d file.json https://api.etomin.com/API/v1.0/payment

    JSON simple para generar pagos con tarjetas "VISA/MASTERCARD" :

{
        "public_key": "public_key",
        "transaction": {
                "payer": {
                    "email": "test@test.com"
                },
                "order": {
                        "external_reference": "reference-0001"
                },
                "payment": {
                        "amount": 100,
                        "payment_method": "VISA",
                        "currency": "MXN",
                        "payment_country": "MEX",
                        "number": "4111111111111111",
                        "securityCode": "123",
                        "expirationDate": "03/18",
                        "name": "Luis Cruz",
                },
                "extraParameters": {
                    "plan": 4 #para agregar suscriptor al plan 4
                },
                "payment_pending": false,
                "device_session_id": "149073421142142231262335",
        },
        "test": true
}


#Respuesta de pago/suscriptor

{
    "status": "APPROVED",
    "transaction": "11993",
    "authorization_code": "516369D",
    "payment_method": "VISA",
    "payment_token": "809dd85d4f289854232856f155beb20a",
    "code": 201,
    "error": "0",
    "message": "Approved+by+Payworks+%28test+mode%29",
    "credit_card": "************1111",
    "order": "13027"
}

//generando pago y suscriptor

var http_auth = new XMLHttpRequest();
var http_charge = new XMLHttpRequest();

http_auth.open("GET", "https://api.etomin.com/API/v1.0/kount/auth", true);
http_charge.open("POST", "https://api.etomin.com/API/v1.0/payment",true);

var params = {
    "public_key": "PB_key_tst_",
    "transaction": {
                            "payer": {
                                    "email": "test@test.com"
                            },
            "order": {
                    "external_reference": "reference-0001-res"
            },
            "payment": {
                    "amount": 100,
                    "payment_method": "VISA",
                    "currency": "MXN",
                    "payment_country": "MEX",
                    "number": "4111111111111111",
                    "securityCode": "123",
                    "expirationDate": "03/18",
                    "name": "Luis Cruz",
            },
            "extraParameters": {
                "plan": 4 //para agregar suscriptor al plan 4
            },
            "payment_pending": false,
            "device_session_id": "",
    },
    "test": true
}

http_auth.onreadystatechange = function() {
    if (this.readyState == 4 && this.status == 200) {
         var result = JSON.parse(this.responseText);
         params.transaction.device_session_id = result.session_id; // se agrega el session id
         http_charge.send(JSON.stringify(params)); // se manda a generar el pago
    }
};

http_charge.onreadystatechange = function() {
    if (this.readyState == 4 &&  this.status == 201) {
         console.log(this.responseText);
    }
};

http_auth.send();


//Respuesta de pago/suscriptor

{
    "status": "APPROVED",
    "transaction": "11993",
    "authorization_code": "516369D",
    "payment_method": "VISA",
    "payment_token": "809dd85d4f289854232856f155beb20a",
    "code": 201,
    "error": "0",
    "message": "Approved+by+Payworks+%28test+mode%29",
    "credit_card": "************1111",
    "order": "13027"
}

#generando pago y suscriptor

import requests
import json

headers = {'content-type': 'application/json'}
url = 'https://api.etomin.com/API/v1.0/kount/auth'
url_charge = 'https://api.etomin.com/API/v1.0/payment'

data = {}
params = {
        "public_key": "PB_key_tst_d861621e313dc98dad0a2f0678a2d36f",
        "transaction": {
                                                        "payer": {
                                                                        "email": "test@test.com"
                                                        },
                        "order": {
                                        "external_reference": "reference-0001-res-1"
                        },
                        "payment": {
                                        "amount": 100,
                                        "payment_method": "VISA",
                                        "currency": "MXN",
                                        "payment_country": "MEX",
                                        "number": "4111111111111111",
                                        "securityCode": "123",
                                        "expirationDate": "03/18",
                                        "name": "Luis Cruz"
                        },
                        "extraParameters": {
                            "plan": 4 #para agregar suscriptor al plan 4
                        },
                        "payment_pending": False,
                        "device_session_id": ""
        },
        "test": True
}

auth = requests.get(url);
if auth.status_code == 200:
        obj = json.loads(auth.text)
        params["transaction"]["device_session_id"] = obj["session_id"]
        charge = requests.post(url_charge, params={}, data=json.dumps(params), headers=headers)
        obj_charge = json.loads(charge.text)
        print obj_charge


#Respuesta de pago/suscriptor

{
    "status": "APPROVED",
    "transaction": "11993",
    "authorization_code": "516369D",
    "payment_method": "VISA",
    "payment_token": "809dd85d4f289854232856f155beb20a",
    "code": 201,
    "error": "0",
    "message": "Approved+by+Payworks+%28test+mode%29",
    "credit_card": "************1111",
    "order": "13027"
}
require 'net/http'
require 'json'

uri = URI('https://api.etomin.com/API/v1.0/kount/auth')
uri_charge = URI.parse('https://api.etomin.com/API/v1.0/payment')
res = Net::HTTP.get_response(uri)

params = {
    :public_key => "PB_key_tst_d861621e313dc98dad0a2f0678a2d36f",
    :transaction => {
                            :payer => {
                                    :email => "test@test.com"
                            },
            :order=> {
                    :external_reference=> "reference-0004-res"
            },
                        :payment => {
                    :amount => 100,
                    :payment_method =>"VISA",
                    :currency =>"MXN",
                    :payment_country =>"MEX",
                    :number =>"4111111111111111",
                    :securityCode =>"123",
                    :expirationDate =>"03/18",
                    :name =>"Luis Cruz",
            },
                        :extraParameters => {
                            :plan => 4 #para agregar suscriptor al plan 4
                        },
            :payment_pending => false,
            :device_session_id => ""
    },
    :test => true
}

if res.code == "200"
  result_auth = JSON.parse(res.body);
  params[:transaction][:device_session_id] = result_auth["session_id"]
  http = Net::HTTP.new(uri_charge.host, uri_charge.port)
  http.use_ssl = true
  header = {'Content-Type'=> 'text/json'}
  request = Net::HTTP::Post.new(uri_charge.request_uri, header)
  request.body = params.to_json
    # Send the request
   response = http.request(request)
   puts response.read_body;
end


#Respuesta de pago/suscriptor

{
    "status": "APPROVED",
    "transaction": "11993",
    "authorization_code": "516369D",
    "payment_method": "VISA",
    "payment_token": "809dd85d4f289854232856f155beb20a",
    "code": 201,
    "error": "0",
    "message": "Approved+by+Payworks+%28test+mode%29",
    "credit_card": "************1111",
    "order": "13027"
}

Etomin también cuenta con un sistema integrado de planes de suscripción, es decir que serás capaz de crear cargos recurrentes a tus clientes con tarjeta de crédito o débito. La API aplicará periódicamente el cargo por el monto especificado en el plan por tiempo indefinido, es decir que al terminar el plazo convenido, deberás enviar desde tu sistema la instrucción para cancelar al suscriptor

REQUEST


Parámetros Descripción
public_key string (requerido)
Llave pública que se encuentra en la cuenta del seller
transaction array (requerido)
Contiene parámetros para realizar la transacción
payer array (requerido)
Contiene información sobre el cliente
email string (requerido)
Email del cliente que realiza el pago
order array (requerido)
Contiene parámetros sobre la orden
external_reference string (requerido)
Referencia para identificar el pago
payment array (requerido)
Contiene parámetros sobre la información del pago
amount number (requerido)
Cantidad que se va a pagar
payment_method string (requerido)
Tipo de tarjeta que se va a utilizar. Las opciones son Visa y Master Card
currency string (requerido)
Tipo de moneda con que se realiza el pago. Solo se cuenta con MXN
payment_country string (requerido)
País donde se realiza el pago. Las opciones son México, Colombia y Estados Unidos
number string (requerido)
Número de la tarjeta con la que se realiza el pago
securityCode string (requerido)
Código de seguridad de la tarjeta con la que se realiza el pago
expirationDate date (requerido)
Fecha de expiración de la tarjeta con la que se realiza el pago
name string (requerido)
Nombre del tarjetahabiente
extraParameters array (requerido)
Contiene parámetros extra para el pago, en esta ocación sera el plan al que se va a suscribir
plan number (requerido)
id del plan al que se va a suscribir
payment_pending float (requerido)
Se refiere si el pago se mostrará como pendiente
device_session_id string (requerido)
Es un número único que Etomin asigna al usuario para la duración de la visita
test float (requerido)
Se refiere que si el pago será en modo test o live

Datos ISO

Algunos de los parámetros en la API sólo aceptan ciertos valores. En esta sección encontrarás las opciones aplicables:

País

Especifica el país de origen de la transacción.

País Código
México MEX
Estados Unidos USA

Moneda

Especifica el tipo de moneda de la transacción.

Moneda Código
Peso Mexicano MXN
Dolar americano USD

Métodos de pago

Especifica qué método de pago se utilizará.

Tipo de tarjeta Código
Visa VISA
Master Card MASTERCARD
American Express AMEX
Oxxo OXXO

Errores de pago

Error Code Meaning
00 Aprobado
01 Remisión / Emisor de llamada
02 Consulte al emisor: concesión especial
03 Operador no válido
04 Decomisar tarjeta
05 Declinado
06 Error
07 Reservado
08 Aprobada con ID positivo
09 Ninguna desición tomada (no se puede echar atrás la transacción)
11 Aprobado
12 Transacción inválida
13 Monto invalido
14 Cuenta inválida
15 Emison invalido
30 Error del sistema
31 Error del sistema
33 Tarjeta expirada
34 Decomisar tarjeta: condición especial
35 Decomisar tarjeta: condición especial
36 Error
37 Decomisar tarjeta: condición especial
38 El número de intentos para ingresar el PIN fue excedido
39 Sin fondos
41 Tarjeta extraviada
43 Decomisar tarjeta (tarjeta robada)
51 Fondos insuficientes
54 Tarjeta expirada
55 PIN incorrecto
56 No se puede localizar en el archivo de registro o la cuenta no se encuentra
57 Transacción no permitida para el titular de la tarjeta
58 Transacción no permitida para el titular de la tarjeta
59 Código de autorización requerido CVV2 / CVC2 no se proporciono
61 El monto del retiro excede el limite permitido de esta actividad
62 Tarjeta restringida
65 Se supero el limite de actividad permitido
68 Error del sitema
75 El número de intentos para ingresar el PIN fue excedido
82 Violación de seguridad
90 Host no disponible
92 Rechazada / Sin respuesta / No existe el HOST / categoría inválida
94 Ninguna desición tomada (no se puede echar atrás la transacción)
58 No existe registro
1001 Declinado por motor antifraude
1002 El monto de la operación supera el límite permitido.
1003 El monto diario permitido fue superado
1004 Las operaciones diarias permitidas del seller fueron superada.
1005 El límite de las operaciones diarias del cliente fue superado.
1006 No se agregó el registro.
1007 No se pudo buscar el registro.
1008 El registro no existe.
9000 Pendiente de pago
9001 La transacción ya fue rechazada el #date a las #hour hrs.