NAV

Nucleus  Proton  Electron

curl java javascript php python ruby

Introduction

Authentication Base URL

https://api.hydrogenplatform.com/authorization/v1

Electron Base URL

https://api.hydrogenplatform.com/electron/v1

The Electron API connects Nucleus data to perform back office bank operations.

All Hydrogen APIs are built on REST principles, with resource oriented URLs and HTTP response codes. All API responses are returned in JSON format. Additional features of the API include filtering, pagination, and data caching.

Run in Postman

Authentication

All Atom APIs use the same authentication and authorization. Please refer to the Nucleus API for detailed documentation.

Fields

IDS

All Object IDs are represented in universally unique identifier (UUID) format. A UUID is a string of 32 alphanumeric characters in the format 8-4-4-4-12. An example would be efa289b2-3565-42e6-850b-8dad25727e99.

STRINGS

All strings are limited to 255 characters unless otherwise noted.

DATES

All dates are represented in ISO 8601 format YYYY-MM-DD. An example would be 2018-01-10.

TIMESTAMPS

All object responses will include a create_date and update_date in timestamp format. All timestamps are represented in ISO 8601 format YYYY-MM-DDThh:mm:ssTZD. The “T” appears before the time element and the TZD before the time zone. An example would be 2018-01-10T16:00:30+01:00.

Errors

ERROR CODES

Code Description
400 Bad Request
401 Unauthorized. Occurs when you are using an invalid or expired access token.
403 Forbidden. The request was valid but you are not authorized to access the resource.
404 Not Found. Occurs when you are requesting a resource which doesn’t exist such as an incorrect URL, incorrect ID, or empty result.
429 Too Many Requests. Exceeded the rate limit set. Currently, there is no rate limit on the APIs.
500 Internal Server Error.
503 Service Unavailable. If the API is down for maintenance you will see this error.


STATUS CODES

Code Description
200 Ok. The request was successful.
204 No Content. The request was successful but there is no additional content to send in the response body. This will occur on a successful DELETE.

Versioning

The Electron API is currently in major version 1.0. All features which are not backwards compatible will be pushed as a major version release. Features that we consider to be backwards compatible include the following:

Changelog

Date Change Description
2022-01-20 update Added ACH and Cards entities.

Idempotency

Example Request

curl -X POST -H "Authorization: Bearer <access_token>" \
    -H "Content-Type: application/json" \
  -H "Idempotency-Key: 099961da-7f41-4309-950f-2b51689a0033" \
    -d '{
          "nucleus_funding_id": "cc0937c7-f72e-4de2-9be8-738f90258762"
      }' "https://api.hydrogenplatform.com/electron/v1/card/load"

An API request is idempotent if it has the same result no matter how many times it is tried. Hydrogen supports idempotency to allow requests to be retried without risk of the operation being performed multiple times. This is useful for requests that involve critical such as payments or account creation to protect against network outages and you are unsure if a previous request had been processed successfully. If you ever have any doubt, always submit the request again with the same idempotency key in the request header to make sure you don’t duplicate the data.

To submit an idempotent request, simply submit any POST request with an Idempotency-Key in the Request Header. If you retry the same request body and endpoint with the Idempotency-Key you will receive a cached version of the original response if it was successfully submitted the first time.

To create a unique Idempotency-Key please one of the libraries below to generate a unique UUID in the language of your choice:

Language Function
C# Guid.NewGuid
Java UUID.randomUUID
Node uuid
PHP uniqid
Python uuid Python 2 / Python 3
Ruby SecureRandom.uuid

Wallet

These services perform business logic and analysis on the Hydrogen Wallet product.

Card Clients

Create an individual card client

Certain card programs require the creation of a client before the issuance of the card. Depending on the requirements of the card program, the information may be used to perform KYC.

HTTP REQUEST

POST /card/client

Example Request

curl -X POST -H "Authorization: Bearer <access_token>" \
    -H "Content-Type: application/json" \
    -d '{
            "nucleus_client_id": "5f8c6b1b-c032-4fff-9d4f-e0cd3ec6291"
        }' "https://api.hydrogenplatform.com/electron/v1/card/client"
    api_instance = electron_api.CardApi(electron_api.ApiClient(configuration))
    card_client_request_co = electron_api.CardClientRequestCO(
      nucleus_client_id='d1ce4937-180b-47f4-b95d-7e972fbf160a'
      )
try:
    api_response = api_instance.create_client_card_using_post(card_client_request_co)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CardApi->create_ach_client_using_post: %s\n" % e)
 api_instance = ElectronApi::CardApi.new
 nucleus_client_id = "182d8546-05fb-4286-b7fe-e3ec8a9c9a46";
 card_client_request_co = ElectronApi::CardClientRequestCO.new
 card_client_request_co.nucleus_client_id =nucleus_client_id
begin
  result = api_instance.create_client_card_using_post(card_client_request_co)
  p result
rescue ElectronApi::ApiError => e
  p e.response_body
  puts "Exception when calling CardApi->create_client_card_using_post: #{e}"
end
CardApi apiInstance = new CardApi();
UUID nucleusClientID = UUID.fromString("182d8546-05fb-4286-b7fe-e3ec8a9c9a46");

 try {
       CardClientRequestCO cardClientRequestCO = new CardClientRequestCO();
       cardClientRequestCO.setNucleusClientId(nucleusClientID);
       CreateCardClientResponseVO result = apiInstance.createClientCardUsingPost(cardClientRequestCO);
       System.out.println(result);
   } catch (ApiException e) {
       System.err.println("Exception when calling CardApi#createClientCardUsingPost");
       System.out.println(e.getResponseBody());
       System.out.println(e.getCode());
   }
