Nuestros componentes visuales en tu checkout

¿Usas Gradle? Agrégala en el build.gradle del módulo donde nos integres.

Sino descarga el SDK de Mercado Pago.

                        dependencies {
   compile 'com.mercadopago:sdk:'
}
                        
                        
                           
                        
                     

UI para la recolección de datos

El más completo de nuestros componentes visuales es PaymentVault con el cual estarás en condiciones de enviar los datos a tu servidor. Con este componente tendrás a disposición el medio de pago seleccionado (PaymentMethod) y si tu usuario paga con tarjeta, el banco (Issuer), las cuotas (PayerCost) y la información de la tarjeta encriptada (Token).
Para utilizarlo, agrega un botón:

Luego, cuando el botón es presionado, por medio de nuestra SDK invoca a PaymentVault y espera el resultado para conocer los datos que seleccionó el usuario dentro del flujo.

                        
public void onPaymentVaultButtonClicked(View view) {
  new MercadoPago.StartActivityBuilder()
    .setActivity(this)
    .setPublicKey(TU_PUBLIC_KEY)
    .setAmount(MONTO_A_COBRAR)
    .setSite(Sites.ARGENTINA)
    .startPaymentVaultActivity();
}

// Espera los resultados
@Override
protected void onActivityResult(int requestCode, int resultCode,
Intent data) {
  if(requestCode == MercadoPago.PAYMENT_VAULT_REQUEST_CODE) {
    if(resultCode == RESULT_OK) {
      PaymentMethod paymentMethod = JsonUtil.getInstance().fromJson(data.getStringExtra("paymentMethod"), PaymentMethod.class);
      Issuer issuer = JsonUtil.getInstance().fromJson(data.getStringExtra("issuer"), Issuer.class);
      Token token = JsonUtil.getInstance().fromJson(data.getStringExtra("token"), Token.class);
      PayerCost payerCost = JsonUtil.getInstance().fromJson(data.getStringExtra("payerCost"), PayerCost.class);

      createPayment(paymentMethod, issuer, payerCost, token);
    } else {
      if ((data != null) && (data.hasExtra("mpException"))) {
        MPException exception = JsonUtil.getInstance()
          .fromJson(data.getStringExtra("mpException"), MPException.class);
      }
    }
  }
}
                        
                        
                           
                        
                     

Cobra con tarjeta

Para recolectar sólamente los datos de la tarjeta de tu usuario te brindamos un componente que resuelve esta necesidad de una forma intuitiva y segura. Sólo tienes que invocar el formulario de tarjeta y esperar el resultado: PaymentMethod (marca de la tarjeta), Issuer (banco de la tarjeta) y Token (información encriptada de la tarjeta).
Sigue navegando si quieres ver cómo cobrar en cuotas.

                        
public void onCardStartButtonClicked(View view) {
  new MercadoPago.StartActivityBuilder()
    .setActivity(this)
    .setPublicKey(TU_PUBLIC_KEY)
    .startCardVaultActivity();
}

@Override
protected void onActivityResult(int requestCode, int resultCode,
Intent data) {

  if(requestCode == MercadoPago.CARD_VAULT_REQUEST_CODE) {
    if(resultCode == RESULT_OK) {
      PaymentMethod paymentMethod = JsonUtil.getInstance().fromJson(data.getStringExtra("paymentMethod"), PaymentMethod.class);
      Issuer issuer = JsonUtil.getInstance().fromJson(data.getStringExtra("issuer"), Issuer.class);
      Token token = JsonUtil.getInstance().fromJson(data.getStringExtra("token"), Token.class);

      // Listo! Envía los datos a tu servidor!

    } else {
      if ((data != null) && (data.hasExtra("mpException"))) {
        MPException exception = JsonUtil.getInstance()
          .fromJson(data.getStringExtra("mpException"), MPException.class);
      }
    }
  }
}
                        
                        
                           
                        
                     

