LogoLogo
  • Platform Overview
  • 🗺️Guides
    • Getting Started
    • Users
      • Integrate the User SDK
      • Registration
      • Authentication
      • SDK Releases
      • API Reference
    • Entitlements
      • Administrative API
        • Integrating the Administrative API
        • Entitlement Definitions
        • Managing Entitlements Sets
        • Managing Entitlements Sequences
        • Managing User Entitlements
        • API Schema
      • End-user API
        • Integrate the Entitlements SDK
        • Redeeming Entitlements
        • Retrieving Entitlements
        • SDK Releases
        • API Reference
    • Sudos
      • Integrate the Sudo Profiles SDK
      • Sudo Entitlements
      • Manage Sudos
      • SDK Releases
      • API Reference
    • Telephony
      • Integrate the Telephony SDK
      • Manage Phone Numbers
      • Text Messaging
      • Voice Calling
      • Telephony Simulator
      • SDK Releases
      • API Reference
    • Email
      • Integrate the Email SDK
      • Email Entitlements
      • Manage Email Addresses
      • Sending & Receiving Email
      • Manage Email Folders
      • Draft Email Messages
      • Manage Email Address Blocklists
      • Email Address Public Information
      • Pagination
      • Caching
      • Configuration Data
      • Email Notifications
      • SDK Releases
      • API Reference
    • Decentralized Identity
      • Edge Agent
        • Relay SDK
          • Integrate the Relay SDK
          • Relay Entitlements
          • Manage Relay Postboxes
          • Manage Relay Messages
          • Receiving Messages
          • SDK Releases
        • Edge Agent SDK
          • Integrate the Edge Agent SDK
          • Agent Management
          • Manage Wallets
          • Establishing Connections
          • Manage Connections
          • Messaging
          • Manage DIDs
          • Accepting New Credentials
          • Manage Credentials
          • Present Credentials for Verification
          • Utilize Alternative Cryptography Providers
          • SDK Releases
          • Standards and Protocols
      • Cloud Agent
        • Cloud Agent Admin API
          • Integrate the Cloud Agent Admin API
          • Aries Interop Profile (AIP)
            • Connection Exchanges
            • Credential Exchanges
            • Proof Exchanges
          • Connections
          • Basic Messages
          • Credentials
            • Anoncreds Credentials
              • Schemas
              • Credential Definitions
            • W3C Credentials
          • Audit Logs
          • API Schema
          • Error Codes
          • Standards and Protocols
    • Virtual Cards
      • Integrate the Virtual Cards SDK
      • Virtual Cards Entitlements
      • Virtual Cards Transaction Velocity Constraints
      • Key Management
      • Manage Funding Sources
      • Manage Virtual Cards
      • Manage Transactions
      • Configuration Data
      • Pagination
      • Caching
      • SDK Releases
      • API Reference
    • Virtual Cards Simulator
      • Integrate the Virtual Cards Simulator SDK
      • Simulate Authorizations
      • Simulate Debits
      • Simulate Refunds
      • Simulate Reversals
      • Merchants and Currencies
      • SDK Releases
      • API Reference
    • Virtual Private Network
      • Integrate the VPN SDK
      • VPN Entitlements
      • Manage Servers
      • Manage Connection
      • Observe VPN Related Events
      • SDK Releases
      • API Reference
      • Frequently Asked Questions
    • Secure ID Verification
      • Integrate the Secure ID Verification SDK
      • List Supported Countries
      • Verify an Identity
      • Check Secure ID Verification Status
      • Use the Secure ID Verification Simulator
      • SDK Releases
      • API Reference
    • Password Manager
      • Integrate the Password Manager SDK
      • Accessing the Password Manager
      • Managing Password Vaults
      • Managing Password Vault Items
      • Vault Import and Export
      • Password Utilities
      • Password Manager Entitlements
      • Password Vault Security
      • SDK Releases
      • API Reference
    • Ad/Tracker Blocker
      • Integrate the Ad/Tracker Blocker SDK
      • Manage Rulesets
      • Blocking Ads and Trackers
      • Manage Exceptions
      • SDK Releases
      • API Reference
    • Site Reputation
      • Integrate the Site Reputation SDK
      • Use the Site Reputation SDK
      • SDK Releases
      • API Reference
  • 💡Concepts
    • Sudo Digital Identities
  • 🧱Development
    • Versioning
  • 🏢Administration
    • Admin Console Roles
  • ❓Get Help
    • Request a Demo
    • Report an Issue
Powered by GitBook
On this page
  • Create a Simulated Authorization
  • Increase the Value of an Authorization
  • Simulate the Expiry of an Authorization
  1. Guides
  2. Virtual Cards Simulator

Simulate Authorizations

Simulate a request from a merchant to authorize a charge to a virtual card.

PreviousIntegrate the Virtual Cards Simulator SDKNextSimulate Debits

Last updated 7 months ago

An authorization is a request by a merchant for permission to charge a virtual card up to a fixed amount at some time in the near future.

Create a Simulated Authorization

A simulated authorization is created by calling the simulate authorization API and supplying the amount and virtual card details.