var api = new HydrogenElectronApi.CardApi()
var nucleusClientID = "182d8546-05fb-4286-b7fe-e3ec8a9c9a46";
var cardClientRequestCO = new HydrogenElectronApi.CardClientRequestCO();
    cardClientRequestCO.nucleus_client_id = nucleusClientID;

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

api.createClientCardUsingPost(cardClientRequestCO, callback);
$client = new GuzzleHttp\Client();
$apiInstance = new com\hydrogen\electron\Api\CardApi($client, $config);
$nucleusClientId = "182d8546-05fb-4286-b7fe-e3ec8a9c9a46";

$cardClientRequestCo = new \com\hydrogen\electron\Model\CardClientRequestCO();
$cardClientRequestCo->setNucleusClientId($nucleusClientId);
try {
    $result = $apiInstance->createClientCardUsingPost($cardClientRequestCo);
    print_r($result);
} catch (\com\hydrogen\electron\ApiException $e) {
    echo 'Exception when calling CardApi->createClientCardUsingPost: ', $e->getResponseBody(), PHP_EOL;
}

Example Response

{
  "message": "Success",
  "status": "ACTIVE",
  "nucleus_client_id": "5f8c6b1b-c032-4fff-9d4f-e0cd3ec6291",
  "vendor_name": "Marqeta",
  "vendor_response": {
      "token": "cbe791f8-822d-4dae-9b9d-b6177a4e9baf",
        "active": true,
        "first_name": "Joe",
        "last_name": "Smith",
        "uses_parent_account": false,
        "corporate_card_holder": false,
        "created_time": "2020-11-27T13:49:32Z",
        "last_modified_time": "2020-11-27T13:49:33Z",
        "metadata": {},
        "account_holder_group_token": "kyc_never",
        "status": "ACTIVE",
        "deposit_account": {
            "token": "0c1a4443-515b-4d52-8068-07cba0b3efc6",
            "account_number": "40011180010578931",
            "routing_number": "293748000",
            "allow_immediate_credit": false
        }
   }
}

ARGUMENTS

Parameter Type Required Description
nucleus_client_id UUID required The ID of the client that will be submitted to the back office

RESPONSE

Parameter Description
message Message related to whether the client was created successfully by the back office
status Status of client creation in back office
nucleus_client_id The client ID from the request
vendor_name Vendor’s name
vendor_response Vendor’s response

Update an individual card client

This service is used to update client information. Note that clients are only required for certain card programs.

HTTP REQUEST

PUT /card/client/{nucleus_client_id}

Example Request

curl -X PUT -H "Authorization: Bearer <access_token>" \
    -H "Content-Type: application/json" \
    -d '{
        }' "https://api.hydrogenplatform.com/electron/v1/card/client/5f8c6b1b-c032-4fff-9d4f-e0cd3ec6291"
    api_instance = electron_api.CardApi(electron_api.ApiClient(configuration))

try:
    api_response = api_instance.update_client_card_using_put(id='d1ce4937-180b-47f4-b95d-7e972fbf160a')
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CardApi->update_client_card_using_put: %s\n" % e)
 api_instance = ElectronApi::CardApi.new
 nucleus_client_id = "182d8546-05fb-4286-b7fe-e3ec8a9c9a46";
begin
  result = api_instance.update_client_card_using_put(nucleus_client_id)
  p result
rescue ElectronApi::ApiError => e
  p e.response_body
  puts "Exception when calling CardApi->update_client_card_using_put: #{e}"
end
 CardApi apiInstance = new CardApi();
 UUID nucleusClientID = UUID.fromString("182d8546-05fb-4286-b7fe-e3ec8a9c9a46");

try {
      UpdateCardClientResponseVO result = apiInstance.updateClientCardUsingPut(nucleusClientID);
      System.out.println(result);
  } catch (ApiException e) {
      System.err.println("Exception when calling CardApi#updateClientCardUsingPut");
      System.out.println(e.getResponseBody());
      System.out.println(e.getCode());
  }
var api = new HydrogenElectronApi.CardApi()
var nucleusClientID = "182d8546-05fb-4286-b7fe-e3ec8a9c9a46";