¿Cómo adivinamos la marca de la tarjeta?
Dado el BIN de la tarjeta (6 primeros dígitos), podemos determinar el medio de pago (Visa, Mastercard, Amex, etc) y mediante expresiones regulares, muchas veces podemos determinar el banco. En los casos en que no podemos determinar el banco que emitió la tarjeta, le pedimos a tu usuario que lo elija.

Cobra con tarjeta en cuotas

Si deseas cobrar en cuotas, ofrecemos un flujo que se encarga de la recolección de datos de la tarjeta y además, de la selección de cuotas. A los parámetros de respuesta del paso anterior también debes esperar por el PayerCost (las cuotas seleccionadas por el usuario).

                        
public void onStartCardWithInstallmentsButtonClicked(View view) {

  new MercadoPago.StartActivityBuilder()
    .setActivity(this)
    .setPublicKey(TU_PUBLIC_KEY)
    .setAmount(MONTO_A_COBRAR)
    .setSite(Sites.ARGENTINA)
    .setInstallmentsEnabled(true)
    .startCardVaultActivity();
}

@Override
protected void onActivityResult(int requestCode, int resultCode,
Intent data) {

  if(requestCode == MercadoPago.CARD_VAULT_REQUEST_CODE) {
      if(resultCode == RESULT_OK) {
          PaymentMethod paymentMethod = JsonUtil.getInstance().fromJson(data.getStringExtra("paymentMethod"), PaymentMethod.class);
          Issuer issuer = JsonUtil.getInstance().fromJson(data.getStringExtra("issuer"), Issuer.class);
          Token token = JsonUtil.getInstance().fromJson(data.getStringExtra("token"), Token.class);
          PayerCost payerCost = JsonUtil.getInstance().fromJson(data.getStringExtra("payerCost"), PayerCost.class);

          // Listo! Envía los datos a tu servidor!
      } else {
        if ((data != null) && (data.hasExtra("mpException"))) {
          MPException exception = JsonUtil.getInstance()
            .fromJson(data.getStringExtra("mpException"), MPException.class);
        }
      }
  }
}
                        
                        
                           
                        
                     

Tarjetas guardadas del cliente

Puedes darle la opción a tu cliente de pagar con sus tarjetas guardadas. Para esto, puedes utilizar el componente de selección completa y además de los datos mencionados especificar tu URL, la URI del recurso de tu servidor a la cual solicitarle un Customer, y un "merchantAccessToken", con el cual debes poder identificar a tu usuario en tu servidor para así obtener el Customer correspondiente para realizar el pago.
Para realizar pagos con tarjetas guardadas en tu servidor, mira la documentación.
Ejemplo:

                     
public void onPaymentVaultButtonClicked(View view) {
new MercadoPago.StartActivityBuilder()
 .setActivity(this)
 .setMerchantBaseUrl("https://api.tunombre.com")
 .setMerchantGetCustomerUri("/getCustomer")
 .setMerchantAccessToken("USER_IDENTIFICATION")
 .setPublicKey(TU_PUBLIC_KEY)
 .setAmount(MONTO_A_COBRAR)
 .setSite(Sites.ARGENTINA)
 .startPaymentVaultActivity();
}

                     
                     
                        
                     
                  

Medios de pago

Es la entidad participante del pago en sí misma. Desde la marca de la tarjeta, pasando por la entidad de cobro en efectivo hasta el lugar dónde se encuentra el cajero automático para que el usuario realice el pago.
Si el medio de pago pertenece a una tarjeta te brindamos la información necesaria para armar tu formulario de tarjeta y sus validaciones, por ejemplo la longitud del número de tarjeta, si el código de seguridad está al frente o al dorso de la tarjeta, su longitud, entre otros. Pero también, el medio de pago puede ser offline. En este caso te indicamos, entre otros, el tiempo de acreditación ya que el pago quedará en un estado pendiente que cambiará cuando el usuario se acerque a la entidad correspondiente a finalizar el pago en efectivo.

                        
public void onPaymentMethodsButtonClicked(View view) {
  new MercadoPago.StartActivityBuilder()
    .setActivity(this)
    .setPublicKey(TU_PUBLIC_KEY)
    .startPaymentMethodsActivity();
}

