Autenticación

Las llaves de autenticación son usadas para autenticar todas tus llamadas al servidor de Conekta por medio de autenticación básica HTTP. Las llaves o keys pueden ser recuperadas y configuradas dentro de tu Admin Conekta. Cada key es configurada para ser utilizada ya sea en modo sandbox o producción y para cada uno de estos modos obtendrás una key privada para llamadas entre servidores y una key pública para utilizar con ConektaJS o en su defecto algún SDK como Android y iOS.

Asegúrate de nunca compartir tus keys públicas o privadas con nadie, ya que podrían tener accesos a tu cuenta de Conekta.

Hemos utilizado una llave de API de prueba en todos los ejemplos de la documentación para que puedas probar todos los ejemplos de inmediato y sin tener que crear una cuenta.

No olvides tener a la mano el KIT de pruebas para estar probando los métodos de pago con tarjetas durante el desarrollo.

Para efectos prácticos estamos utilizando nuestras Bibliotecas de pagos , se mantienen actualizadas y te servirán para integrarte fácilmente con nuestros servicios:

Recuerda que:

Las llaves se obtienen desde el panel Conekta Si tu llave por ejemplo fuera:

  • Key_LlavePRIVADA123456789

Pasaría a ser ya codificada con el Basic Auth una cadena con el prefijo de la cadena BASE64 algo como:

  • S2V5X0xsYXZlUFJJVkFEQTEyMzQ1Njc4OQ==
Imagen 1: Una vista simple para obtener las llaves desde POSTMAN de Google, aquí declaramos variables de entorno.Imagen 1: Una vista simple para obtener las llaves desde POSTMAN de Google, aquí declaramos variables de entorno.

Imagen 1: Una vista simple para obtener las llaves desde POSTMAN de Google, aquí declaramos variables de entorno.

Imagen 2: Una vista simple para obtener las llaves desde POSTMAN de Google, aquí la herramienta las genera automáticamente, la imagen es informativaImagen 2: Una vista simple para obtener las llaves desde POSTMAN de Google, aquí la herramienta las genera automáticamente, la imagen es informativa

Imagen 2: Una vista simple para obtener las llaves desde POSTMAN de Google, aquí la herramienta las genera automáticamente, la imagen es informativa

curl --location --request POST 'https://api.conekta.io'/{API_endpoint}' \
//POST / PUT / GET / DEL son admitidas dependiendo del endpont a utilizar//
--header 'Accept: application/vnd.conekta-v2.0.0+json' \
--header 'Accept-Language: es' \
--header 'Content-Type: application/json' \
--header 'Authorization: Basic S2V5X0xsYXZlUFJJVkFEQTEyMzQ1Njc4OQ==' \
--data-raw '{
//JSON REQUEST BODY
}'
#Ejemplo: Los ejemplos deben de servir de guia, pero deben de desarrollarse de manera segura en conexiones HTTPS y bajo los lineamientos de buenas prácticas

require 'net/http'
require 'openssl'

uri = URI('https://localhost/')

Net::HTTP.start(uri.host, uri.port,
  :use_ssl => uri.scheme == 'https', 
  :verify_mode => OpenSSL::SSL::VERIFY_NONE) do |http|

  request = Net::HTTP::Get.new uri.request_uri
  request.basic_auth 'matt', 'secret'

  response = http.request request # Net::HTTPResponse object

  puts response
  puts response.body
end
// Ejemplo: Los ejemplos deben de servir de guia, pero deben de desarrollarse de manera segura en conexiones HTTPS y bajo los lineamientos de buenas prácticas

<?php
function require_auth() {
    $AUTH_USER = 'admin';
    $AUTH_PASS = 'admin';
    header('Cache-Control: no-cache, must-revalidate, max-age=0');
    $has_supplied_credentials = !(empty($_SERVER['PHP_AUTH_USER']) && empty($_SERVER['PHP_AUTH_PW']));
    $is_not_authenticated = (
        !$has_supplied_credentials ||
        $_SERVER['PHP_AUTH_USER'] != $AUTH_USER ||
        $_SERVER['PHP_AUTH_PW']   != $AUTH_PASS
    );
    if ($is_not_authenticated) {
        header('HTTP/1.1 401 Authorization Required');
        header('WWW-Authenticate: Basic realm="Access denied"');
        exit;
    }
}
#Ejemplo: Los ejemplos deben de servir de guia, pero deben de desarrollarse de manera segura en conexiones HTTPS y bajo los lineamientos de buenas prácticas
  