var callback = function(error, data, response) {
  if (error) {
      console.error(error);
  } else {
      console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateClientCardUsingPut(nucleusClientID, callback);
$client = new GuzzleHttp\Client();
$apiInstance = new com\hydrogen\electron\Api\CardApi($client, $config);
$nucleusClientId = "182d8546-05fb-4286-b7fe-e3ec8a9c9a46";

try {
    $result = $apiInstance->updateClientCardUsingPut($nucleusClientId);
    print_r($result);
} catch (\com\hydrogen\electron\ApiException $e) {
    echo 'Exception when calling CardApi->updateClientCardUsingPut: ', $e->getResponseBody(), PHP_EOL;
}

Example Response

{
  "message": "Success",
  "nucleus_client_id": "5f8c6b1b-c032-4fff-9d4f-e0cd3ec6291",
  "vendor_name": "Marqeta",
  "vendor_request_data": {
    "first_name": "Joe",
    "last_name": "Smith",
    "middle_name": "Bob",
    "date_of_birth": "1950-01-01",
    "phone_number": "+15105551212",
    "email": "test@mail.com",
    "address": [
        {
            "address_line1": "100 Peach Drivee",
            "address_line2": null,
            "city": "Atlanta",
            "is_primary": true,
            "postalcode": "30301",
            "country": "US",
            "state": "GA",
            "type": "mailing"
        }
     ]
  },
  "vendor_response": {
        "token": "80356664-87ef-4ed5-8204-c3526aed7d01",
        "active": true,
        "gender": null,
        "first_name": "Joe",
        "last_name": "Bob",
        "middle_name": "Smith",
        "email": "test@mail.com",
        "address_line1": "100 Peach Drivee",
        "address_line2": null,
        "city": "Atlanta",
        "state": "GA",
        "country": "US",
        "zip": "30301",
        "phone": "+15105551212",
        "uses_parent_account": false,
        "password": null,
        "created_time": "2020-07-10T12:16:06Z",
        "last_modified_time": "2020-08-07T07:31:40Z",
        "metadata": {},
        "account_holder_group_token": "DEFAULT_AHG",
        "status": "ACTIVE",
        "deposit_account": null,
        "birth_date": "1950-01-01",
        "honorific": null,
        "company": null,
        "ssn": "___________"
    }
}

ARGUMENTS

Parameter Type Required Description
nucleus_client_id UUID required The ID of the client that will be submitted to the back office

RESPONSE

Parameter Description
message Message related to whether the client was update successfully by the back office
nucleus_client_id Client ID from the request
vendor_name Vendor’s name
vendor_request_data Details that were updated
vendor_response Vendor’s response

Card Operations

Issue a card

This service is used to issue a card at the bank. All the information for the creation of the card should be defined in nucleus_card_id. If the card is created successfully, the card details such as the mask and expiration date will be stored in Nucleus.

HTTP REQUEST

POST /card/issue

Example Request

curl -X POST -H "Authorization: Bearer <access_token>" \
    -H "Content-Type: application/json" \
    -d '{
            "nucleus_card_id": "5f8c6b1b-c032-4fff-9d4f-e0cd3ec6291"
        }' "https://api.hydrogenplatform.com/electron/v1/card/issue"
    api_instance = electron_api.CardApi(electron_api.ApiClient(configuration))
    nucleus_card_id='7cf558a5-bb99-40b7-9a20-8f095bfcb9ea';
    card_base_request_co = electron_api.CardBaseRequestCO(nucleus_card_id=nucleus_card_id);
try:
    api_response = api_instance.create_card_issue_using_post(card_base_request_co)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CardApi->create_card_issue_using_post: %s\n" % e)
 api_instance = ElectronApi::CardApi.new
 nucleus_card_id = "7cf558a5-bb99-40b7-9a20-8f095bfcb9ea";
 card_base_request_co = ElectronApi::CardBaseRequestCO.new
 card_base_request_co.nucleus_card_id = nucleus_card_id;

begin
  result = api_instance.create_card_issue_using_post(card_base_request_co)
  p result
rescue ElectronApi::ApiError => e
  p e.response_body
  puts "Exception when calling CardApi->create_card_issue_using_post: #{e}"
end
 CardApi apiInstance = new CardApi();
 UUID nucleusCardID = UUID.fromString("7cf558a5-bb99-40b7-9a20-8f095bfcb9ea");
 CardBaseRequestCO cardBaseRequestCO = new CardBaseRequestCO();
cardBaseRequestCO.setNucleusCardId(nucleusCardID);

  try {
        BaseResponseVO result = apiInstance.createCardIssueUsingPost(cardBaseRequestCO);
        System.out.println(result);
    } catch (ApiException e) {
        System.err.println("Exception when calling CardApi#createCardIssueUsingPost");
        System.out.println(e.getResponseBody());
        System.out.println(e.getCode());
    }
var api = new HydrogenElectronApi.CardApi()
var nucleusCardID = "7cf558a5-bb99-40b7-9a20-8f095bfcb9ea";
var cardBaseRequestCO = new HydrogenElectronApi.CardBaseRequestCO()
    cardBaseRequestCO.nucleus_card_id = nucleusCardID;

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

api.createCardIssueUsingPost(cardBaseRequestCO, callback);
$client = new GuzzleHttp\Client();
$apiInstance = new com\hydrogen\electron\Api\CardApi($client, $config);
$nucleusCardId = "7cf558a5-bb99-40b7-9a20-8f095bfcb9ea";

$cardBaseRequestCO = new \com\hydrogen\electron\Model\CardBaseRequestCO();
$cardBaseRequestCO->setNucleusCardId($nucleusCardId);
try {
    $result = $apiInstance->createCardIssueUsingPost($cardBaseRequestCO);
    print_r($result);
} catch (\com\hydrogen\electron\ApiException $e) {
    echo 'Exception when calling CardApi->createCardIssueUsingPost: ', $e->getResponseBody(), PHP_EOL;
}

Example Response

{
  "message": "Success",
  "nucleus_card_id": "5f8c6b1b-c032-4fff-9d4f-e0cd3ec6291",
  "card_status": "pending",
  "vendor_name": "Marqeta",
  "vendor_response": {ommitted due to length}
}

ARGUMENTS

Parameter Type Required Description
nucleus_card_id UUID required The ID of the card that will be submitted to the back office

RESPONSE

Parameter Description
message Message related to whether the card was issued successfully by the back office
nucleus_card_id The card ID from the request
card_status Status of the card. It can be one of the following: pending, issued, activated, suspended, closed, other
vendor_name Vendor’s name
vendor_response Vendor’s response

Suspend a card

This service is used to suspend/freeze a card. A reason for suspension of the card is required.

HTTP REQUEST

POST /card/suspend

Example Request

curl -X POST -H "Authorization: Bearer <access_token>" \
    -H "Content-Type: application/json" \
    -d '{
            "nucleus_card_id": "5f8c6b1b-c032-4fff-9d4f-e0cd3ec6291",
            "reason":"Lost"
        }' "https://api.hydrogenplatform.com/electron/v1/card/suspend"
    api_instance = electron_api.CardApi(electron_api.ApiClient(configuration))
      nucleus_card_id='7cf558a5-bb99-40b7-9a20-8f095bfcb9ea';
      card_suspend_request_co = electron_api.CardBaseRequestCO(
      nucleus_card_id=nucleus_card_id,
      reason="Lost"
    );