@Override
protected void onActivityResult(int requestCode, int resultCode,
Intent data) {

    if(requestCode == MercadoPago.PAYMENT_METHODS_REQUEST_CODE) {
        if(resultCode == RESULT_OK) {
            PaymentMethod paymentMethod = JsonUtil.getInstance().fromJson(data.getStringExtra("paymentMethod"), PaymentMethod.class);
            // Ahora puedes continuar con tu flujo.
            // Recuerda verificar si el medio de pago es offline!
        } else {
          if ((data != null) && (data.hasExtra("mpException"))) {
            MPException exception = JsonUtil.getInstance()
              .fromJson(data.getStringExtra("mpException"), MPException.class);
          }
        }
    }
}
                        
                        
                           
                        
                     

Bancos

El banco es la entidad que emite la tarjeta. Como procesadores de pagos establecemos promociones con los distintos bancos para que tus usuarios puedan tener mayor flexibilidad a la hora de comprar. La marca de la tarjeta de tu usuario puede ser emitida por más de un banco. Para ofrecerle las promociones correctas, necesitamos que nos indique el banco que emitió su tarjeta.

Por eso tenemos un componente para seleccionar bancos. Es tan sólo una pantalla en la que listamos los bancos posibles para un BIN y el medio de pago de la tarjeta.

                        
public void onIssuersButtonClicked(View view) {
  PaymentMethod paymentMethod = JsonUtil.getInstance().fromJson(data.getStringExtra("paymentMethod"), PaymentMethod.class);

  new MercadoPago.StartActivityBuilder()
    .setActivity(this)
    .setPublicKey(TU_PUBLIC_KEY)
    .setPaymentMethod(paymentMethod)
    .startIssuersActivity();
}

@Override
protected void onActivityResult(int requestCode, int resultCode,
Intent data) {

    if(requestCode == MercadoPago.ISSUERS_REQUEST_CODE) {
        if(resultCode == RESULT_OK) {
            Issuer issuer = JsonUtil.getInstance().fromJson(data.getStringExtra("issuer"), Issuer.class);
            // Ahora puedes continuar con tu flujo.
        } else {
          if ((data != null) && (data.hasExtra("mpException"))) {
            MPException exception = JsonUtil.getInstance()
              .fromJson(data.getStringExtra("mpException"), MPException.class);
          }
        }
    }
}
                        
                        
                           
                        
                     

Cuotas

Una vez que tu usuario seleccione el medio de pago y el banco que emitió su tarjeta, es importante que, para ofrecerle mayor flexibilidad al momento de pagar, le permitas seleccionar la cantidad de cuotas en la que va a realizar el pago.
Sólo indícanos qué datos seleccionó (medio de pago y banco). Te pedimos el monto, ya que nos permite obtener una descripción recomendada para indicarle a tu usuario la cantidad de cuotas, el valor de cada una y el monto final.

                        
public void startInstallmentsActivity(View view) {
  PaymentMethod paymentMethod = JsonUtil.getInstance().fromJson(data.getStringExtra("paymentMethod"), PaymentMethod.class);
  Issuer issuer = JsonUtil.getInstance().fromJson(data.getStringExtra("issuer"), Issuer.class);

  new MercadoPago.StartActivityBuilder()
    .setActivity(this)
    .setPublicKey(TU_PUBLIC_KEY)
    .setSite(Sites.ARGENTINA)
    .setAmount(MONTO_A_COBRAR)
    .setIssuer(issuer)
    .setPaymentMethod(paymentMethod)
    .startInstallmentsActivity();
}

