OAuth2 Transaction API

OAuth2

oauthAuthorizeGet

OAuth2 authorization endpoint

Redirect users here to begin the OAuth2 authorization flow


/oauth/authorize

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://api.example.com/v1/oauth/authorize?response_type=&client_id=&redirect_uri=&scope=&state="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OAuth2Api;

import java.io.File;
import java.util.*;

public class OAuth2ApiExample {

    public static void main(String[] args) {
        
        OAuth2Api apiInstance = new OAuth2Api();
        String responseType = responseType_example; // String | Must be 'code' for authorization code flow
        String clientId = clientId_example; // String | The client ID obtained during registration
        String redirectUri = redirectUri_example; // String | Must match one of the registered redirect URIs
        String scope = scope_example; // String | Space-separated list of scopes (e.g., 'transactions:read transactions:write')
        String state = state_example; // String | Optional state parameter to prevent CSRF attacks
        try {
            apiInstance.oauthAuthorizeGet(responseType, clientId, redirectUri, scope, state);
        } catch (ApiException e) {
            System.err.println("Exception when calling OAuth2Api#oauthAuthorizeGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OAuth2Api;

public class OAuth2ApiExample {

    public static void main(String[] args) {
        OAuth2Api apiInstance = new OAuth2Api();
        String responseType = responseType_example; // String | Must be 'code' for authorization code flow
        String clientId = clientId_example; // String | The client ID obtained during registration
        String redirectUri = redirectUri_example; // String | Must match one of the registered redirect URIs
        String scope = scope_example; // String | Space-separated list of scopes (e.g., 'transactions:read transactions:write')
        String state = state_example; // String | Optional state parameter to prevent CSRF attacks
        try {
            apiInstance.oauthAuthorizeGet(responseType, clientId, redirectUri, scope, state);
        } catch (ApiException e) {
            System.err.println("Exception when calling OAuth2Api#oauthAuthorizeGet");
            e.printStackTrace();
        }
    }
}
String *responseType = responseType_example; // Must be 'code' for authorization code flow
String *clientId = clientId_example; // The client ID obtained during registration
String *redirectUri = redirectUri_example; // Must match one of the registered redirect URIs
String *scope = scope_example; // Space-separated list of scopes (e.g., 'transactions:read transactions:write') (optional)
String *state = state_example; // Optional state parameter to prevent CSRF attacks (optional)

OAuth2Api *apiInstance = [[OAuth2Api alloc] init];

// OAuth2 authorization endpoint
[apiInstance oauthAuthorizeGetWith:responseType
    clientId:clientId
    redirectUri:redirectUri
    scope:scope
    state:state
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OAuth2TransactionApi = require('o_auth2_transaction_api');

var api = new OAuth2TransactionApi.OAuth2Api()
var responseType = responseType_example; // {{String}} Must be 'code' for authorization code flow
var clientId = clientId_example; // {{String}} The client ID obtained during registration
var redirectUri = redirectUri_example; // {{String}} Must match one of the registered redirect URIs
var opts = { 
  'scope': scope_example, // {{String}} Space-separated list of scopes (e.g., 'transactions:read transactions:write')
  'state': state_example // {{String}} Optional state parameter to prevent CSRF attacks
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.oauthAuthorizeGet(responseType, clientId, redirectUri, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class oauthAuthorizeGetExample
    {
        public void main()
        {

            var apiInstance = new OAuth2Api();
            var responseType = responseType_example;  // String | Must be 'code' for authorization code flow
            var clientId = clientId_example;  // String | The client ID obtained during registration
            var redirectUri = redirectUri_example;  // String | Must match one of the registered redirect URIs
            var scope = scope_example;  // String | Space-separated list of scopes (e.g., 'transactions:read transactions:write') (optional) 
            var state = state_example;  // String | Optional state parameter to prevent CSRF attacks (optional) 

            try
            {
                // OAuth2 authorization endpoint
                apiInstance.oauthAuthorizeGet(responseType, clientId, redirectUri, scope, state);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OAuth2Api.oauthAuthorizeGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOAuth2Api();
$responseType = responseType_example; // String | Must be 'code' for authorization code flow
$clientId = clientId_example; // String | The client ID obtained during registration
$redirectUri = redirectUri_example; // String | Must match one of the registered redirect URIs
$scope = scope_example; // String | Space-separated list of scopes (e.g., 'transactions:read transactions:write')
$state = state_example; // String | Optional state parameter to prevent CSRF attacks

try {
    $api_instance->oauthAuthorizeGet($responseType, $clientId, $redirectUri, $scope, $state);
} catch (Exception $e) {
    echo 'Exception when calling OAuth2Api->oauthAuthorizeGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OAuth2Api;

my $api_instance = WWW::SwaggerClient::OAuth2Api->new();
my $responseType = responseType_example; # String | Must be 'code' for authorization code flow
my $clientId = clientId_example; # String | The client ID obtained during registration
my $redirectUri = redirectUri_example; # String | Must match one of the registered redirect URIs
my $scope = scope_example; # String | Space-separated list of scopes (e.g., 'transactions:read transactions:write')
my $state = state_example; # String | Optional state parameter to prevent CSRF attacks

eval { 
    $api_instance->oauthAuthorizeGet(responseType => $responseType, clientId => $clientId, redirectUri => $redirectUri, scope => $scope, state => $state);
};
if ($@) {
    warn "Exception when calling OAuth2Api->oauthAuthorizeGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.OAuth2Api()
responseType = responseType_example # String | Must be 'code' for authorization code flow
clientId = clientId_example # String | The client ID obtained during registration
redirectUri = redirectUri_example # String | Must match one of the registered redirect URIs
scope = scope_example # String | Space-separated list of scopes (e.g., 'transactions:read transactions:write') (optional)
state = state_example # String | Optional state parameter to prevent CSRF attacks (optional)

try: 
    # OAuth2 authorization endpoint
    api_instance.oauth_authorize_get(responseType, clientId, redirectUri, scope=scope, state=state)
except ApiException as e:
    print("Exception when calling OAuth2Api->oauthAuthorizeGet: %s\n" % e)

Parameters

Query parameters
Name Description
response_type*
String
Must be 'code' for authorization code flow
Required
client_id*
String
The client ID obtained during registration
Required
redirect_uri*
String (uri)
Must match one of the registered redirect URIs
Required
scope
String
Space-separated list of scopes (e.g., 'transactions:read transactions:write')
state
String
Optional state parameter to prevent CSRF attacks

Responses

Status: 302 - Redirect to login page or back to client with authorization code

Name Type Format Description
Location String uri

Status: 400 - Invalid request parameters

oauthRegisterPost

Register a new OAuth2 client

Register a new client application to obtain client credentials for OAuth2 flow


/oauth/register

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://api.example.com/v1/oauth/register"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OAuth2Api;

import java.io.File;
import java.util.*;

public class OAuth2ApiExample {

    public static void main(String[] args) {
        
        OAuth2Api apiInstance = new OAuth2Api();
        ClientRegistration body = ; // ClientRegistration | 
        try {
            ClientCredentials result = apiInstance.oauthRegisterPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OAuth2Api#oauthRegisterPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OAuth2Api;

public class OAuth2ApiExample {

    public static void main(String[] args) {
        OAuth2Api apiInstance = new OAuth2Api();
        ClientRegistration body = ; // ClientRegistration | 
        try {
            ClientCredentials result = apiInstance.oauthRegisterPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OAuth2Api#oauthRegisterPost");
            e.printStackTrace();
        }
    }
}
ClientRegistration *body = ; // 

OAuth2Api *apiInstance = [[OAuth2Api alloc] init];

// Register a new OAuth2 client
[apiInstance oauthRegisterPostWith:body
              completionHandler: ^(ClientCredentials output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OAuth2TransactionApi = require('o_auth2_transaction_api');

var api = new OAuth2TransactionApi.OAuth2Api()
var body = ; // {{ClientRegistration}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.oauthRegisterPost(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class oauthRegisterPostExample
    {
        public void main()
        {

            var apiInstance = new OAuth2Api();
            var body = new ClientRegistration(); // ClientRegistration | 

            try
            {
                // Register a new OAuth2 client
                ClientCredentials result = apiInstance.oauthRegisterPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OAuth2Api.oauthRegisterPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOAuth2Api();
$body = ; // ClientRegistration | 

try {
    $result = $api_instance->oauthRegisterPost($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OAuth2Api->oauthRegisterPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OAuth2Api;

my $api_instance = WWW::SwaggerClient::OAuth2Api->new();
my $body = WWW::SwaggerClient::Object::ClientRegistration->new(); # ClientRegistration | 

eval { 
    my $result = $api_instance->oauthRegisterPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OAuth2Api->oauthRegisterPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.OAuth2Api()
body =  # ClientRegistration | 

try: 
    # Register a new OAuth2 client
    api_response = api_instance.oauth_register_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OAuth2Api->oauthRegisterPost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 201 - Client successfully registered

Status: 400 - Invalid registration data

oauthTokenPost

OAuth2 token endpoint

Exchange authorization code for access token or refresh an existing token


/oauth/token

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/x-www-form-urlencoded"\
"https://api.example.com/v1/oauth/token"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OAuth2Api;

import java.io.File;
import java.util.*;

public class OAuth2ApiExample {

    public static void main(String[] args) {
        
        OAuth2Api apiInstance = new OAuth2Api();
        try {
            TokenResponse result = apiInstance.oauthTokenPost();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OAuth2Api#oauthTokenPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OAuth2Api;

public class OAuth2ApiExample {

    public static void main(String[] args) {
        OAuth2Api apiInstance = new OAuth2Api();
        try {
            TokenResponse result = apiInstance.oauthTokenPost();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OAuth2Api#oauthTokenPost");
            e.printStackTrace();
        }
    }
}

OAuth2Api *apiInstance = [[OAuth2Api alloc] init];

// OAuth2 token endpoint
[apiInstance oauthTokenPostWithCompletionHandler: 
              ^(TokenResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OAuth2TransactionApi = require('o_auth2_transaction_api');

var api = new OAuth2TransactionApi.OAuth2Api()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.oauthTokenPost(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class oauthTokenPostExample
    {
        public void main()
        {

            var apiInstance = new OAuth2Api();

            try
            {
                // OAuth2 token endpoint
                TokenResponse result = apiInstance.oauthTokenPost();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OAuth2Api.oauthTokenPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOAuth2Api();

try {
    $result = $api_instance->oauthTokenPost();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OAuth2Api->oauthTokenPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OAuth2Api;

my $api_instance = WWW::SwaggerClient::OAuth2Api->new();

eval { 
    my $result = $api_instance->oauthTokenPost();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OAuth2Api->oauthTokenPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.OAuth2Api()

try: 
    # OAuth2 token endpoint
    api_response = api_instance.oauth_token_post()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OAuth2Api->oauthTokenPost: %s\n" % e)

Parameters

Responses

Status: 200 - Token successfully generated

Status: 400 - Invalid grant request

Status: 401 - Invalid client credentials

Transactions

transactionsPingPost

Submit a transaction for processing (Ping)

Submit a transaction number for payment processing. The system will process the payment and call back via the pong endpoint.


/transactions/ping

Usage and SDK Samples

curl -X POST\
\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://api.example.com/v1/transactions/ping"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TransactionsApi;

import java.io.File;
import java.util.*;

public class TransactionsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        TransactionsApi apiInstance = new TransactionsApi();
        PingRequest body = ; // PingRequest | 
        try {
            PingResponse result = apiInstance.transactionsPingPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionsApi#transactionsPingPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TransactionsApi;

public class TransactionsApiExample {

    public static void main(String[] args) {
        TransactionsApi apiInstance = new TransactionsApi();
        PingRequest body = ; // PingRequest | 
        try {
            PingResponse result = apiInstance.transactionsPingPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionsApi#transactionsPingPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];
PingRequest *body = ; // 

TransactionsApi *apiInstance = [[TransactionsApi alloc] init];

// Submit a transaction for processing (Ping)
[apiInstance transactionsPingPostWith:body
              completionHandler: ^(PingResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OAuth2TransactionApi = require('o_auth2_transaction_api');
var defaultClient = OAuth2TransactionApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN"

var api = new OAuth2TransactionApi.TransactionsApi()
var body = ; // {{PingRequest}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.transactionsPingPost(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class transactionsPingPostExample
    {
        public void main()
        {

            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new TransactionsApi();
            var body = new PingRequest(); // PingRequest | 

            try
            {
                // Submit a transaction for processing (Ping)
                PingResponse result = apiInstance.transactionsPingPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TransactionsApi.transactionsPingPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\ApiTransactionsApi();
$body = ; // PingRequest | 

try {
    $result = $api_instance->transactionsPingPost($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TransactionsApi->transactionsPingPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TransactionsApi;

# Configure OAuth2 access token for authorization: oauth2
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::TransactionsApi->new();
my $body = WWW::SwaggerClient::Object::PingRequest->new(); # PingRequest | 

eval { 
    my $result = $api_instance->transactionsPingPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TransactionsApi->transactionsPingPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.TransactionsApi()
body =  # PingRequest | 

try: 
    # Submit a transaction for processing (Ping)
    api_response = api_instance.transactions_ping_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionsApi->transactionsPingPost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 202 - Transaction accepted for processing

Status: 400 - Invalid transaction data

Status: 401 - Unauthorized - invalid or missing token

Status: 403 - Forbidden - insufficient scope

transactionsPongPost

Transaction status callback (Pong)

Webhook endpoint that receives transaction status updates. This endpoint should be implemented by the client application.


/transactions/pong

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://api.example.com/v1/transactions/pong"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TransactionsApi;

import java.io.File;
import java.util.*;

public class TransactionsApiExample {

    public static void main(String[] args) {
        
        TransactionsApi apiInstance = new TransactionsApi();
        PongRequest body = ; // PongRequest | 
        try {
            PongResponse result = apiInstance.transactionsPongPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionsApi#transactionsPongPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TransactionsApi;

public class TransactionsApiExample {

    public static void main(String[] args) {
        TransactionsApi apiInstance = new TransactionsApi();
        PongRequest body = ; // PongRequest | 
        try {
            PongResponse result = apiInstance.transactionsPongPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionsApi#transactionsPongPost");
            e.printStackTrace();
        }
    }
}
PongRequest *body = ; // 

TransactionsApi *apiInstance = [[TransactionsApi alloc] init];

// Transaction status callback (Pong)
[apiInstance transactionsPongPostWith:body
              completionHandler: ^(PongResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OAuth2TransactionApi = require('o_auth2_transaction_api');

var api = new OAuth2TransactionApi.TransactionsApi()
var body = ; // {{PongRequest}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.transactionsPongPost(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class transactionsPongPostExample
    {
        public void main()
        {

            var apiInstance = new TransactionsApi();
            var body = new PongRequest(); // PongRequest | 

            try
            {
                // Transaction status callback (Pong)
                PongResponse result = apiInstance.transactionsPongPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TransactionsApi.transactionsPongPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTransactionsApi();
$body = ; // PongRequest | 

try {
    $result = $api_instance->transactionsPongPost($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TransactionsApi->transactionsPongPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TransactionsApi;

my $api_instance = WWW::SwaggerClient::TransactionsApi->new();
my $body = WWW::SwaggerClient::Object::PongRequest->new(); # PongRequest | 

eval { 
    my $result = $api_instance->transactionsPongPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TransactionsApi->transactionsPongPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.TransactionsApi()
body =  # PongRequest | 

try: 
    # Transaction status callback (Pong)
    api_response = api_instance.transactions_pong_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionsApi->transactionsPongPost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Callback received and processed successfully

Status: 400 - Invalid callback data

transactionsTransactionIdStatusGet

Get transaction status

Retrieve the current status of a specific transaction


/transactions/{transactionId}/status

Usage and SDK Samples

curl -X GET\
\
-H "Accept: application/json"\
"https://api.example.com/v1/transactions/{transactionId}/status"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TransactionsApi;

import java.io.File;
import java.util.*;

public class TransactionsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        TransactionsApi apiInstance = new TransactionsApi();
        String transactionId = transactionId_example; // String | The unique transaction identifier
        try {
            TransactionStatus result = apiInstance.transactionsTransactionIdStatusGet(transactionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionsApi#transactionsTransactionIdStatusGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TransactionsApi;

public class TransactionsApiExample {

    public static void main(String[] args) {
        TransactionsApi apiInstance = new TransactionsApi();
        String transactionId = transactionId_example; // String | The unique transaction identifier
        try {
            TransactionStatus result = apiInstance.transactionsTransactionIdStatusGet(transactionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionsApi#transactionsTransactionIdStatusGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];
String *transactionId = transactionId_example; // The unique transaction identifier

TransactionsApi *apiInstance = [[TransactionsApi alloc] init];

// Get transaction status
[apiInstance transactionsTransactionIdStatusGetWith:transactionId
              completionHandler: ^(TransactionStatus output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var OAuth2TransactionApi = require('o_auth2_transaction_api');
var defaultClient = OAuth2TransactionApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN"

var api = new OAuth2TransactionApi.TransactionsApi()
var transactionId = transactionId_example; // {{String}} The unique transaction identifier

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.transactionsTransactionIdStatusGet(transactionId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class transactionsTransactionIdStatusGetExample
    {
        public void main()
        {

            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new TransactionsApi();
            var transactionId = transactionId_example;  // String | The unique transaction identifier

            try
            {
                // Get transaction status
                TransactionStatus result = apiInstance.transactionsTransactionIdStatusGet(transactionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TransactionsApi.transactionsTransactionIdStatusGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\ApiTransactionsApi();
$transactionId = transactionId_example; // String | The unique transaction identifier

try {
    $result = $api_instance->transactionsTransactionIdStatusGet($transactionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TransactionsApi->transactionsTransactionIdStatusGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TransactionsApi;

# Configure OAuth2 access token for authorization: oauth2
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::TransactionsApi->new();
my $transactionId = transactionId_example; # String | The unique transaction identifier

eval { 
    my $result = $api_instance->transactionsTransactionIdStatusGet(transactionId => $transactionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TransactionsApi->transactionsTransactionIdStatusGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.TransactionsApi()
transactionId = transactionId_example # String | The unique transaction identifier

try: 
    # Get transaction status
    api_response = api_instance.transactions_transaction_id_status_get(transactionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionsApi->transactionsTransactionIdStatusGet: %s\n" % e)

Parameters

Path parameters
Name Description
transactionId*
String
The unique transaction identifier
Required

Responses

Status: 200 - Transaction status retrieved successfully

Status: 404 - Transaction not found

Status: 401 - Unauthorized