The amount supplied as input is expressed as a multiple of the smallest unit of currency the merchant accepts. For example if the currency is US dollar then the amount is the number of US cents. The merchantId is the identifier of a merchant defined in the simulator. The merchants are listed with the getSimulatorMerchants method. See .

An example implementation of creating a simulated authorization is:

try {
  const result = await simulatorClient.simulateAuthorization({
    pan: "4242424242424242",
    amount: 4200,
    merchantId: "000000001",
    expiry: { mm: "2", yyyy: "2024" },
    billingAddress: undefined,
    csc: "123",
  })
} catch (error) {
  // Handle error
}
do {
    let authInput = SimulateAuthorizationInput(
        pan: "4242424242424242",
        amount: 4200,
        merchantId: "000000001",
        expiry: Expiry(mm: 2, yyyy: 2024),
        billingAddress: nil,
        csc: "123"
    )
    let response = try await simulatorClient.simulateAuthorizationWithInput(
        authInput
    )
    if (response.approved) {
        // Authorization has been approved
    } else {
        // Handle the authorization being declined
        // see result.declineReason for why
    }
} catch let error {
    // Handle/notify the user of error
}
val authInput = SimulateAuthorizationInput(
    cardNumber = "4242424242424242",
    amount = 4200, 
    merchantId = "000000001", 
    securityCode = "123",
    expirationMonth = 2,
    expirationYear = 2024
)
launch {
    try {
        val authorization = withContext(Dispatchers.IO) {
            simulatorClient.simulateAuthorization(authInput)
        }
        if (authorization.isApproved) {
            // Authorization has been approved
        } else {
            // Handle the authorization being declined
            // see authorization.declineReason for why
        }
    } catch (e: AuthorizationException) {
        // Handle/notify the user of exception
    }
}

This API call returns an authorization that may have been approved or declined. If the authorization has been approved the merchant will be able to charge the virtual card by creating a simulated debit. See . If the authorization was declined the declineReason of the response will provide an explanation of why. If an exception occurs, the error or exception will contain a description of the fault that caused the exception.

Increase the Value of an Authorization

The amount of a simulated authorization can be increased by calling the simulate incremental authorization API and supplying the identifier of the authorization and the amount by which it will be increased.

The amount supplied as input is expressed as a multiple of the smallest unit of currency the merchant accepts. For example if the currency is US dollar then the amount is the number of US cents. The authorizationId is the identifier of the original authorization being modified that was created by a call to the simulateAuthorization method.

An example implementation of creating a simulated incremental authorization is:

try {
  const result = await simulatorClient.simulateIncrementalAuthorization({
    authorizationId: authorization.id,
    amount: 2400,
  })
} catch (error) {
  // Handle error
}
do {
    let incAuthInput = SimulateIncrementalAuthorizationInput(
        amount: 2400,
        authorizationId: authorization.id
    )
    let response = try await simulatorClient.simulateIncrementalAuthorizationWithInput(
        incAuthInput
    )
    if (response.approved) {
        // Authorization increment has been approved
    } else {
        // Handle the authorization increment being declined
        // see result.declineReason for why
    }
} catch let error {
    // Handle/notify the user of error
}    
val incAuthInput = SimulateIncrementalAuthorizationInput(
    authorizationId = authorization.id,
    amount = 2400
)
launch {
    try {
        val authorization = withContext(Dispatchers.IO) {
            simulatorClient.simulateIncrementalAuthorization(incAuthInput)
        }
        if (authorization.isApproved) {
            // Authorization increased has been approved
        } else {
            // Handle the authorization increase being declined
            // see authorization.declineReason for why
        }
    } catch (e: AuthorizationException) {
        // Handle/notify the user of exception
    }
}

Simulate the Expiry of an Authorization

An example implementation of marking an authorization as expired is:

try {
  const result = await simulatorClient.simulateAuthorizationExpiry({
    authorizationId: authorization.id,
  })
} catch (error) {
  // Handle error
}
do {
    let response = try await simulatorClient.simulateAuthorizationExpiryWithId(
        authorizationId
    )
    // Authorization is expired
} catch let error {
    // Handle/notify the user of error
}
launch {
    try {
        withContext(Dispatchers.IO) {
            simulatorClient.simulateAuthorizationExpiry(authorizationId)
        }
        // Authorization is expired
    } catch (e: AuthorizationException) {
        // Handle/notify the user of exception
    }
}

This API call returns a response that contains the identifier of the expiry request, which is of little interest. If an exception occurs, the error or exception will contain a description of the fault that caused the exception.

This API call returns an authorization that may have been approved or declined. If the authorization has been approved the merchant will be able to charge the virtual card more than permitted by the original authorization by creating a simulated debit. See . If the incremental authorization was declined the declineReason of the response will provide an explanation of why. If an exception occurs, the error or exception will contain a description of the fault that caused the exception.

An authorization can be marked as expired by calling the simulate authorization expiry API. The authorizationId is the identifier of the original authorization being modified that was created by a call to the API.

🗺️
Create a Simulated Authorization
Create a Simulated Debit
Create a Simulated Debit
List the Simulator Merchants