@Override
protected void onActivityResult(int requestCode, int resultCode,
Intent data) {

    if(requestCode == MercadoPago.INSTALLMENTS_REQUEST_CODE) {
      if(resultCode == RESULT_OK) {
        PayerCost payerCost = JsonUtil.getInstance().fromJson(data.getStringExtra("payerCost"), PayerCost.class);
        // Ahora puedes continuar con tu flujo.
      } else {
          if ((data != null) && (data.hasExtra("mpException"))) {
            MPException exception = JsonUtil.getInstance()
              .fromJson(data.getStringExtra("mpException"), MPException.class);
          }
      }
    }
}
                        
                        
                           
                        
                     

Promociones

Hablamos con las marcas de las tarjetas y con los bancos para poder brindarle a tus usuarios las mejores promociones a la hora de pagar. Consideramos que es muy importante que en tu flujo de pagos le cuentes a tus usuarios las comodidades que tiene para abonar, ya que es más probable que elija un medio de pago conveniente para él y pueda concretar el pago.

                        
public void onBankDealsButtonClicked(View view) {
  new MercadoPago.StartActivityBuilder()
    .setActivity(this)
    .setPublicKey(TU_PUBLIC_KEY)
    .startBankDealsActivity();
}
                        
                        
                           
                        
                     

Creación de pago

Antes de crear el pago, te recomendamos que hagas todas las validaciones necesarias para entender si la transacción que se está llevando a cabo es lícita: puedes verificar el precio del item u objeto a comprar, validar stock si fuera necesario y si tu usuario está en condiciones para realizar la compra.
Junto con el token creado necesitas enviar también el medio de pago, cuotas y banco seleccionados por el usuario, además de un identificador del artículo o servicio que se está pagando y del usuario que está presente en tu aplicación.
En este caso, el método createPayment hace un POST y envía como cuerpo del mensaje el objeto MerchantPayment que agrupa toda la información que precisas tener en tu servidor para conectarte con el nuestro. Por eso debes indicarnos tu URL base (https://api.tunombre.com) y la uri (/create_payment) donde esperas los datos para crear el pago. MerchantServer se encargará de transformar la respuesta de tu servicio (la misma que los servicios de Mercado Pago) en un objeto Payment.

Una vez recibida la información en tus servidores, puedes crear el pago usando uno de los SDKs de MercadoPago. En este link podrás ver ejemplos de cómo utilizar nuestras SDK para realizar pagos. Los ejemplos están disponibles para PHP, cURL, ASP.NET, Java, Node.js, Phyton y Ruby.

A continuación podrás ver cómo conectar tu aplicación con tu servidor al momento de querer efectuar el cobro:

                        
import com.mercadopago.callbacks.Callback;

public void createPayment(final Activity activity, final PaymentMethod paymentMethod,
Issuer issuer, PayerCost payerCost, Token token) {

   if (paymentMethod != null) {

      // Crear el item que se está cobrando
      Item item = new Item(DUMMY_ITEM_ID, DUMMY_ITEM_QUANTITY,
      DUMMY_ITEM_UNIT_PRICE);

      // Obtener el ID del medio de pago
      String paymentMethodId = paymentMethod.getId();

      // Obtener el ID del banco que emite la tarjeta
      Long cardIssuerId = issuer.getId();

      // Obtener la cantidad de cuotas
      Integer installments = payerCost.getInstallments();

      // Obtener el ID del token
      String tokenId = token.getId();


      /*    Crear el body del request que va a llegar a tu servidor.
      *  Debes indicar el item, la cantidad de cuotas, el banco,
      *  el token de la tarjeta, el medio de pago y cómo identificas
      *  a tu usuario para que puedas asignarle a éste el movimiento
      */
      MerchantPayment payment = new MerchantPayment(item, installments,
      cardIssuerId, tokenId, paymentMethodId, DUMMY_CAMPAIGN_ID, DUMMY_MERCHANT_ACCESS_TOKEN);

      // Enviar los datos a tu servidor
      MerchantServer.createPayment(activity, TU_BASE_URL, TU_CREATE_PAYMENT_URI,
      payment, new Callback<Payment>() {
         @Override
         public void success(Payment payment) {
                // Ya se realizó el pago.
                // Inicio de componente de resultado.
                new MercadoPago.StartActivityBuilder()
                  .setPublicKey(TU_PUBLIC_KEY)
                  .setActivity(this)
                  .setPayment(payment)
                  .setPaymentMethod(paymentMethod)
                  .startPaymentResultActivity();
            }
         }

         @Override
         public void failure(ApiException apiException) {

            // Ups, ha ocurrido un error.

         }
      });
   } else {
      Toast.makeText(activity, "Invalid payment method", Toast.LENGTH_LONG).show();
   }
}
                        
                        
                           
                        
                     

