Introduction

Authentication Base URL

https://[sandbox][api].hydrogenplatform.com/authorization/v1

Electron Base URL

https://[sandbox][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.

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:

• Adding new API resources.
• Adding new optional request parameters to existing API methods.
• Adding new fields to existing API responses.
• Changing the order of fields in existing API responses.
• Changing the length or format of objects

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://[sandbox][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://[sandbox][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://[sandbox][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": "[email protected]",
    "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": "[email protected]",
        "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://[sandbox][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://[sandbox][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://[sandbox][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://[sandbox][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://[sandbox][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://[sandbox][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:

• card_id is not null
• funding_type = “card_load”
• funding_status = “initiated”
• frequency_unit = “one_time”
• start_date = today’s date in “yyyy-mm-dd” format
• amount > 0
• is_deposit = true (deposit). Withdrawals are currently not allowed.

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://[sandbox][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://[sandbox][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:

• card_id is not null
• bank_link_id is not null
• funding_type = “bank_transfer”
• funding_status = “initiated”
• frequency_unit = “one_time”
• start_date = today’s date in “yyyy-mm-dd” format
• amount > 0
• is_deposit = true (deposit). Withdrawals are currently not allowed.

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.