try:
    api_response = api_instance.create_card_suspend_using_post(card_suspend_request_co)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CardApi->create_card_suspend_using_post: %s\n" % e)
 api_instance = ElectronApi::CardApi.new
 nucleus_card_id = "7cf558a5-bb99-40b7-9a20-8f095bfcb9ea";

 card_suspend_request_co = ElectronApi::CardBaseRequestCO.new
 card_suspend_request_co.nucleus_card_id = nucleus_card_id
 card_suspend_request_co.reason = 'Lost'

begin
  result = api_instance.create_card_suspend_using_post(card_suspend_request_co)
  p result
rescue ElectronApi::ApiError => e
  p e.response_body
  puts "Exception when calling CardApi->create_card_suspend_using_post: #{e}"
end
 CardApi apiInstance = new CardApi();
 UUID nucleusCardID = UUID.fromString("7cf558a5-bb99-40b7-9a20-8f095bfcb9ea");
 CardBaseRequestCO cardBaseRequestCO = new CardBaseRequestCO();
 cardBaseRequestCO.setNucleusCardId(nucleusCardID);
 cardBaseRequestCO.setReason("Lost");

try {
    BaseResponseVO result = apiInstance.createCardSuspendUsingPost(cardBaseRequestCO);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling CardApi#createCardSuspendUsingPost");
    System.out.println(e.getResponseBody());
    System.out.println(e.getCode());
}
var api = new HydrogenElectronApi.CardApi()
var nucleusCardID = "7cf558a5-bb99-40b7-9a20-8f095bfcb9ea";
var cardBaseRequestCO = new HydrogenElectronApi.CardBaseRequestCO()
    cardBaseRequestCO.nucleus_card_id = nucleusCardID;
    cardBaseRequestCO.reason = "Lost"

var callback = function(error, data, response) {
  if (error) {
      console.error(error);
  } else {
      console.log('API called successfully. Returned data: ' + data);
  }
};
api.createCardSuspendUsingPost(cardBaseRequestCO, callback);
$client = new GuzzleHttp\Client();
$apiInstance = new com\hydrogen\electron\Api\CardApi($client, $config);
$nucleusCardId = "7cf558a5-bb99-40b7-9a20-8f095bfcb9ea";

$cardSuspendRequestCO = new \com\hydrogen\electron\Model\CardBaseRequestCO();
$cardSuspendRequestCO->setNucleusCardId($nucleusCardId);
$cardSuspendRequestCO->setReason("Lost");
try {
    $result = $apiInstance->createCardSuspendUsingPost($cardSuspendRequestCO);
    print_r($result);
} catch (\com\hydrogen\electron\ApiException $e) {
    echo 'Exception when calling CardApi->createCardSuspendUsingPost: ', $e->getResponseBody(), PHP_EOL;
}

Example Response

{
  "message": "Success",
  "nucleus_card_id": "5f8c6b1b-c032-4fff-9d4f-e0cd3ec6291",
  "card_status": "suspended",
  "vendor_name": "EML",
  "vendor_response": {}
}

ARGUMENTS

Parameter Type Required Description
nucleus_card_id UUID required The ID of the card that will be submitted to the back office
reason string required, conditional Reason why the card is being suspended. Please ask us for applicable values if you require this API.

RESPONSE

Parameter Description
message Message from the back office: ‘success’ if the suspension was successful, ‘failed:{Error Message}’ otherwise
nucleus_card_id The card ID from the request
card_status suspended if the card has been suspended, else current status
vendor_name Vendor’s name
vendor_response Vendor’s response

Reactivate a card

This service is used to reactivate a suspended/frozen card.

HTTP REQUEST

POST /card/reactivate

Example Request

curl -X POST -H "Authorization: Bearer <access_token>" \
    -H "Content-Type: application/json" \
    -d '{
            "nucleus_card_id": "5f8c6b1b-c032-4fff-9d4f-e0cd3ec6291",
            "reason":"01"
        }' "https://api.hydrogenplatform.com/electron/v1/card/reactivate"
    api_instance = electron_api.CardApi(electron_api.ApiClient(configuration))
      nucleus_card_id='7cf558a5-bb99-40b7-9a20-8f095bfcb9ea'
      card_reactivate_request_co = electron_api.CardBaseRequestCO(
      nucleus_card_id=nucleus_card_id,
      reason="01"
    );
try:
    api_response = api_instance.create_card_reactivate_using_post(card_reactivate_request_co)
    pprint(api_response)
    except ApiException as e:
    print("Exception when calling CardApi->create_card_reactivate_using_post: %s\n" % e)
 api_instance = ElectronApi::CardApi.new
 nucleus_card_id = "7cf558a5-bb99-40b7-9a20-8f095bfcb9ea";

 card_reactivate_request_co = ElectronApi::CardBaseRequestCO.new
 card_reactivate_request_co.nucleus_card_id = nucleus_card_id
 card_reactivate_request_co.reason = '01'