* Envía tantos datos del pago como puedas. Mientras más información nos envíes, mejor será tu experiencia y la de tus usuarios.

Resultado de pagos

Cuando el usuario elige pagar con tarjeta pueden ocurrir diferentes escenarios a la hora de procesar el pago. El pago puede ser aprobado, pero también pueden haber varios motivos por los cuales el pago puede ser rechazado. Son motivos de rechazo de un pago, la carga errónea del número de tarjeta, del código de seguridad, de la fecha de vencimiento, la falta de fondos para completar el pago, que la tarjeta no esté habilitada, que el usuario deba llamar al emisor de la tarjeta para autorizar el pago, entre otros.

Ofrecemos un componente en nuestra SDK, que dependiendo del tipo y el estado del pago, mostramos una pantalla de resultados con toda la información necesaria para que el usuario entienda si el pago fue aprobado, el por qué fue rechazado o qué debe hacer si el mismo se encuentra pendiente.

Dentro de los motivos de rechazo mencionados, existen algunos pagos que se pueden recuperar y lograr su aprobación. Estos rechazos se deben al ingreso erróneo de los datos de la tarjeta o porque el emisor de la tarjeta frenó el pago. Para más información sobre el recupero del pago dirigirse a la sección siguiente.

Cuando se elige un tipo de medio de pago que no es con tarjeta, el pago quedará pendiente a una acción a realizar por el usuario. Para estos casos nuestro componente ofrece una pantalla con los pasos a seguir para concretar el pago.

Este componente se utiliza de la siguiente forma:

                        
public void startPaymentResultActivity(Payment payment, PaymentMethod paymentMethod) {

  new MercadoPago.StartActivityBuilder()
    .setPublicKey(TU_PUBLIC_KEY)
    .setActivity(this)
    .setPayment(payment)
    .setPaymentMethod(paymentMethod)
    .startPaymentResultActivity();
}

// Espera el resultado
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  if (requestCode == MercadoPago.PAYMENT_RESULT_REQUEST_CODE) {
    if (resultCode == RESULT_CANCELED && data != null) {
      if (data.getStringExtra("nextAction").equals(PaymentResultAction.SELECT_OTHER_PAYMENT_METHOD)){
        // Muestra otros medios de pagos disponibles
      }
      if (data.getStringExtra("nextAction").equals(PaymentResultAction.RECOVER_PAYMENT)){
        // Ve a la siguiente sección para ver como recuperar un pago
      }
    }
  }
}
                        
                        
                           
                        
                     

Recupero de pagos

Este componente es el que utilizamos para realizar cobros con tarjeta de crédito, que además, nos permite recuperar pagos que fueron rechazados porque el usuario ingresó mal los datos de su tarjeta o porque el usuario debe realizar un llamado al emisor de la tarjeta para habilitar el pago.

En los casos en los cuales se rechazó el pago por la carga errónea de los datos de la tarjeta este componente permite solicitar solo el ingreso de los datos de la tarjeta sin que el usuario deba ingresarlos todos nuevamente.

En los casos en los cuales el emisor de la tarjeta frena el pago, el usuario debe llamar y autorizar el mismo. Una vez obtenida la autorización, este componente permite que solicites solo el código de seguridad para regenerar el pago. De esta manera, otorgamos una mejor experiencia, dado que no pedimos al usuario que ingrese nuevamente todos los datos de la tarjeta.