from http.client import HTTPSConnection
from base64 import b64encode
#This sets up the https connection
c = HTTPSConnection("www.google.com")
#we need to base 64 encode it 
#and then decode it to acsii as python 3 stores it as a byte string
userAndPass = b64encode(b"username:password").decode("ascii")
headers = { 'Authorization' : 'Basic %s' %  userAndPass }
#then connect
c.request('GET', '/', headers=headers)
#get the response back
res = c.getresponse()
# at this point you could check the status etc
# this gets the page text
data = res.read()
//Ejemplo: Los ejemplos deben de servir de guia, pero deben de desarrollarse de manera segura en conexiones HTTPS y bajo los lineamientos de buenas prácticas

const userService = require('../users/user.service');

module.exports = basicAuth;

async function basicAuth(req, res, next) {
    // make authenticate path public
    if (req.path === '/users/authenticate') {
        return next();
    }

    // check for basic auth header
    if (!req.headers.authorization || req.headers.authorization.indexOf('Basic ') === -1) {
        return res.status(401).json({ message: 'Missing Authorization Header' });
    }

    // verify auth credentials
    const base64Credentials =  req.headers.authorization.split(' ')[1];
    const credentials = Buffer.from(base64Credentials, 'base64').toString('ascii');
    const [username, password] = credentials.split(':');
    const user = await userService.authenticate({ username, password });
    if (!user) {
        return res.status(401).json({ message: 'Invalid Authentication Credentials' });
    }

    // attach user to request object
    req.user = user

    next();
}
//Ejemplo: Los ejemplos deben de servir de guia, pero deben de desarrollarse de manera segura en conexiones HTTPS y bajo los lineamientos de buenas prácticas

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Base64;


public class HttpBasicAuth {

    public static void main(String[] args) {

        try {
            URL url = new URL ("http://ip:port/login");
            String encoding = Base64.getEncoder().encodeToString(("test1:test1").getBytes(‌"UTF‌​-8"​));

            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setDoOutput(true);
            connection.setRequestProperty  ("Authorization", "Basic " + encoding);
            InputStream content = (InputStream)connection.getInputStream();
            BufferedReader in   = 
                new BufferedReader (new InputStreamReader (content));
            String line;
            while ((line = in.readLine()) != null) {
                System.out.println(line);
            }
        } catch(Exception e) {
            e.printStackTrace();
        }

    }

}
//Ejemplo: Los ejemplos deben de servir de guia, pero deben de desarrollarse de manera segura en conexiones HTTPS y bajo los lineamientos de buenas prácticas

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net.Http;
using System.Net;


namespace HTTP_Test
{
    class program
    {
        static void Main()
        {
            Task t = new Task(HTTP_GET);
            t.Start();
            Console.ReadLine();
        }

        static async void HTTP_GET()
        {
            var TARGETURL = "http://en.wikipedia.org/";

            HttpClientHandler handler = new HttpClientHandler()
            {
                Proxy = new WebProxy("http://127.0.0.1:8888"),
                UseProxy = true,
            };

            Console.WriteLine("GET: + " + TARGETURL);

            // ... Use HttpClient.            
            HttpClient client = new HttpClient(handler);

            var byteArray = Encoding.ASCII.GetBytes("username:password1234");
            client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));

            HttpResponseMessage response = await client.GetAsync(TARGETURL);
            HttpContent content = response.Content;

            // ... Check Status Code                                
            Console.WriteLine("Response StatusCode: " + (int)response.StatusCode);

            // ... Read the string.
            string result = await content.ReadAsStringAsync();

            // ... Display the result.
            if (result != null &&
            result.Length >= 50)
            {
                Console.WriteLine(result.Substring(0, 50) + "...");
            }
        }
    }
}
//Ejemplo: Los ejemplos deben de servir de guia, pero deben de desarrollarse de manera segura en conexiones HTTPS y bajo los lineamientos de buenas prácticas

func basicAuth(username, password string) string {
  auth := username + ":" + password
  return base64.StdEncoding.EncodeToString([]byte(auth))
}

func redirectPolicyFunc(req *http.Request, via []*http.Request) error{
  req.Header.Add("Authorization","Basic " + basicAuth("username1","password123"))
  return nil
}

func main() {
  client := &http.Client{
    Jar: cookieJar,
    CheckRedirect: redirectPolicyFunc,
  }

  req, err := http.NewRequest("GET", "http://localhost/", nil)
  req.Header.Add("Authorization","Basic " + basicAuth("username1","password123")) 
  resp, err := client.Do(req)
}