begin
  result = api_instance.create_card_reactivate_using_post(card_reactivate_request_co)
  p result
rescue ElectronApi::ApiError => e
  p e.response_body
  puts "Exception when calling CardApi->create_card_reactivate_using_post: #{e}"
end
CardApi apiInstance = new CardApi();
UUID nucleusCardID = UUID.fromString("7cf558a5-bb99-40b7-9a20-8f095bfcb9ea");
 CardBaseRequestCO cardBaseRequestCO = new CardBaseRequestCO();
 cardBaseRequestCO.setNucleusCardId(nucleusCardID);
 cardBaseRequestCO.setReason("01");

 try {
     BaseResponseVO result = apiInstance.createCardReactivateUsingPost(cardBaseRequestCO);
     System.out.println(result);
 } catch (ApiException e) {
     System.err.println("Exception when calling CardApi#createCardReactivateUsingPost");
     System.out.println(e.getResponseBody());
     System.out.println(e.getCode());
 }
var api = new HydrogenElectronApi.CardApi()
var nucleusCardID = "7cf558a5-bb99-40b7-9a20-8f095bfcb9ea";
var cardBaseRequestCO = new HydrogenElectronApi.CardBaseRequestCO()
    cardBaseRequestCO.nucleus_card_id = nucleusCardID;
    cardBaseRequestCO.reason = "01"

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

api.createCardReactivateUsingPost(cardBaseRequestCO, callback);
$client = new GuzzleHttp\Client();
$apiInstance = new com\hydrogen\electron\Api\CardApi($client, $config);
$nucleusCardId = "7cf558a5-bb99-40b7-9a20-8f095bfcb9ea";

$cardReactivateRequestCO = new \com\hydrogen\electron\Model\CardBaseRequestCO();
$cardReactivateRequestCO->setNucleusCardId($nucleusCardId);
$cardReactivateRequestCO->setReason("01");
try {
    $result = $apiInstance->createCardReactivateUsingPost($cardReactivateRequestCO);
    print_r($result);
} catch (\com\hydrogen\electron\ApiException $e) {
    echo 'Exception when calling CardApi->createCardReactivateUsingPost: ', $e->getResponseBody(), PHP_EOL;
}

Example Response

{
  "message": "Success",
  "nucleus_card_id": "5f8c6b1b-c032-4fff-9d4f-e0cd3ec6291",
  "card_status": "activated",
  "vendor_name": "Marqeta",
  "vendor_response": {
        "token": "449f849a-d4de-455a-8a7a-99b333ef19dc",
        "card_token": "35c791e8-97ff-4751-8489-87265580ccab",
        "user_token": "a1bad6b1-c3b7-48e5-87ea-ff6a881db724",
        "state": "ACTIVE",
        "reason": "ReInstated",
        "reason_code": "01",
        "channel": "API",
        "fulfillment_status": "ISSUED",
        "validations": {
            "user": {
                "birth_date": false,
                "phone": false,
                "ssn": false,
                "random_name_line1_postfix": false
            }
        },
        "type": "state.reinstated",
        "created_time": "2020-12-09T07:04:15Z",
        "card_product_token": "fc74ff1c-90c4-4485-b0e0-90b252e0192c",
        "last_four": "4723",
        "pan": "111111______4723",
        "expiration": "1224",
        "expiration_time": "2024-12-31T23:59:59.000Z",
        "barcode": "28000054612000532039",
        "pin_is_set": false,
        "fulfillment": {
            "shipping": {
                "recipient_address": {
                    "first_name": "Minnie",
                    "last_name": "Hettinger",
                    "address1": "3 Downtown Street",
                    "city": "New York",
                    "state": "NY",
                    "zip": "123457",
                    "country": "US",
                    "phone": "5555751234",
                    "postal_code": "123457"
                }
            }
        },
        "user": {
            "metadata": {}
        },
        "card": {
            "metadata": {}
        }
    }
}

ARGUMENTS

Parameter Type Required Description
nucleus_card_id UUID required The ID of the card that will be submitted to card vendor
reason string required, conditional Reason why the card is being reactivated. Please ask us for applicable values if you require this API.

RESPONSE

Parameter Description
message Message from the back office: ‘success’ if the reactivation was successful, ‘failed:{Error Message}’ otherwise
nucleus_card_id The card ID from the request
card_status activated if the card has been reactivated, else current status
vendor_name Vendor’s name
vendor_response Vendor’s response

Close a card

This service is used to close a card. This action cannot be undone. For temporary suspension, please use the POST /card/suspend call instead.

HTTP REQUEST

POST /card/close

Example Request

curl -X POST -H "Authorization: Bearer <access_token>" \
    -H "Content-Type: application/json" \
    -d '{
            "nucleus_card_id": "5f8c6b1b-c032-4fff-9d4f-e0cd3ec6291",
        "reason":"Closed Account"
        }' "https://api.hydrogenplatform.com/electron/v1/card/close"
    api_instance = electron_api.CardApi(electron_api.ApiClient(configuration))
    nucleus_card_id='7cf558a5-bb99-40b7-9a20-8f095bfcb9ea';
    card_close_request_co = electron_api.CardBaseRequestCO(
      nucleus_card_id=nucleus_card_id
    );
try:
    api_response = api_instance.create_card_close_using_post(card_close_request_co)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CardApi->create_card_close_using_post: %s\n" % e)
 api_instance = ElectronApi::CardApi.new
 nucleus_card_id = "8890e5da-5742-436e-b7f6-e335125ec98f"

 card_close_request_co = ElectronApi::CardBaseRequestCO.new
 card_close_request_co.nucleus_card_id = nucleus_card_id