En las dos situaciones descriptas, debes iniciar el componente de la siguiente manera:

                        
public void startCardVaultActivity(PaymentRecovery paymentRecovery) {
  PaymentRecovery paymentRecovery = new PaymentRecovery(token, payment, paymentMethod, payerCost, issuer);

  new MercadoPago.StartActivityBuilder()
    .setActivity(this)
    .setPublicKey(TU_PUBLIC_KEY)
    .setAmount(MONTO_A_COBRAR)
    .setSite(Sites.ARGENTINA)
    .setInstallmentsEnabled(true)
    .setPaymentRecovery(paymentRecovery);
    .startCardVaultActivity();
}

// Espera el resultado
protected void onActivityResult(int resultCode, Intent data){
  if(requestCode == MercadoPago.CARD_VAULT_REQUEST_CODE) {
    if (resultCode == RESULT_OK) {
      Issuer issuer = JsonUtil.getInstance().fromJson(data.getStringExtra("issuer"), Issuer.class);
      PayerCost payerCost = JsonUtil.getInstance().fromJson(data.getStringExtra("payerCost"), PayerCost.class);
      Token token = JsonUtil.getInstance().fromJson(data.getStringExtra("token"), Token.class);
      PaymentMethod paymentMethod = JsonUtil.getInstance().fromJson(data.getStringExtra("paymentMethod"), PaymentMethod.class);

      // Listo! Envía los datos a tu servidor
    } else {
      if (data != null && data.getStringExtra("mpException") != null) {
        // Ups, algo salió mal
      }
    }
  }
}
                        
                        
                           
                        
                     

Customiza los componentes

También puedes excluír medios de pago, tipos de medios de pago, elegir un máximo de cuotas o una cantidad de cuotas por default.

Puedes cambiar el color de nuestros componentes, y elegir entre una fuente clara u oscura.

Configuraciones de medios de pago

Nuestra SDK cuenta con un objeto "PaymentPreference" el cual puede enviarse a cada componente. Este objeto representa tu configuración de cómo quieres customizar la forma de cobrar. Ejemplos:

                        
PaymentPreference paymentPreference = new PaymentPreference();

//Agrega una lista de exclusiones de tipos de medios de pago si lo deseas
List<String> excludedPaymentTypes = new ArrayList();
excludedPaymentTypes.add(PaymentTypes.TICKET);

paymentPreference.setExcludedPaymentTypeIds(excludedPaymentTypes);

//Agrega una lista de exclusiones de tipos de medio de pago si lo deseas
List<String> excludedPaymentMethods = new ArrayList();
excludedPaymentMethods.add(PaymentMethods.ARGENTINA.VISA);

paymentPreference.setExcludedPaymentMethodIds(excludedPaymentMethods);

//Agrega una cantidad máxima de cuotas aceptadas si lo deseas
paymentPreference.setMaxAcceptedInstallments(6);

//Agrega una cantidad de cuotas por default si lo deseas
paymentPreference.setDefaultInstallments(3);

new MercadoPago.StartActivityBuilder().
    //Agrega los demás setters que corresponden al componente a utilizar
    .setPaymentPreference(paymentPreference) //Optional
    //Inicia el componente

                        
                        
                           
                        
                     

Decoración

Nuestra SDK cuenta con un objeto "DecorationPreference" el cual puede enviarse a cada componente. Este objeto te permite elegir un color base, a partir del cual decoramos las distintas partes de los componentes. Además, si tu color base es claro, puedes habilitar una fuente oscura.

                        

DecorationPreference decorationPreference = new DecorationPreference();

//Puedes obtener el color desde un recurso de tu colors.xml
decorationPreference.setBaseColor(ContextCompat.getColor(context, R.color.your_color));

//O con un código de color hexadecimal
decorationPreference.setBaseColor("#77B2D2");

//También puedes habilitar la fuente oscura
decorationPreference.enableDarkFont();

new MercadoPago.StartActivityBuilder().
    //Agrega los demás setters que corresponden al componente a utilizar
    .setDecorationPreference(decorationPreference) //Optional
    //Inicia el componente