begin
  result = api_instance.create_card_close_using_post(card_close_request_co)
  p result
rescue ElectronApi::ApiError => e
  p e.response_body
  puts "Exception when calling CardApi->create_card_close_using_post: #{e}"
end
CardApi apiInstance = new CardApi();
UUID nucleusCardID = UUID.fromString("7cf558a5-bb99-40b7-9a20-8f095bfcb9ea");
CardBaseRequestCO cardBaseRequestCO = new CardBaseRequestCO();
cardBaseRequestCO.setNucleusCardId(nucleusCardID);

 try {
     BaseResponseVO result = apiInstance.createCardCloseUsingPost(cardBaseRequestCO);
     System.out.println(result);
 } catch (ApiException e) {
     System.err.println("Exception when calling CardApi#createCardCloseUsingPost");
     System.out.println(e.getResponseBody());
     System.out.println(e.getCode());
 }
var api = new HydrogenElectronApi.CardApi()
var nucleusCardID = "7cf558a5-bb99-40b7-9a20-8f095bfcb9ea";
var cardBaseRequestCO = new HydrogenElectronApi.CardBaseRequestCO()
    cardBaseRequestCO.nucleus_card_id = nucleusCardID;

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

api.createCardCloseUsingPost(cardBaseRequestCO, callback);
$client = new GuzzleHttp\Client();
$apiInstance = new com\hydrogen\electron\Api\CardApi($client, $config);
$nucleusCardId = "7cf558a5-bb99-40b7-9a20-8f095bfcb9ea";

$cardCloseRequestCO = new \com\hydrogen\electron\Model\CardBaseRequestCO();
$cardCloseRequestCO->setNucleusCardId($nucleusCardId);
try {
    $result = $apiInstance->createCardCloseUsingPost($cardCloseRequestCO);
    print_r($result);
} catch (\com\hydrogen\electron\ApiException $e) {
    echo 'Exception when calling CardApi->createCardCloseUsingPost: ', $e->getResponseBody(), PHP_EOL;
}

Example Response

{
  "message": "Success",
  "nucleus_card_id": "5f8c6b1b-c032-4fff-9d4f-e0cd3ec6291",
  "card_status": "closed",
  "vendor_name": "EML",
  "vendor_response": {}
}

ARGUMENTS

Parameter Type Required Description
nucleus_card_id UUID required The ID of the card that will be submitted to the back office
reason string required, conditional The reason for closing the card. Please ask us for applicable values if you require this API.

RESPONSE

Parameter Description
message Message from the back office: ‘success’ if the closure was successful, ‘failed:{Error Message}’ otherwise
nucleus_card_id The card ID from the request
card_status Returns closed if the card has been closed, otherwise returns current card status
vendor_name Vendor’s name
vendor_response Vendor’s response

Replace a card

This service is used to replace a card and transfer the balance to the new card.

HTTP REQUEST

POST /card/replace

Example Request

curl -X POST -H "Authorization: Bearer <access_token>" \
    -H "Content-Type: application/json" \
    -d '{
          "nucleus_card_id": "5f8c6b1b-c032-4fff-9d4f-e0cd3ec6291",
          "reason":"Card Stolen",
          "vendor_request": {
            "location": "New York"
          }
        }' "https://api.hydrogenplatform.com/electron/v1/card/replace"
    api_instance = electron_api.CardApi(electron_api.ApiClient(configuration))
    nucleus_card_id='7cf558a5-bb99-40b7-9a20-8f095bfcb9ea';
    card_replace_request_co = electron_api.CardBaseRequestCO(
      nucleus_card_id=nucleus_card_id,
      vendor_request={"location": "test"}
    );
try:
    api_response = api_instance.create_card_replace_using_post(card_replace_request_co)
    pprint(api_response)
    except ApiException as e:
    print("Exception when calling CardApi->create_card_replace_using_post: %s\n" % e)
 api_instance = ElectronApi::CardApi.new
 nucleus_card_id = "7cf558a5-bb99-40b7-9a20-8f095bfcb9ea";

 card_replace_request_co = ElectronApi::CardBaseRequestCO.new
 card_replace_request_co.nucleus_card_id = nucleus_card_id
 card_replace_request_co.vendor_request = {location: "test"}
begin
  result = api_instance.create_card_replace_using_post(card_replace_request_co)
  p result
rescue ElectronApi::ApiError => e
  p e.response_body
  puts "Exception when calling CardApi->create_card_replace_using_post: #{e}"
end
CardApi apiInstance = new CardApi();
UUID nucleusCardID = UUID.fromString("7cf558a5-bb99-40b7-9a20-8f095bfcb9ea");
CardBaseRequestCO cardBaseRequestCO = new CardBaseRequestCO();
Map<String, String> location = new HashMap<>();
Map<String, String> vendorRequest = new HashMap<>();

 location.put("address_line1" , "street1");
 vendorRequest.put("location" , "location");
 cardBaseRequestCO.setNucleusCardId(nucleusCardID);
 cardBaseRequestCO.setVendorRequest(vendorRequest);

 try {
     CardReplaceResponseVO result = apiInstance.createCardReplaceUsingPost(cardBaseRequestCO);
     System.out.println(result);
 } catch (ApiException e) {
     System.err.println("Exception when calling CardApi#createCardReplaceUsingPost");
     System.out.println(e.getResponseBody());
     System.out.println(e.getCode());
 }
var api = new HydrogenElectronApi.CardApi()
var nucleusCardID = "7cf558a5-bb99-40b7-9a20-8f095bfcb9ea";
var cardBaseRequestCO = new HydrogenElectronApi.CardBaseRequestCO();
var locationMap = new Map();
    locationMap['address_line1'] = "Street 1";
var vendorRequest = new Map();
    vendorRequest['location'] = locationMap;

    cardBaseRequestCO.nucleus_card_id = nucleusCardID;
    cardBaseRequestCO.vendor_request = vendorRequest;

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

api.createCardReplaceUsingPost(cardBaseRequestCO, callback);
$client = new GuzzleHttp\Client();
$apiInstance = new com\hydrogen\electron\Api\CardApi($client, $config);
$nucleusCardId = "7cf558a5-bb99-40b7-9a20-8f095bfcb9ea";

$cardReplaceRequestCO = new \com\hydrogen\electron\Model\CardBaseRequestCO();
$cardReplaceRequestCO->setNucleusCardId($nucleusCardId);
$vendorRequest = new stdClass();
$vendorRequest->location = 'test';
$cardReplaceRequestCO->setVendorRequest($vendorRequest);
try {
    $result = $apiInstance->createCardReplaceUsingPost($cardReplaceRequestCO);
    print_r($result);
} catch (\com\hydrogen\electron\ApiException $e) {
    echo 'Exception when calling CardApi->createCardReplaceUsingPost: ', $e->getResponseBody(), PHP_EOL;
}

Example Response

{
  "message": "Success",
  "replaced_nucleus_card_id": "59b16ac9-6e49-4210-aab9-ddc8001ce9a5",
  "new_nucleus_card_id": "59b16ac9-6e49-4210-aab9-ddc8001ce9a5",
  "vendor_name": "EML",
  "vendor_response": {
    "card_id": 0,
    "id": "LFF9S5X5BZDDSHH7",
    "client_tracking_id": "6e4b1e82-42ac-46a9-996a-9bd59985c19d",
    "available_balance": 20.00,
    "currency": "USD",
    "actual_balance": 20.00,
    "activation_amount": 0.00,
    "program_supports_statements": false,
    "program_3ds_enabled": false,
    "amf_amount": 0.00,
    "adjusted_balance": 20.00,
    "is_icc_card": false,
    "has_atm_access": true
  }
}

ARGUMENTS

Parameter Type Required Description
nucleus_card_id UUID required The ID of the card that will be submitted to the back office
reason string required, conditional Reason for replacement. Please ask us for applicable values if you require this API.
vendor_request object required, conditional Additional request parameters required for some use cases. Please ask us for applicable request if you require this API.

RESPONSE

Parameter Description
message Message from the back office: ‘success’ if the replacement was successful, ‘failed:{Error Message}’ otherwise
replaced_nucleus_card_id The card ID from the request
new_nucleus_card_id The new card ID
vendor_name Vendor’s name
vendor_response Vendor’s response

Deposit

These services perform back office operations on the Hydrogen Deposit product.

Card Funding

Get card reserve balance

This service is used to get the total reserve balance for your business. This should be used in conjunction with POST /card/load so you know how much money you currently have to load.

HTTP REQUEST

GET /card/reserve

Example Request

curl -X GET -H "Authorization: Bearer <access_token>" \
    -H "Content-Type: application/json" \
    -d '{
        }' "https://api.hydrogenplatform.com/electron/v1/card/reserve"
api_instance = electron_api.CardApi(electron_api.ApiClient(configuration))

try:
    api_response = api_instance.get_card_reserve_account_details_using_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CardApi->get_card_reserve_account_details_using_get: %s\n" % e)
 api_instance = ElectronApi::CardApi.new
begin
  result = api_instance.get_card_reserve_account_details_using_get()
  p result
rescue ElectronApi::ApiError => e
  p e.response_body
  puts "Exception when calling CardApi->get_card_reserve_account_details_using_get: #{e}"
end
CardApi apiInstance = new CardApi();

try {
      CardReserveAccountResponseVO result = apiInstance.getCardReserveAccountDetailsUsingGet();
      System.out.println(result);
  } catch (ApiException e) {
      System.err.println("Exception when calling CardApi#getCardReserveAccountDetailsUsingGet");
      System.out.println(e.getResponseBody());
      System.out.println(e.getCode());
  }
var api = new HydrogenElectronApi.CardApi()

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

api.getCardReserveAccountDetailsUsingGet(callback);
$client = new GuzzleHttp\Client();
$apiInstance = new com\hydrogen\electron\Api\CardApi($client, $config);

try {
    $result = $apiInstance->getCardReserveAccountDetailsUsingGet();
    print_r($result);
} catch (\com\hydrogen\electron\ApiException $e) {
    echo 'Exception when calling CardApi->getCardReserveAccountDetailsUsingGet: ', $e->getResponseBody(), PHP_EOL;
}

Example Response

{
  "message": "Success",
  "vendor_name": "EML",
  "wallet_id": "1111",
  "balance": 1500,
  "balance_available": 1450,
  "overdraft_limit": 50
}

RESPONSE

Parameter Description
message Message from the back office: ‘success’ if the reserve balance request was successful, ‘failed:{Error Message}’ otherwise
vendor_name Vendor’s name
wallet_id Wallet ID
balance Total reserve balance
balance_available Available reserve balance
overdraft_limit Overdraft limit

Load a card

This service is used to load funds onto a debit card from the reserve account balance. A Nucleus funding request must first be created with the following data:

HTTP REQUEST

POST /card/load

Example Request

curl -X POST -H "Authorization: Bearer <access_token>" \
    -H "Content-Type: application/json" \
    -d '{
            "nucleus_funding_id": "95719c40-ec63-4c4d-9503-3a9815fd9d24"
        }' "https://api.hydrogenplatform.com/electron/v1/card/load"
    api_instance = electron_api.CardApi(electron_api.ApiClient(configuration))
    card_load_request_co = electron_api.CardLoadRequestCO(
      nucleus_funding_id='135e974f-ff06-4607-af7c-880d28f91d0a'
    );
try:
    api_response = api_instance.create_card_load_using_post(card_load_request_co)
    pprint(api_response)
  except ApiException as e:
    print("Exception when calling CardApi->create_card_load_using_post: %s\n" % e)
 api_instance = ElectronApi::CardApi.new
 nucleus_funding_id = "135e974f-ff06-4607-af7c-880d28f91d0a";

 card_load_request_co = ElectronApi::CardLoadRequestCO.new
 card_load_request_co.nucleus_funding_id = nucleus_funding_id
begin
  result = api_instance.create_card_load_using_post(card_load_request_co)
  p result
rescue ElectronApi::ApiError => e
  p e.response_body
  puts "Exception when calling CardApi->create_card_load_using_post: #{e}"
end
CardApi apiInstance = new CardApi();
UUID nucleusFundingID = UUID.fromString("135e974f-ff06-4607-af7c-880d28f91d0a");
CardLoadRequestCO cardLoadRequestCO = new CardLoadRequestCO();
cardLoadRequestCO.setNucleusFundingId(nucleusFundingID);

 try {
       CardLoadUnloadResponseVO result = apiInstance.createCardLoadUsingPost(cardLoadRequestCO);
       System.out.println(result);
   } catch (ApiException e) {
       System.err.println("Exception when calling CardApi#createCardLoadUsingPost");
       System.out.println(e.getResponseBody());
       System.out.println(e.getCode());
   }
var api = new HydrogenElectronApi.CardApi()
var nucleusFundingID = "135e974f-ff06-4607-af7c-880d28f91d0a";
var cardLoadRequestCO = new HydrogenElectronApi.CardLoadRequestCO()
    cardLoadRequestCO.nucleus_funding_id = nucleusFundingID;

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

api.createCardLoadUsingPost(cardLoadRequestCO, callback);
$client = new GuzzleHttp\Client();
$apiInstance = new com\hydrogen\electron\Api\CardApi($client, $config);
$nucleusFundingId = "135e974f-ff06-4607-af7c-880d28f91d0a";

$cardLoadRequestCO = new \com\hydrogen\electron\Model\CardLoadRequestCO();
$cardLoadRequestCO->setNucleusFundingId($nucleusFundingId);
try {
    $result = $apiInstance->createCardLoadUsingPost($cardUpdatePinRequestCO);
    print_r($result);
} catch (\com\hydrogen\electron\ApiException $e) {
    echo 'Exception when calling CardApi->createCardLoadUsingPost: ', $e->getResponseBody(), PHP_EOL;
}

Example Response

{
  "message": "Success",
  "nucleus_card_id": "12e4cc85-9065-478b-8c14-5f7dbc290d83",
  "nucleus_funding_id": "95719c40-ec63-4c4d-9503-3a9815fd9d24",
  "amount": 10.0,
  "vendor_name": "EML Payments",
  "vendor_response": {
    "currency": "USD",
    "available_balance": 10.0,
    "system_transaction_id": 1583594,
    "adjusted_balance": 10.0
  }
}

ARGUMENTS

Parameter Type Required Description
nucleus_funding_id UUID required The ID of the funding request

RESPONSE

Parameter Description
message Message from the back office: ‘success’ if the load was successful, ‘failed:{Error Message}’ otherwise
nucleus_card_id The card ID from the requested funding ID
nucleus_funding_id The funding ID from the request
amount Amount that was loaded
vendor_name Vendor’s name
vendor_response Vendor’s response

ACH

Hydrogen supports money transfers between US bank accounts which are executed on the ACH (Automated Clearing House) network.

Create an ACH card transfer

Example Request

curl -X POST -H "Authorization: Bearer <access_token>" \
    -H "Content-Type: application/json" \
    -d '{
            "nucleus_funding_id": "51dcb222-11d4-4b3f-bdbc-4124840bac90"
        }' "https://api.hydrogenplatform.com/electron/v1/ach/card"





Example Response

{
  "message": "Success",
  "nucleus_funding_id": "266faabc-f77b-4e0b-b04c-aee660705a45",
  "status": "initiated",
  "vendor_name": "Dwolla",
  "vendor_response": {
    "location": "https://api.dwolla.com/transfers/65b3ef2f-fbf4-eb11-8136-b0300d0c7e2a"
  }
}

Initiate and submit an ACH transfer to a card from a linked bank account. This service will accept a Nucleus funding request with the following constraints:

HTTP REQUEST

POST /ach/card

ARGUMENTS

Parameter Type Required Description
nucleus_funding_id UUID required The ID of the funding request

RESPONSE

Parameter Description
message Status of ACH transfer request. Values are either Success or Failed: {Error Message}
nucleus_funding_id The ID of the funding request
status The status of the transfer. Value may be initiated, declined, completed, cancelled, received, processing
vendor_name Vendor’s name
vendor_response Vendor’s response

Reward

There are no API services required to perform back office operations on the Hydrogen Reward product. All necessary operations are performed purely no-code through the Hydrogen Account Portal.

Spend

There are no API services required to perform back office operations on the Hydrogen Spend product.