# Authentication
Source: https://docs.woodcore.co/api-reference/authentication
Guide to authentication and authorization of Woodcore API access
Woodcore has an AWS-like API structure so if you are familair with AWS access and secret key you will this process even more descriptive but if you dont, hang on tight.
First, you need to have or have done the following
* An employee creation completed
* A user account associated with the employee created - \[Allow API access]
* Have assigned requisite permissions on user
Then you create an API by clicking on the Generate API key inside the user profile.
Take note of the following
* You can only create an APi key to a user that has api access enabled
* You can only generate two (2) api key per user
* You must provide an IP to be whitelisted. This may not be effective on sandbox but will be sure reject your request if they do not come from the whitelisted IP
Now you have your freshly baked API key and please remember to keep this super safe because it has every level of permision trusted on the base user on it, happy hacking! 🚀
```bash theme={null}
curl -X GET https://base_url/api/v1/clients \
-H "Authorization: Bearer wc_env_xxxxxxxxxxx"
```
## Asymmetric Authentication \[Recommended]
For enhanced security, Woodcore supports asymmetric authentication using RSA key pairs. This approach provides better security than simple API keys.
### Step 1: Generate Private Key
First, call the endpoint to generate your private key:
```bash theme={null}
curl -X POST https://api.woodcore.co/v2/gateway/generateKey \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_API_KEY"
```
**Important**: Store the private key securely as it will not be displayed again. This key is used to sign all your API requests.
### Step 2: Sign Your Messages
Use your private key to sign your request payload. Here are examples in different programming languages:
```javascript theme={null}
const crypto = require('crypto');
async function signRequest(payload, privateKey) {
const dataToSign = typeof payload === 'string' ? payload : JSON.stringify(payload);
const sign = crypto.createSign('RSA-SHA256');
sign.update(dataToSign);
const signature = sign.sign(privateKey, 'base64');
return signature;
}
// Example usage
const payload = {
name: "Cash at Office Vault",
glCode: "960F05F3FB39",
manualEntriesAllowed: true,
type: "asset",
parentId: "29",
usage: "header",
description: "Cash at Head office branch"
};
const signature = await signRequest(payload, privateKey);
const timestamp = new Date().getTime();
// API Request
const response = await fetch('https://api.woodcore.co/v2/endpoint', {
method: 'POST',
headers: {
'X-Signature': signature,
'X-Timestamp': timestamp,
'Content-Type': 'application/json'
},
body: JSON.stringify(payload)
});
```
```java theme={null}
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.util.Base64;
import com.fasterxml.jackson.databind.ObjectMapper;
public class WoodcoreAuth {
private static String signRequest(String payload, String privateKeyPEM) throws Exception {
// Remove PEM headers and decode
String privateKeyContent = privateKeyPEM
.replace("-----BEGIN PRIVATE KEY-----", "")
.replace("-----END PRIVATE KEY-----", "")
.replaceAll("\\s", "");
byte[] privateKeyBytes = Base64.getDecoder().decode(privateKeyContent);
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
// Sign the payload
Signature signature = Signature.getInstance("SHA256withRSA");
signature.initSign(privateKey);
signature.update(payload.getBytes("UTF-8"));
return Base64.getEncoder().encodeToString(signature.sign());
}
}
```
```python theme={null}
import base64
import json
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.backends import default_backend
def sign_request(payload, private_key_pem):
# Load private key
private_key = serialization.load_pem_private_key(
private_key_pem.encode(),
password=None,
backend=default_backend()
)
# Prepare data to sign
data_to_sign = json.dumps(payload) if isinstance(payload, dict) else payload
# Sign the data
signature = private_key.sign(
data_to_sign.encode(),
padding.PKCS1v15(),
hashes.SHA256()
)
return base64.b64encode(signature).decode()
# Example usage
payload = {
"name": "Cash at Office Vault",
"glCode": "960F05F3FB39",
"manualEntriesAllowed": True,
"type": "asset",
"parentId": "29",
"usage": "header",
"description": "Cash at Head office branch"
}
signature = sign_request(payload, private_key_pem)
timestamp = int(time.time() * 1000)
```
```go theme={null}
package main
import (
"crypto"
"crypto/rand"
"crypto/rsa"
"crypto/sha256"
"crypto/x509"
"encoding/base64"
"encoding/json"
"encoding/pem"
"fmt"
)
func signRequest(payload interface{}, privateKeyPEM string) (string, error) {
// Decode PEM block
block, _ := pem.Decode([]byte(privateKeyPEM))
if block == nil {
return "", fmt.Errorf("failed to decode PEM block")
}
// Parse private key
privateKey, err := x509.ParsePKCS8PrivateKey(block.Bytes)
if err != nil {
return "", err
}
rsaPrivateKey, ok := privateKey.(*rsa.PrivateKey)
if !ok {
return "", fmt.Errorf("not an RSA private key")
}
// Prepare data to sign
var dataToSign []byte
if str, ok := payload.(string); ok {
dataToSign = []byte(str)
} else {
dataToSign, err = json.Marshal(payload)
if err != nil {
return "", err
}
}
// Sign the data
hashed := sha256.Sum256(dataToSign)
signature, err := rsa.SignPKCS1v15(rand.Reader, rsaPrivateKey, crypto.SHA256, hashed[:])
if err != nil {
return "", err
}
return base64.StdEncoding.EncodeToString(signature), nil
}
```
```rust theme={null}
use base64;
use rsa::{pkcs8::DecodePrivateKey, RsaPrivateKey};
use rsa::signature::{Signer, Verifier};
use rsa::pkcs1v15::{SigningKey, VerifyingKey};
use sha2::Sha256;
use serde_json;
fn sign_request(payload: &str, private_key_pem: &str) -> Result> {
// Parse private key
let private_key = RsaPrivateKey::from_pkcs8_pem(private_key_pem)?;
let signing_key = SigningKey::::new(private_key);
// Sign the payload
let signature = signing_key.sign(payload.as_bytes());
// Encode to base64
Ok(base64::encode(signature.to_bytes()))
}
```
```csharp theme={null}
using System;
using System.Security.Cryptography;
using System.Text;
using Newtonsoft.Json;
public class WoodcoreAuth
{
public static string SignRequest(object payload, string privateKeyPEM)
{
// Remove PEM headers
string privateKeyContent = privateKeyPEM
.Replace("-----BEGIN PRIVATE KEY-----", "")
.Replace("-----END PRIVATE KEY-----", "")
.Replace("\n", "")
.Replace("\r", "");
byte[] privateKeyBytes = Convert.FromBase64String(privateKeyContent);
using (RSA rsa = RSA.Create())
{
rsa.ImportPkcs8PrivateKey(privateKeyBytes, out _);
// Prepare data to sign
string dataToSign = payload is string ? (string)payload : JsonConvert.SerializeObject(payload);
byte[] dataBytes = Encoding.UTF8.GetBytes(dataToSign);
// Sign the data
byte[] signatureBytes = rsa.SignData(dataBytes, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
return Convert.ToBase64String(signatureBytes);
}
}
}
```
### Step 3: Make API Requests
Include the signature and timestamp in your request headers:
```bash theme={null}
curl -X POST https://api.woodcore.co/v2/endpoint \
-H "X-Signature: YOUR_SIGNATURE" \
-H "X-Timestamp: TIMESTAMP" \
-H "Content-Type: application/json" \
-d '{"your": "payload"}'
```
**Best Practice**: Always include a timestamp in your requests to prevent replay attacks. The timestamp should be within 5 minutes of the server time.
# Ledger to Account - Generic
Source: https://docs.woodcore.co/api-reference/endpoint/accountgl
POST /accountgl
# Ledger to Account - Internal
Source: https://docs.woodcore.co/api-reference/endpoint/accountgl_system
POST /accountgl/system
# List Account Transfers
Source: https://docs.woodcore.co/api-reference/endpoint/accounttransfers
GET /accounttransfers
# GetCharges
Source: https://docs.woodcore.co/api-reference/endpoint/charges
GET /charges
GetCharges
# Get Charge By ID
Source: https://docs.woodcore.co/api-reference/endpoint/charges_93
GET /charges/{chargeId}
# List Clients
Source: https://docs.woodcore.co/api-reference/endpoint/clients
GET /clients
# List Client Accounts
Source: https://docs.woodcore.co/api-reference/endpoint/clients_1093_accounts
GET /clients/{clientId}/accounts
# Activate Client
Source: https://docs.woodcore.co/api-reference/endpoint/clients_1733_activate
POST /clients/{clientId}/activate
This API can be used when `_isActive:true` is not passed in the request body of customer creation.
Clients can be created in a pending state but If the client is already active, this API will result in an error.
# Change Client Tier
Source: https://docs.woodcore.co/api-reference/endpoint/clients_1733_updateTier
POST /clients/{clientId}/updateTier
# Retrieve All Client Documents
Source: https://docs.woodcore.co/api-reference/endpoint/clients_405_documents
GET /clients/{clientId}/documents
# Retrieve Single Client Document
Source: https://docs.woodcore.co/api-reference/endpoint/clients_405_documents_107
GET /clients/{clientId}/documents/{documentId}
# Retrieve Client Image
Source: https://docs.woodcore.co/api-reference/endpoint/clients_410_images
GET /clients/{clientId}/images
# Retrieve Client
Source: https://docs.woodcore.co/api-reference/endpoint/clients_415
GET /clients/{clientId}
# Patch Corporate Customer
Source: https://docs.woodcore.co/api-reference/endpoint/clients_corporate_34352
PUT /clients/corporate/{clientId}
# Upload Document
Source: https://docs.woodcore.co/api-reference/endpoint/clients_document_34005
POST /clients/document/{clientId}
# Upload Image
Source: https://docs.woodcore.co/api-reference/endpoint/clients_images_1
POST /clients/images/{clientId}
# Patch Individual Customer
Source: https://docs.woodcore.co/api-reference/endpoint/clients_individual_415
PUT /clients/individual/{clientId}
# Update Individual Customer
Update Individual Customer
# Search By BVN
Source: https://docs.woodcore.co/api-reference/endpoint/clients_searchbybvn_23737828392
GET /clients/searchbybvn/{bvn}
Search By BVN Number
# Search By Account Number
Source: https://docs.woodcore.co/api-reference/endpoint/clients_searchbyeaccountnumber_000001733
GET /clients/searchbyeaccountnumber/{accountNumber}
# Search By Phone Number
Source: https://docs.woodcore.co/api-reference/endpoint/clients_searchbyphone_09117258911
GET /clients/searchbyphone/{phoneNumber}
# Get all ClientTiers
Source: https://docs.woodcore.co/api-reference/endpoint/clienttiers
GET /clienttiers
# Get all ClientTiers
Get all ClientTiers
# Get Codes
Source: https://docs.woodcore.co/api-reference/endpoint/codes
GET /codes
# Get Codevalues By Code Id
Source: https://docs.woodcore.co/api-reference/endpoint/codes_29_codeValues
GET /codes/{code_id}/codeValues
# Get Codevalues By Code Id
Get Codevalues By Code Id
# Get Codevalues By Code Name
Source: https://docs.woodcore.co/api-reference/endpoint/codes_codeValues
GET /codes/codeValues
# Get Codevalues By Code Name
Get Codevalues By Code Name
## Parameters
* **name** (query, string, required: False): Example: `ClientSectorCodes`
# Create Customer
Source: https://docs.woodcore.co/api-reference/endpoint/create_clients
POST /clients
# Create General Ledger Account
Source: https://docs.woodcore.co/api-reference/endpoint/create_ledger
POST /ledger
# Create Loan Account
Source: https://docs.woodcore.co/api-reference/endpoint/create_loans
POST /loans
# Create Loan Account
A loan account application can be created by using this endpoint.
##### Field Description
| Field | Description | Type |
| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
| clientId | The client submitting a loan application. | Integer |
| productId | Desccribes the Identifier of the loan product associated with the loan application. The loan application inherits some of the information from its associated loan product. | Integer |
| principal | The loan amount to be disbursed to through loan. | Integer |
| duration | The loan term period to use. e.g. 10,12 | Integer |
| durationBy | Describes the type of duration cycle to be used for the loan. Available values include: \[Month, Year] | String |
| loanType | To represent different type of loans. At present there are three type of loans are supported. Available loan types: ***individual***: Loan given to individual member. ***group***: Loan given to group as a whole. ***jlg***: Joint liability group loan given to members in a group on individual basis. JLG loan can be given to one or more members in a group. | String |
| numberOfRepayments | This is the number of installments to repay. e.g 1 (repayments) every 12 months. | Integer |
| repaymentEvery | This is used like numberOfRepayments e.g 1 (repayments) every 1 month. | Integer |
| repaymentFrequency | This describes the frequency of payments for the loan. Available options include: \[Monthly, Yearly] | String |
| interestRate | This describes the rate of interest calculated on the principal amount of the loan. | Integer |
| interestType | Describes the type of interest calculated on the loan. Examples include: fiat, declining, e.t.c. | String. |
| linkDepositAccountId | Describes the Identifier of the savings account to be linked to the loan account. | Integer |
| expectedDisbursementDate | The proposed disbursement date of the loan so a proposed repayment schedule can be provided. | String |
| createdDate | The date the loan application was submitted by applicant. | String |
| dateFormat | The default date format on WoodCore "dd MMMM yyyy" | String |
| locale | "en" by default | String |
## Parameters
* **woodcoretenant** (header, string, required: False): Example: `default`
# Create Loop Entries
Source: https://docs.woodcore.co/api-reference/endpoint/create_loops_entries
POST /loops/entries/Bvn/{value}
# Create Savings Account Application
Source: https://docs.woodcore.co/api-reference/endpoint/create_savingsaccounts
POST /savingsaccounts
# List Fixed Deposit Accounts
Source: https://docs.woodcore.co/api-reference/endpoint/fixeddepositaccounts
GET /fixeddepositaccounts
# Pre-Mature Close Fixed Deposit Account
Source: https://docs.woodcore.co/api-reference/endpoint/fixeddepositaccounts_1082_prematureClose
POST /fixeddepositaccounts/{accountId}/prematureClose
# Close Fixed Deposit Account
Source: https://docs.woodcore.co/api-reference/endpoint/fixeddepositaccounts_398_close
POST /fixeddepositaccounts/{accountId}/close
# Activate Fixed Deposit Account
Source: https://docs.woodcore.co/api-reference/endpoint/fixeddepositaccounts_690_activate
POST /fixeddepositaccounts/{accountId}/activate
# Retrieve Fixed Deposit Account
Source: https://docs.woodcore.co/api-reference/endpoint/fixeddepositaccounts_692
GET /fixeddepositaccounts/{accountId}
# Create Intra Transfer
Source: https://docs.woodcore.co/api-reference/endpoint/intratransfer
POST /intratransfer
# (Check) Retrieve Intra transfer transaction
Source: https://docs.woodcore.co/api-reference/endpoint/intratransfer_transaction_626
GET /intratransfer/transaction/{transactionId}
# Retrieve All Journal Entries
Source: https://docs.woodcore.co/api-reference/endpoint/journalentries
GET /journalentries
# Retrieve Journal Entry
Source: https://docs.woodcore.co/api-reference/endpoint/journalentries_804
GET /journalentries/{entryId}
# Reverse Journal Entry (Not Applicable)
Source: https://docs.woodcore.co/api-reference/endpoint/journalentries_804_reverse
POST /journalentries/{entryId}/reverse
# Retrieve Ledger Transaction Status wIth entryId
Source: https://docs.woodcore.co/api-reference/endpoint/journalentries_PLRTRF_15620801726047104623_transactionstatus
GET /journalentries/{reference}/transactionstatus
# Retrieve Transaction Status With uniqueReferenceKey
Source: https://docs.woodcore.co/api-reference/endpoint/journalentries_transactionstatus_9e8djd98ddw123
GET /journalentries/transactionstatus/{reference}
# Retrieve All General Ledger Accounts
Source: https://docs.woodcore.co/api-reference/endpoint/ledger
GET /ledger
# Retrieve General Ledger Account
Source: https://docs.woodcore.co/api-reference/endpoint/ledger_50
GET /ledger/{accountId}
# Generate Ledger Number
Source: https://docs.woodcore.co/api-reference/endpoint/ledger__utilities_generateCode_LIABILITY
GET /ledger//utilities/generateCode/{accountType}
# List Loan Products
Source: https://docs.woodcore.co/api-reference/endpoint/loanproducts
GET /loanproducts
# Retrieve a Loan Product
Source: https://docs.woodcore.co/api-reference/endpoint/loanproducts_3
GET /loanproducts/{productId}
# Retrieve a Loan Product Charges Options
Source: https://docs.woodcore.co/api-reference/endpoint/loanproducts_3_chargeOptions
GET /loanproducts/{productId}/chargeOptions
# List All Loan Accounts
Source: https://docs.woodcore.co/api-reference/endpoint/loans
GET /loans
# List All Loan Accounts
This allows the retrieval of all loan account in a paginated or non-paginated format.
##### Optional Query Parameters
| Name | Description | Required | Type |
| ------- | ---------------------------------------------------------------------------------------------------------------------- | -------- | ------- |
| page | Pagination, index to start searching at when retrieving elements, used in combination with perPage to paginate results | false | Integer |
| perPage | Pagination, the number of elements to retrieve, used in combination with page to paginate results | false | Integer |
**Example Requests**:
[baseUrl/api/v2/loans](https://spark.test.woodcore.co/api/v2/loans)
[baseUrl/api/v2/loans?page=10\&perPage=50](https://spark.test.woodcore.co/api/v2/loans?page=10\&perPage=50)
# Disburse Loan To Savings
Source: https://docs.woodcore.co/api-reference/endpoint/loans_16_disbursetosavings
POST /loans/{loanId}/disbursetosavings
# Approve Loan Account
Source: https://docs.woodcore.co/api-reference/endpoint/loans_17_approve
POST /loans/{loanId}/approve
# Retrieve Loan Account
Source: https://docs.woodcore.co/api-reference/endpoint/loans_217
GET /loans/{loanId}
# Repayment Schedule
Source: https://docs.woodcore.co/api-reference/endpoint/loans_2_repaymentSchedule
GET /loans/{loanId}/repaymentSchedule
# Reject Loan
Source: https://docs.woodcore.co/api-reference/endpoint/loans_329_reject
POST /loans/{loanId}/reject
# Make Repayment for Loan
Source: https://docs.woodcore.co/api-reference/endpoint/loans_342_repayment
POST /loans/{loanId}/repayment
# Foreclosure of an Active Loan
Source: https://docs.woodcore.co/api-reference/endpoint/loans_74_foreclosure
POST /loans/{loanId}/foreclosure
# Undo Disburse Loan
Source: https://docs.woodcore.co/api-reference/endpoint/loans_74_undodisburse
POST /loans/{loanId}/undodisburse
# Modify Loan Account
Source: https://docs.woodcore.co/api-reference/endpoint/loans_75_modify
PUT /loans/{loanId}/modify
# Make Recovery Payment for Write-off Loan
Source: https://docs.woodcore.co/api-reference/endpoint/loans_75_recoverypayment
POST /loans/{loanId}/recoverypayment
# GET All Loan Account Transactions
Source: https://docs.woodcore.co/api-reference/endpoint/loans_75_transactions
GET /loans/{loanId}/transactions
# GET Loan Account Transaction
Source: https://docs.woodcore.co/api-reference/endpoint/loans_75_transactions_572
GET /loans/{loanId}/transactions/{transactionId}
# Undo Approval for Loan Account
Source: https://docs.woodcore.co/api-reference/endpoint/loans_75_unapprove
POST /loans/{loanId}/unapprove
# Undo Write-off for Loan
Source: https://docs.woodcore.co/api-reference/endpoint/loans_75_undowriteoff
POST /loans/{loanId}/undowriteoff
# Waive Interest on Loan Account
Source: https://docs.woodcore.co/api-reference/endpoint/loans_75_waiveInterest
POST /loans/{loanId}/waiveInterest
# Write-off Loan
Source: https://docs.woodcore.co/api-reference/endpoint/loans_75_writeoff
POST /loans/{loanId}/writeoff
# Disburse Loan
Source: https://docs.woodcore.co/api-reference/endpoint/loans_7_disburse
POST /loans/{loanId}/disburse
# Foreclosure With Linked Savings
Source: https://docs.woodcore.co/api-reference/endpoint/loans_95_foreclosurewithlinkedsavings
POST /loans/{loanId}/foreclosurewithlinkedsavings
# Loan Calculation
Source: https://docs.woodcore.co/api-reference/endpoint/loans_calculate
POST /loans/calculate
# List All Loops
Source: https://docs.woodcore.co/api-reference/endpoint/loops
GET /loops
# Retreive Entries in a Loop
Source: https://docs.woodcore.co/api-reference/endpoint/loops_entries_Additional Information_4
GET /loops/entries/table/{value}
# Update Loop Entries
Source: https://docs.woodcore.co/api-reference/endpoint/loops_entries_Bvn_427
PUT /loops/entries/Bvn/{value}
# List Savings Accounts
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts
GET /savingsaccounts
# List All Lien on Savings Account
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_1_lien
GET /savingsaccounts/{savingsId}/lien
# Lien Amount from Savings Account
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_2_lien
POST /savingsaccounts/{savingsId}/lien
# Release Lien Amount on Savings Account
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_2_lien_195401
POST /savingsaccounts/{savingsId}/lien/{lienId}
# Withdraw From Liened Amount
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_2_lien_withdraw_184801
POST /savingsaccounts/{savingsId}/lien/withdraw/{lienId}
# Reverse Savings Account Transaction
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_2_transactions_79
POST /savingsaccounts/{savingsId}/transactions/{transactionId}
# Retrieve Savings Account Transaction
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_2_transactions_80526687-e86e-4c07-84fa-33d256d0e68a
GET /savingsaccounts/{savingsId}/transactions/{transactionId}
# List Savings Account Charges
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_424_charges
GET /savingsaccounts/{savingsId}/charges
# Retrieve Savings Account Charge
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_424_charges_8
GET /savingsaccounts/{savingsId}/charges/{chargeId}
# PNC On Savings Account
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_458_setpnc
POST /savingsaccounts/{savingsId}/setpnc
# Block Savings Account
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_459_block
POST /savingsaccounts/{savingsId}/block
# UnBlock Savings Account
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_459_unblock
POST /savingsaccounts/{savingsId}/unblock
# Activate Savings Account
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_573_activate
POST /savingsaccounts/{savingsId}/activate
# Retrieve a Savings Account
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_61
GET /savingsaccounts/{savingsId}
The balance on a savings account is automatically re-calculated and upated after every **30 mins** on Woodcore, when a transaction is done on an an account, the change on the balance might not impact immediately but the message has been efected, if you need to see the calculated balaned realtime you can passs `refresh` as `true`
**Example**
* GET Account Balance - \$500
* POST Debit Transaction - \$100
* GET Account Balance - \$500
* GET Account Balance with `refresh = true` - \$400
* GET Account Balance **30 min after** - \$400
# Unblock PNC On Savings Account
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_688_removepnc
POST /savingsaccounts/{savingsId}/removepnc
# Unblock PND On Savings Account
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_688_removepnd
POST /savingsaccounts/{savingsId}/removepnd
# Post No Debit (PND) On Savings Account
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_688_setpnd
POST /savingsaccounts/{savingsId}/setpnd
# List Savings Accounts Transactions
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_695_transactions
GET /savingsaccounts/{savingsId}/transactions
# Enable Pool On Savings Account
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_6_pool
POST /savingsaccounts/{savingsId}/pool
# Search Account By Nuban
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_nuban_1100074454
GET /savingsaccounts/nuban/{nuban}
# Search By Account Number
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_searchbyeaccountnumber_000000001
GET /savingsaccounts/searchbyeaccountnumber/{accountNumber}
# Search By Account Number
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_searchbyeaccountnumber_000000695
GET /savingsaccounts/searchbyeaccountnumber/{accountNumber}
# Generate Transaction Receipt
Source: https://docs.woodcore.co/api-reference/endpoint/savingsaccounts_utilities_downloadReceipt_1
GET /savingsaccounts/utilities/downloadReceipt/{savingsId}
# List savings product
Source: https://docs.woodcore.co/api-reference/endpoint/savingsproducts
GET /savingsproducts
# Retrive a savings product
Source: https://docs.woodcore.co/api-reference/endpoint/savingsproducts_8
GET /savingsproducts/{productId}
# List Transactions
Source: https://docs.woodcore.co/api-reference/endpoint/transactions
GET /transactions
# Retrieve Transaction
Source: https://docs.woodcore.co/api-reference/endpoint/transactions_4
GET /transactions/{transactionId}
# Introduction
Source: https://docs.woodcore.co/api-reference/introduction
API Reference for Woodcore integrations
Welcome to Woodcore simplified api endpoints, these are dedicated customer friendly endpoints mostly used by financial institutions on our SAAS.
Start your journey in the following steps
Create your API keys using the [authentication guide](/api-reference/authentication)
Create and configure your [webhook](/api-reference/notifications) (if neccesary)
Start building solutions on Woodcore simplified API's
For Legacy API's for on-premise customers please contact **[business@woodcore.co](mailto:business@woodcore.co)**
#### Base URLs
| Environment | Version | Base URL |
| ------------ | ------- | ------------------------------------------- |
| `Sandbox` | `v1` | `https://spark.test.woodcoreapp.com/api/v2` |
| `Production` | `v1` | `https://sandbox-api.woodcore.co/api/v2` |
| | | |
| `Sanbox` | `v2` | `https://api.studio.woodcore.co/api/v2` |
| `Production` | `v2` | `https://api.woodcore.co/api/v2` |
**Important Notice**: API v1 will be deprecated and phased out on December 29, 2025. We recommend migrating to v2 as soon as possible to ensure uninterrupted service.
**Security First**: Before making any API calls, new tenants must complete the following security setup:
1. Generate and secure API keys
2. Configure IP whitelisting
3. Set up proper authentication
## Security Setup
As a new tenant, your first step should be to configure your security settings. Visit our [Security Endpoints](/security/endpoint/introduction) documentation to:
Configure which IP addresses can access your API endpoints
Manage and monitor your API keys
For security compliance and custom requirements, please contact our compliance team at [compliance@woodcore.co](mailto:compliance@woodcore.co)
### Modular Guides
Core banking operations including accounts, loans, and transactions
Digital banking services including accounts, transactions, and payments
Service orchestration and workflow management
Card management and transaction processing
# Changelog
Source: https://docs.woodcore.co/changelog/logs
Find Woodcore APIs' updates.
Only keep those starting from 2025 here; the previous ones will not be
included.
## January, 2025
#### Balance Calulation Update
Deposit account balance will not longer be calculted real-time on the system, when a transaction is completed the balance will remain the same way until either the following happens;
* Balance will get updated after **30 mins**
* Pass `refresh` as `true` to the `/savingsaccounts/{savingsId}` endpoint as a query param. see example below
```curl theme={null}
curl -X GET "https://base.com/savingsaccounts/{savingsId}?refresh=true" -H "Accept: application/json"
```
If `refresh` is not set as `true` the current balance as is will be returned
# Card Management
Source: https://docs.woodcore.co/modules/card/intro
Comprehensive card management solution for financial institutions with ISO 8583 support, dispute management, and end-to-end card lifecycle management. Features include card issuance, transaction processing, security compliance, and integration capabilities.
The Card Services module provides comprehensive card management capabilities for financial institutions, supporting various card types and payment networks. This module enables end-to-end card lifecycle management from issuance to transaction processing.
> 💡 **Modern Card Management**
>
> Woodcore's Card Services module delivers a complete card management solution that supports multiple card types, payment networks, and processing capabilities while ensuring security and compliance. The platform enables rapid deployment of card programs with full ISO 8583 protocol support and comprehensive dispute management.
## Core Capabilities
| Capability | Description | Features |
| -------------------------- | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| **Card Issuance** | End-to-end card issuance process | • Card product management
• Card personalization
• Card production
• Card delivery
• Card activation |
| **Transaction Processing** | Comprehensive transaction handling | • Authorization processing
• Clearing and settlement
• Transaction routing
• Fee calculation
• Dispute management |
| **Card Management** | Ongoing card lifecycle management | • PIN management
• Card blocking/unblocking
• Card replacement
• Card renewal
• Card limits management |
| **Security Management** | Advanced security features | • Fraud detection
• Risk scoring
• Transaction monitoring
• Security alerts
• Compliance checks |
## Card Issuance Process Flow
```mermaid theme={null}
graph TD
A[Customer Application] --> B[KYC Verification]
B --> C[Risk Assessment]
C --> D[Card Product Selection]
D --> E[Card Production]
E --> F[Card Personalization]
F --> G[Card Delivery]
G --> H[Card Activation]
H --> I[PIN Generation]
style A fill:#f9f,stroke:#333,stroke-width:2px
style I fill:#9f9,stroke:#333,stroke-width:2px
```
## Transaction Processing Flow
```mermaid theme={null}
graph TD
A[Transaction Initiation] --> B[ISO 8583 Message]
B --> C[Authorization Request]
C --> D[Risk Check]
D --> E[Balance Check]
E --> F[Authorization Response]
F --> G[Transaction Completion]
G --> H[Clearing]
H --> I[Settlement]
style A fill:#f9f,stroke:#333,stroke-width:2px
style I fill:#9f9,stroke:#333,stroke-width:2px
```
## ISO 8583 Protocol Support
| Protocol Feature | Description | Implementation |
| ------------------- | --------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| **Message Types** | Standard message formats | • Authorization (0100/0110)
• Financial (0200/0210)
• Reversal (0400/0410)
• Network Management (0800/0810) |
| **Data Elements** | Message field definitions | • Primary Account Number
• Processing Code
• Transaction Amount
• Transmission Date/Time
• Merchant Data |
| **Network Support** | Payment network integration | • Visa
• Mastercard
• UnionPay
• Local Networks
• Custom Networks |
> 🔄 **Transaction Processing**
>
> Woodcore's card processing capabilities include:
>
> * Full ISO 8583 protocol implementation
> * Real-time authorization processing
> * Multi-currency support
> * Dynamic routing capabilities
> * Comprehensive fee management
> * Automated clearing and settlement
> * Real-time transaction monitoring
> * Advanced fraud detection
## Dispute Management
| Process Stage | Description | Features |
| ------------------------- | -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| **Chargeback Initiation** | Dispute processing start | • Dispute reason codes
• Documentation collection
• Timeline tracking
• Status monitoring
• Communication management |
| **Representment** | Merchant response handling | • Evidence collection
• Response preparation
• Timeline management
• Status tracking
• Communication handling |
| **Arbitration** | Final dispute resolution | • Case review
• Decision management
• Settlement processing
• Communication handling
• Compliance checks |
> ⚠️ **Dispute Resolution**
>
> The dispute management system provides:
>
> * Automated chargeback processing
> * Comprehensive reason code support
> * Timeline management
> * Document handling
> * Status tracking
> * Communication management
> * Settlement processing
> * Compliance monitoring
## Key Features
| Feature Category | Description | Components |
| --------------------------- | ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| **Card Product Management** | Product configuration and setup | • Product configuration
• Fee structure setup
• Card type management
• Network configuration
• Product versioning |
| **Card Issuance** | Digital and physical card handling | • Digital card issuance
• Physical card production
• Card personalization
• Card delivery tracking
• Card activation |
| **Transaction Processing** | Comprehensive transaction handling | • Real-time authorization
• Clearing and settlement
• Transaction routing
• Fee calculation
• Dispute handling |
| **Card Management** | Ongoing card operations | • PIN management
• Card blocking/unblocking
• Card replacement
• Card renewal
• Limits management |
## Integration Points
```mermaid theme={null}
graph TD
A[Card Services] --> B[Core Banking]
A --> C[Payment Networks]
A --> D[Digital Services]
A --> E[Security Systems]
A --> F[Reporting Systems]
style A fill:#f9f,stroke:#333,stroke-width:4px
```
> ℹ️ **System Integration**
>
> The Card Services module integrates with:
>
> * Core Banking System for account management
> * Payment Networks for transaction processing
> * Digital Services for mobile/online access
> * Security Systems for fraud prevention
> * Reporting Systems for analytics
> * ISO 8583 Gateways for network communication
> * Dispute Management Systems
> * Compliance Monitoring Systems
## Security and Compliance
| Aspect | Features | Capabilities |
| ----------------------- | ---------------------- | ------------------------------------------------------------------------------------------------------------------------- |
| **Security Features** | Card security measures | • EMV compliance
• PCI DSS compliance
• Tokenization
• Encryption
• Fraud prevention |
| **Compliance Features** | Regulatory compliance | • Regulatory reporting
• Transaction monitoring
• Audit logging
• Compliance checks
• Risk management |
> ⚠️ **Important Note**
>
> Before processing live card transactions, ensure:
>
> * PCI DSS compliance certification
> * EMV compliance implementation
> * Network certification completion
> * Security measures configuration
> * Compliance monitoring setup
> * Dispute management procedures
> * Settlement processes
> * Risk management controls
# Accounting Management
Source: https://docs.woodcore.co/modules/core-banking/accounting
Comprehensive accounting management system supporting modern banking operations with automated general ledger, journal entries, and financial reporting capabilities.
The Accounting Management module is the financial backbone of the core banking system, providing robust accounting capabilities with automated processes, real-time posting, and comprehensive reporting for modern banking operations.
## Overview
The Accounting Management module provides a comprehensive framework for handling all financial accounting operations in the core banking system. From real-time transaction posting to automated financial reporting, the system ensures accurate, efficient, and compliant accounting processes.
The General Ledger is the central repository of all financial transactions, providing real-time balance tracking and automated posting capabilities.
### Core Features
* Real-time transaction posting
* Multi-currency support
* Automated balance updates
* Transaction history
* Balance verification
* Period-end processing
* Year-end processing
### Chart of Accounts
A well-structured Chart of Accounts is crucial for accurate financial reporting and analysis.
* Account hierarchy
* Account types
* Account attributes
* Balance types
* Reporting categories
* Cost centers
* Profit centers
```mermaid theme={null}
flowchart TB
subgraph GL[General Ledger]
Accounts[Chart of Accounts]
Transactions[Transaction Posting]
Balances[Balance Management]
Reports[Financial Reports]
end
subgraph Processing[Processing]
RealTime[Real-time]
Batch[Batch]
Automated[Automated]
Scheduled[Scheduled]
end
subgraph Controls[Controls]
Validation[Validation]
Reconciliation[Reconciliation]
Audit[Audit]
Compliance[Compliance]
end
GL --> Processing
Processing --> Controls
```
Journal entries are the foundation of double-entry accounting, ensuring accurate financial records and automated posting.
### Entry Types
* Transaction entries
* Adjustment entries
* Reversal entries
* Closing entries
* Opening entries
* Correction entries
* Back-dated entries
### Automated Posting
Automated posting rules must be carefully configured to ensure accurate financial records.
* Real-time posting
* Batch posting
* Scheduled posting
* Conditional posting
* Multi-currency posting
* Tax posting
* Fee posting
```mermaid theme={null}
flowchart LR
subgraph JournalEntry[Journal Entry]
Transaction[Transaction]
Rule[Accounting Rule]
Posting[Posting]
Validation[Validation]
end
subgraph Processing[Processing]
RealTime[Real-time]
Batch[Batch]
Scheduled[Scheduled]
end
subgraph GL[General Ledger]
Debit[Debit]
Credit[Credit]
Balance[Balance]
end
JournalEntry --> Processing
Processing --> GL
```
Accounting rules define how transactions are processed and posted to the general ledger, ensuring consistent and accurate financial records.
### Rule Types
* Transaction rules
* Posting rules
* Tax rules
* Fee rules
* Interest rules
* Amortization rules
* Accrual rules
### Rule Management
* Rule definition
* Rule validation
* Rule testing
* Rule deployment
* Rule monitoring
* Rule reporting
* Rule audit
Automated accounting processes ensure efficient and accurate financial operations with minimal manual intervention.
### Amortization
* Loan amortization
* Fee amortization
* Cost amortization
* Schedule generation
* Interest calculation
* Principal calculation
* Balance updates
### Accruals
Accrual accounting ensures that revenues and expenses are recognized in the correct accounting period.
* Interest accruals
* Fee accruals
* Tax accruals
* Revenue accruals
* Expense accruals
* Reversal processing
* Adjustment handling
### Back Posting
* Historical posting
* Period adjustments
* Balance corrections
* Audit trail
* Validation checks
* Reporting updates
* Compliance checks
```mermaid theme={null}
flowchart TD
subgraph Automation[Automated Processes]
Amortization[Amortization]
Accruals[Accruals]
BackPosting[Back Posting]
end
subgraph Processing[Processing]
Schedule[Schedule]
Calculate[Calculate]
Post[Post]
Validate[Validate]
end
subgraph Reporting[Reporting]
Update[Update]
Report[Report]
Audit[Audit]
end
Automation --> Processing
Processing --> Reporting
```
## Financial Controls
Robust financial controls are essential for maintaining accurate financial records and ensuring compliance with regulatory requirements.
### Double-Entry Accounting
* Debit and credit validation
* Balance verification
* Transaction matching
* Error detection
* Correction processing
* Audit trail
* Compliance checks
### Reconciliation
* Account reconciliation
* Transaction matching
* Balance verification
* Exception handling
* Adjustment processing
* Reporting
* Audit trail
## Modern Banking Features
Modern banks can leverage advanced accounting features to improve efficiency and provide better financial services.
### Real-time Processing
* Instant posting
* Real-time balances
* Live reporting
* Immediate reconciliation
* Automated controls
* Instant validation
* Real-time monitoring
### Automated Reporting
* Financial statements
* Regulatory reports
* Management reports
* Tax reports
* Compliance reports
* Audit reports
* Custom reports
## Integration Points
The Accounting Management module integrates with:
* Transaction Processing
* Account Management
* Payment Systems
* Reporting Systems
* Regulatory Systems
* Audit Systems
* Compliance Systems
## Next Steps
Explore related modules to learn more about:
* [Transaction Processing](/modules/core-banking/transactions)
* [Account Management](/modules/core-banking/accounts)
* [Reporting Systems](/modules/core-banking/reports)
* [Compliance Management](/modules/core-banking/compliance)
# Account Management
Source: https://docs.woodcore.co/modules/core-banking/accounts
Comprehensive account management system supporting various account types including digital wallets, savings, loans, and fixed deposits with flexible configuration options for fintechs.
The Account Management module is the primary account type system in Woodcore, providing a flexible framework for managing various account types and enabling fintechs to build sophisticated wallet systems for their end users.
```mermaid theme={null}
flowchart TB
subgraph AccountTypes[Account Types]
Wallet[Digital Wallet]
Savings[Savings Account]
Current[Current Account]
Loan[Loan Account]
Fixed[Fixed Deposit]
Recurring[Recurring Deposit]
end
subgraph Features[Core Features]
Balance[Balance Management]
Interest[Interest Calculation]
Limits[Transaction Limits]
Security[Security Controls]
end
subgraph WalletFeatures[Wallet Features]
P2P[P2P Transfers]
QR[QR Payments]
BillPay[Bill Payments]
TopUp[Top-up Services]
end
AccountTypes --> Features
Wallet --> WalletFeatures
```
The Account Management system is designed to be the foundation for fintech wallet systems, providing all necessary features for modern digital banking.
Digital wallets are the primary account type for fintech applications, providing a flexible foundation for various financial services.
```mermaid theme={null}
flowchart LR
subgraph WalletCore[Wallet Core]
Balance[Balance Management]
Transactions[Transaction Processing]
Security[Security Controls]
end
subgraph WalletServices[Wallet Services]
P2P[P2P Transfers]
QR[QR Payments]
BillPay[Bill Payments]
TopUp[Top-up Services]
end
subgraph Integration[Integration Points]
Payment[Payment Gateways]
Banking[Banking Systems]
Mobile[Mobile Apps]
end
WalletCore --> WalletServices
WalletServices --> Integration
```
* Real-time balance tracking
* Instant P2P transfers
* QR code payments
* Bill payments
* Mobile top-up
* Merchant payments
* Cash-in/Cash-out
* Transaction history
Savings accounts provide interest-earning capabilities with various features for different customer needs.
* Regular savings
* High-yield savings
* Goal-based savings
* Children's savings
* Interest calculation
* Withdrawal limits
* Minimum balance requirements
Current accounts are designed for frequent transactions and business operations.
* Business accounts
* Personal accounts
* Zero balance accounts
* Premium accounts
* Transaction limits
* Overdraft facilities
* Check book facilities
Fixed deposits offer higher interest rates for funds locked for specific periods.
* Term deposits
* Flexible deposits
* Senior citizen deposits
* Corporate deposits
* Interest rate options
* Premature withdrawal
* Auto-renewal
Recurring deposits allow customers to save regularly with fixed installments.
* Regular savings plan
* Flexible installments
* Interest calculation
* Maturity options
* Early withdrawal
* Auto-debit
Loan accounts manage various types of credit facilities for customers.
* Personal loans
* Business loans
* Mortgage loans
* Auto loans
* Education loans
* EMI management
* Interest calculation
```mermaid theme={null}
flowchart TD
subgraph Transactions[Transaction Types]
Deposit[Deposits]
Withdrawal[Withdrawals]
Transfer[Transfers]
Payment[Payments]
end
subgraph Methods[Transaction Methods]
Cash[Cash]
Card[Card]
Mobile[Mobile]
Online[Online]
end
subgraph Channels[Channels]
Branch[Branch]
ATM[ATM]
Mobile[Mobile App]
Internet[Internet Banking]
end
Transactions --> Methods
Methods --> Channels
```
All transactions are subject to account limits and security controls.
* Real-time balance updates
* Available balance calculation
* Ledger balance tracking
* Balance alerts
* Minimum balance monitoring
* Interest calculation
* Interest posting
* Interest rate management
* Interest tax handling
* Interest statements
* Multi-factor authentication
* Role-based access
* Transaction limits
* IP restrictions
* Device management
* Transaction monitoring
* Suspicious activity detection
* Risk scoring
* Account freezing
* Fraud alerts
* KYC verification
* Transaction limits
* Reporting requirements
* Audit trails
* Regulatory compliance
```mermaid theme={null}
flowchart LR
subgraph FintechApp[Fintech Application]
Wallet[Wallet System]
Payments[Payment Services]
Services[Value Services]
end
subgraph CoreBanking[Core Banking]
Accounts[Account Management]
Transactions[Transaction Processing]
Security[Security System]
end
subgraph External[External Systems]
Payment[Payment Gateways]
Banking[Banking Systems]
Mobile[Mobile Apps]
end
FintechApp --> CoreBanking
CoreBanking --> External
```
* RESTful APIs
* WebSocket support
* Batch processing
* Real-time updates
* P2P transfers
* QR payments
* Bill payments
* Merchant payments
* Cash management
* Mobile top-up
* Utility payments
* Insurance products
* Investment products
* Loyalty programs
## Next Steps
Explore related modules to learn more about:
* [Transaction Processing](/modules/core-banking/transactions)
* [Client Management](/modules/core-banking/clients)
* [Payment Systems](/modules/core-banking/payments)
* [Security & Compliance](/modules/core-banking/security)
# Charges Management
Source: https://docs.woodcore.co/modules/core-banking/charges
Comprehensive charges management system handling all banking charges, including taxes, fees, and commissions for loans, deposits, and transactions.
The Charges Management module is a critical component of the core banking system, handling all types of charges, fees, and taxes with automated calculation, application, and reporting capabilities.
## Overview
The Charges Management module provides a comprehensive framework for managing all types of banking charges, from tax calculations to transaction fees. The system ensures accurate charge application, automated calculations, and proper accounting treatment.
Tax charges include various types of taxes and withholdings that must be accurately calculated and reported.
### Tax Types
* Value Added Tax (VAT)
* Withholding Tax (WHT)
* Income Tax
* Stamp Duty
* Transaction Tax
* Service Tax
* Regulatory Tax
### Tax Features
Tax calculations must comply with local regulations and reporting requirements.
* Tax rate management
* Tax calculation rules
* Tax reporting
* Tax reconciliation
* Tax adjustments
* Tax exemptions
* Tax refunds
```mermaid theme={null}
flowchart TB
subgraph TaxTypes[Tax Types]
VAT[VAT]
WHT[WHT]
IncomeTax[Income Tax]
StampDuty[Stamp Duty]
end
subgraph Processing[Processing]
Calculate[Calculate]
Apply[Apply]
Report[Report]
Reconcile[Reconcile]
end
subgraph Compliance[Compliance]
Rules[Rules]
Validation[Validation]
Audit[Audit]
Reporting[Reporting]
end
TaxTypes --> Processing
Processing --> Compliance
```
Loan charges include various fees and costs associated with loan products and services.
### Charge Types
* Processing fees
* Late payment fees
* Prepayment charges
* Commitment fees
* Documentation fees
* Insurance fees
* Service charges
### Charge Features
Loan charges can be configured based on loan type, amount, and customer segment.
* Charge calculation
* Charge application
* Charge waivers
* Charge reversals
* Charge reporting
* Charge history
* Charge analytics
```mermaid theme={null}
flowchart LR
subgraph LoanCharges[Loan Charges]
Processing[Processing Fee]
Late[Late Payment]
Prepayment[Prepayment]
Service[Service Charge]
end
subgraph Calculation[Calculation]
Rules[Rules]
Amount[Amount]
Schedule[Schedule]
Apply[Apply]
end
subgraph Accounting[Accounting]
Post[Post]
Report[Report]
Reconcile[Reconcile]
end
LoanCharges --> Calculation
Calculation --> Accounting
```
Deposit charges include fees associated with deposit accounts and transactions.
### Charge Types
* Account maintenance fees
* Transaction fees
* Withdrawal charges
* Statement fees
* Card charges
* Service fees
* Penalty charges
### Charge Features
* Fee calculation
* Fee application
* Fee waivers
* Fee reversals
* Fee reporting
* Fee history
* Fee analytics
Transaction charges include fees for various banking transactions and services.
### Charge Types
* Transfer fees
* Card transaction fees
* ATM fees
* Check processing fees
* Cash handling fees
* Foreign exchange fees
* Service charges
### Charge Features
Transaction charges must be clearly communicated to customers and properly accounted for.
* Fee calculation
* Fee application
* Fee waivers
* Fee reversals
* Fee reporting
* Fee history
* Fee analytics
```mermaid theme={null}
flowchart TD
subgraph TransactionCharges[Transaction Charges]
Transfer[Transfer Fee]
Card[Card Fee]
ATM[ATM Fee]
Cash[Cash Fee]
end
subgraph Processing[Processing]
Calculate[Calculate]
Apply[Apply]
Report[Report]
end
subgraph Accounting[Accounting]
Post[Post]
Reconcile[Reconcile]
Audit[Audit]
end
TransactionCharges --> Processing
Processing --> Accounting
```
## Charge Processing
Charge processing involves multiple steps to ensure accurate calculation, application, and accounting of charges.
### Processing Steps
1. Charge identification
2. Rule application
3. Fee calculation
4. Charge posting
5. Customer notification
6. Collection processing
7. Reconciliation
### Charge Management
* Charge configuration
* Rate management
* Rule management
* Waiver management
* Reversal processing
* Reporting
* Analytics
## Integration Points
The Charges Management module integrates with:
* Account Management
* Transaction Processing
* Client Management
* Tax Systems
* Reporting Systems
* Billing Systems
* Compliance Systems
## Next Steps
Explore related modules to learn more about:
* [Account Management](/modules/core-banking/accounts)
* [Transaction Processing](/modules/core-banking/transactions)
* [Product Management](/modules/core-banking/products)
* [Compliance Management](/modules/core-banking/compliance)
# Customer & Accounts
Source: https://docs.woodcore.co/modules/core-banking/clients
Comprehensive customer and account management system that handles individual, corporate, and group relationships with flexible account associations.
The Client Management module is the foundation of Woodcore's banking system, handling all aspects of customer information, relationship management, and account associations. It provides a flexible framework for managing diverse customer types and their various banking relationships.
```mermaid theme={null}
flowchart TB
subgraph CustomerTypes[Customer Types]
Individual[Individual Customer]
Corporate[Corporate Customer]
Group[Group/Joint Customer]
Trust[Trust Customer]
end
subgraph AccountTypes[Account Types]
Savings[Savings Account]
Current[Current Account]
Loan[Loan Account]
Fixed[Fixed Deposit]
Investment[Investment Account]
end
subgraph Relationships[Customer-Account Relationships]
Individual --> Savings
Individual --> Current
Individual --> Loan
Individual --> Fixed
Corporate --> Current
Corporate --> Loan
Corporate --> Investment
Group --> Savings
Group --> Current
Trust --> Investment
end
```
A single customer can be associated with multiple accounts of different types, creating a comprehensive banking relationship.
Individual customers are natural persons who can hold personal accounts and access retail banking services.
* Personal identification details
* Contact information
* Employment details
* Income information
* Risk profile
* Banking preferences
Corporate customers are legal entities such as companies, partnerships, and organizations.
* Business registration details
* Corporate structure
* Authorized signatories
* Business classification
* Financial statements
* Compliance documents
Group customers represent multiple individuals sharing accounts or services.
* Group structure
* Member details
* Relationship types
* Authorization levels
* Group policies
Trust customers represent legal arrangements where assets are held for beneficiaries.
* Trust deed details
* Trustee information
* Beneficiary details
* Trust type
* Asset management rules
```mermaid theme={null}
flowchart LR
subgraph CustomerProfile[Customer Profile]
BasicInfo[Basic Information]
KYC[KYC Details]
RiskProfile[Risk Profile]
Preferences[Preferences]
end
subgraph AccountRelationships[Account Relationships]
Primary[Primary Account]
Secondary[Secondary Accounts]
Joint[Joint Accounts]
Beneficiary[Beneficiary Accounts]
end
subgraph AccountTypes[Account Types]
Savings[Savings]
Current[Current]
Loan[Loan]
Fixed[Fixed Deposit]
end
CustomerProfile --> AccountRelationships
AccountRelationships --> AccountTypes
```
* Main operating account
* Salary/income account
* Primary savings account
* Default transaction account
* Additional savings accounts
* Investment accounts
* Special purpose accounts
* Foreign currency accounts
* Shared ownership accounts
* Multiple signatory accounts
* Family accounts
* Business partnership accounts
* Trust beneficiary accounts
* Estate accounts
* Minor accounts
* Power of attorney accounts
```mermaid theme={null}
flowchart TD
Start[Start Registration] --> CollectInfo[Collect Basic Information]
CollectInfo --> VerifyID[Verify Identity]
VerifyID --> RiskAssess[Risk Assessment]
RiskAssess --> ComplianceCheck[Compliance Check]
ComplianceCheck --> CreateProfile[Create Customer Profile]
CreateProfile --> SetupAccounts[Setup Initial Accounts]
SetupAccounts --> End[Registration Complete]
```
All customer registrations must comply with KYC and AML regulations.
* Update personal information
* Modify contact details
* Change preferences
* Update documentation
* Manage relationships
* Open new accounts
* Close accounts
* Modify account details
* Update account status
* Manage account relationships
* Encryption of sensitive data
* Access control mechanisms
* Data retention policies
* Privacy controls
* KYC verification
* AML monitoring
* Regulatory reporting
* Audit trails
* Customer risk scoring
* Transaction monitoring
* Fraud detection
* Compliance alerts
```mermaid theme={null}
flowchart LR
subgraph CoreSystems[Core Systems]
Client[Client Management]
Account[Account Management]
Transaction[Transaction Processing]
Compliance[Compliance System]
end
subgraph ExternalSystems[External Systems]
KYC[KYC Provider]
CreditBureau[Credit Bureau]
Payment[Payment Systems]
Reporting[Reporting Systems]
end
Client --> Account
Account --> Transaction
Client --> Compliance
Client --> KYC
Client --> CreditBureau
Transaction --> Payment
Compliance --> Reporting
```
* Account management
* Transaction processing
* Loan management
* Deposit management
* KYC providers
* Credit bureaus
* Payment gateways
* Regulatory systems
## Next Steps
Explore related modules to learn more about:
* [Account Management](/modules/core-banking/accounts)
* [Transaction Processing](/modules/core-banking/transactions)
* [Loan Management](/modules/core-banking/loans)
* [Deposit Management](/modules/core-banking/deposits)
# Overview
Source: https://docs.woodcore.co/modules/core-banking/intro
Woodcore is a modern, cloud-native core banking engine designed for financial institutions of all sizes. Built with scalability, flexibility, and developer experience in mind, it provides a robust foundation for building next-generation banking solutions.
```mermaid theme={null}
flowchart TB
subgraph CoreBanking[Core Banking]
Client[Client Management]
Account[Account Management]
Transaction[Transaction Processing]
Ledger[General Ledger]
Loan[Loan Management]
Deposit[Deposit Management]
Client --> Account
Account --> Transaction
Transaction --> Ledger
Client --> Loan
Client --> Deposit
end
subgraph IntegrationLayer[Integration Layer]
API[API Gateway]
Webhook[Webhook Service]
EventBus[Event Bus]
API --> CoreBanking
Webhook --> CoreBanking
EventBus --> CoreBanking
end
subgraph SecurityLayer[Security]
Auth[Authentication]
RBAC[Role-Based Access]
Audit[Audit Logging]
Auth --> API
RBAC --> API
Audit --> CoreBanking
end
External[External Systems] --> IntegrationLayer
```
#### The Woodcore engine is built on a microservices architecture, enabling:
* Independent scaling of components
* Technology stack flexibility
* Easy integration with existing systems
* High availability and fault tolerance
Multi-tenancy is a key feature that allows you to serve multiple financial institutions from a single deployment while maintaining complete data isolation.
```mermaid theme={null}
flowchart LR
subgraph Infrastructure
K8s[Kubernetes Cluster]
Tenant1[Tenant 1]
Tenant2[Tenant 2]
Tenant3[Tenant 3]
K8s --> Tenant1
K8s --> Tenant2
K8s --> Tenant3
end
subgraph DataLayer[Data Layer]
DB1[(Database 1)]
DB2[(Database 2)]
DB3[(Database 3)]
DB1 --> Tenant1
DB2 --> Tenant2
DB3 --> Tenant3
end
subgraph SharedServices[Shared Services]
Auth[Auth Service]
Config[Config Service]
Auth --> Tenant1
Auth --> Tenant2
Auth --> Tenant3
Config --> Tenant1
Config --> Tenant2
Config --> Tenant3
end
```
* Isolated tenant environments
* Customizable configurations per tenant
* Shared infrastructure with data isolation
* Tenant-specific branding and workflows
Our cloud-native architecture ensures you can deploy Woodcore on any cloud provider or on-premises environment with minimal configuration changes.
* Containerized deployment
* Kubernetes orchestration
* Auto-scaling capabilities
* Infrastructure as Code support
Woodcore provides comprehensive developer tools and documentation to accelerate your integration process.
* RESTful APIs with OpenAPI/Swagger documentation
* Webhook support for real-time events
* Comprehensive SDKs and client libraries
* Extensive logging and monitoring
```mermaid theme={null}
flowchart TB
subgraph BankingCore[Banking Core]
Account[Account Management]
Transaction[Transaction Processing]
Ledger[General Ledger]
Loan[Loan Management]
Deposit[Deposit Management]
Account --> Transaction
Transaction --> Ledger
Loan --> Transaction
Deposit --> Transaction
end
subgraph Features
MultiCurr[Multi-Currency]
RealTime[Real-time Processing]
Audit[Audit Trail]
Validation[Validation Rules]
MultiCurr --> Transaction
RealTime --> Transaction
Audit --> Transaction
Validation --> Transaction
end
```
* Account Management
* Multiple account types
* Custom account hierarchies
* Flexible account rules
* Real-time balance tracking
* Transaction Processing
* Real-time transaction processing
* Multi-currency support
* Transaction validation rules
* Audit trail and reconciliation
* Loan Management
* Flexible loan products
* Automated disbursement
* Repayment scheduling
* Collateral management
* Deposit Management
* Fixed and recurring deposits
* Interest calculation
* Maturity processing
* Early withdrawal handling
Ensure you have the necessary cloud provider credentials and permissions before starting the deployment process.
```mermaid theme={null}
flowchart TB
subgraph CloudProviders[Cloud Providers]
AWS[AWS]
Azure[Azure]
GCP[GCP]
K8s[Kubernetes]
AWS --> K8s
Azure --> K8s
GCP --> K8s
end
subgraph Infrastructure
Services[Core Services]
DB[(Database)]
Cache[(Cache)]
Queue[(Message Queue)]
K8s --> Services
Services --> DB
Services --> Cache
Services --> Queue
end
subgraph Monitoring
Prometheus[Prometheus]
Grafana[Grafana]
Logs[Log Aggregation]
Prometheus --> Services
Grafana --> Services
Logs --> Services
end
```
* AWS, Azure, GCP support
* Hybrid cloud capabilities
* Multi-region deployment
* Auto-scaling infrastructure
On-premises deployment is ideal for financial institutions with strict data residency requirements or regulatory compliance needs.
* Private cloud deployment
* Data center hosting
* Air-gapped environments
* Custom infrastructure support
Our API-first approach ensures seamless integration with your existing systems and third-party services.
* RESTful APIs
* GraphQL support
* WebSocket connections
* Batch processing APIs
* Payment gateways
* KYC/AML providers
* Credit bureaus
* Mobile banking platforms
Security is our top priority. All deployments include comprehensive security measures and regular security audits.
* End-to-end encryption
* Role-based access control
* Audit logging
* Fraud detection
* GDPR compliance
* PCI DSS support
* Regional banking regulations
* Data residency options
Make sure you have all the prerequisites installed and configured before starting the deployment process.
* Docker and Kubernetes knowledge
* Basic understanding of banking operations
* API integration experience
* Cloud platform familiarity
1. Set up your development environment
2. Deploy the core services
3. Configure your tenant
4. Start integrating with APIs
* API Reference
* Integration Guides
* Deployment Guides
* Security Guidelines
* Technical Documentation
* API Reference
* Integration Guides
* Community Forums
* Support Portal
## Next Steps
Explore the following sections to learn more about specific components:
* [Client Management](/modules/core-banking/clients)
* [Account Management](/modules/core-banking/accounts)
* [Transaction Processing](/modules/core-banking/transactions)
* [Loan Management](/modules/core-banking/loans)
* [Deposit Management](/modules/core-banking/deposits)
# Loan Management
Source: https://docs.woodcore.co/modules/core-banking/loans
Comprehensive loan management system supporting various loan types including BNPL, overdrafts, and traditional loans with flexible configuration options for fintechs.
The Loan Management module is a powerful system that enables financial institutions and fintechs to offer various credit products, from traditional loans to modern BNPL and overdraft facilities. It provides a flexible framework for managing the entire loan lifecycle with robust risk management capabilities.
## Loan Types & Features
```mermaid theme={null}
flowchart TB
subgraph LoanTypes[Loan Types]
Traditional[Traditional Loans]
BNPL[Buy Now Pay Later]
Overdraft[Overdraft Facility]
CreditLine[Credit Lines]
end
subgraph Features[Core Features]
Disbursement[Disbursement]
Repayment[Repayment]
Reschedule[Rescheduling]
Collateral[Collateral]
end
subgraph RiskManagement[Risk Management]
Scoring[Credit Scoring]
Monitoring[Portfolio Monitoring]
Recovery[Recovery]
Reporting[Reporting]
end
LoanTypes --> Features
Features --> RiskManagement
```
Modern credit solutions like BNPL and overdraft facilities are becoming increasingly popular in fintech applications, offering flexible credit options to customers.
### Buy Now Pay Later (BNPL)
```mermaid theme={null}
flowchart LR
subgraph BNPLFlow[BNPL Flow]
Purchase[Purchase Initiated]
Approval[Instant Approval]
Disbursement[Merchant Payment]
Repayment[Installment Repayment]
end
subgraph BNPLFeatures[BNPL Features]
SplitPay[Split Payments]
NoInterest[No Interest]
LateFees[Late Fees]
CreditLimit[Credit Limit]
end
BNPLFlow --> BNPLFeatures
```
BNPL solutions typically offer interest-free periods with late fees, making them attractive for short-term financing needs.
* Split payments into installments
* Interest-free periods
* Late fee management
* Credit limit controls
* Merchant integration
* Automated repayments
* Risk assessment
* Collection management
### Overdraft Facility
```mermaid theme={null}
flowchart LR
subgraph OverdraftFlow[Overdraft Flow]
Account[Account Balance]
Limit[Overdraft Limit]
Usage[Overdraft Usage]
Interest[Interest Calculation]
end
subgraph OverdraftFeatures[Overdraft Features]
AutoApproval[Auto Approval]
InterestCalc[Interest Calculation]
Repayment[Repayment]
LimitMgmt[Limit Management]
end
OverdraftFlow --> OverdraftFeatures
```
Overdraft facilities should be carefully managed with appropriate limits and interest rates to prevent excessive usage.
* Automatic approval
* Interest calculation
* Limit management
* Repayment scheduling
* Usage monitoring
* Risk assessment
* Collection management
Traditional loans provide structured financing options for various purposes with defined terms and conditions.
### Personal Loans
* Unsecured financing
* Fixed interest rates
* EMI-based repayment
* Flexible tenures
* Quick disbursement
* Credit scoring
* Documentation management
### Business Loans
* Working capital
* Term loans
* Equipment financing
* Invoice financing
* Business credit lines
* Collateral management
* Financial analysis
### Mortgage Loans
* Property financing
* Long-term loans
* Collateral management
* Interest rate options
* Repayment schedules
* Insurance integration
* Property valuation
## Loan Lifecycle Management
```mermaid theme={null}
flowchart TD
subgraph Application[Application Phase]
Apply[Apply]
Assess[Assess]
Approve[Approve]
end
subgraph Active[Active Phase]
Disburse[Disburse]
Monitor[Monitor]
Collect[Collect]
end
subgraph Management[Management Phase]
Reschedule[Reschedule]
Restructure[Restructure]
Close[Close]
end
Application --> Active
Active --> Management
```
### Disbursement
Loan disbursement can be automated for certain loan types like BNPL and overdrafts, while traditional loans may require manual approval.
* Automated disbursement
* Manual approval workflow
* Multi-account disbursement
* Payment tracking
* Disbursement scheduling
* Fee calculation
* Documentation verification
### Repayment Management
Effective repayment management is crucial for maintaining portfolio health and ensuring timely collections.
* EMI calculation
* Payment scheduling
* Auto-debit setup
* Payment tracking
* Late payment handling
* Prepayment processing
* Interest adjustment
### Rescheduling & Restructuring
Loan rescheduling should be carefully evaluated to ensure it doesn't increase portfolio risk.
* Term extension
* EMI adjustment
* Interest rate modification
* Payment holiday
* Principal reduction
* Collateral adjustment
* Documentation update
## Risk & Compliance
```mermaid theme={null}
flowchart LR
subgraph RiskManagement[Risk Management]
Scoring[Credit Scoring]
Monitoring[Portfolio Monitoring]
Recovery[Recovery]
end
subgraph Compliance[Compliance]
KYC[KYC Verification]
Reporting[Regulatory Reporting]
Audit[Audit Trail]
end
subgraph Security[Security]
Access[Access Control]
Fraud[Fraud Prevention]
Encryption[Data Encryption]
end
RiskManagement --> Compliance
Compliance --> Security
```
### Credit Assessment
* Credit scoring
* Income verification
* Employment check
* Credit history
* Risk rating
* Limit calculation
* Portfolio analysis
### Portfolio Monitoring
* Performance tracking
* Risk indicators
* Early warning
* Collection efficiency
* Portfolio health
* Risk concentration
* Market analysis
### Recovery Management
* Collection strategies
* Payment reminders
* Legal action
* Settlement options
* Recovery tracking
* Agent management
* Performance reporting
## Integration & APIs
The Loan Management module provides comprehensive APIs for fintechs to integrate credit services into their applications.
* RESTful APIs
* WebSocket support
* Batch processing
* Real-time updates
* Event notifications
* Webhook integration
* SDK support
## Next Steps
Explore related modules to learn more about:
* [Account Management](/modules/core-banking/accounts)
* [Transaction Processing](/modules/core-banking/transactions)
* [Risk Management](/modules/core-banking/risk)
* [Payment Systems](/modules/core-banking/payments)
# Product Management
Source: https://docs.woodcore.co/modules/core-banking/products
Comprehensive product management system for configuring and managing banking products including loans, deposits, and fixed assets with flexible parameters and rules.
The Product Management module is the foundation for creating and managing banking products, enabling financial institutions to configure and deploy various financial products with specific rules and parameters.
## Overview
The Product Management module provides a comprehensive framework for creating and managing banking products. From loan products to deposit accounts and fixed assets, the system enables flexible product configuration with specific rules, parameters, and pricing structures.
Loan products can be configured with specific parameters, rules, and pricing structures to meet various lending needs.
### Product Parameters
* Loan types (Personal, Business, Mortgage)
* Interest rate types (Fixed, Variable, Hybrid)
* Repayment schedules
* Loan terms
* Collateral requirements
* Eligibility criteria
* Pricing rules
### Loan Features
Loan products can be customized with specific features to meet different customer segments and business needs.
* Amortization methods
* Interest calculation
* Fee structure
* Early repayment rules
* Late payment handling
* Restructuring options
* Insurance requirements
```mermaid theme={null}
flowchart TB
subgraph LoanTypes[Loan Types]
Personal[Personal Loan]
Business[Business Loan]
Mortgage[Mortgage]
Asset[Asset Finance]
end
subgraph Parameters[Parameters]
Rate[Interest Rate]
Term[Loan Term]
Schedule[Repayment Schedule]
Collateral[Collateral]
end
subgraph Rules[Rules]
Eligibility[Eligibility]
Pricing[Pricing]
Processing[Processing]
Monitoring[Monitoring]
end
LoanTypes --> Parameters
Parameters --> Rules
```
Deposit products can be configured with specific interest rates, terms, and features to attract different customer segments.
### Product Parameters
* Account types (Savings, Current, Fixed)
* Interest rate types
* Minimum balance
* Transaction limits
* Withdrawal rules
* Interest calculation
* Fee structure
### Deposit Features
Deposit products must comply with regulatory requirements and customer protection rules.
* Interest payment frequency
* Early withdrawal penalties
* Account maintenance
* Transaction limits
* Statement generation
* Online access
* Mobile banking
```mermaid theme={null}
flowchart LR
subgraph DepositTypes[Deposit Types]
Savings[Savings]
Current[Current]
Fixed[Fixed Deposit]
Recurring[Recurring]
end
subgraph Features[Features]
Interest[Interest]
Limits[Limits]
Access[Access]
Services[Services]
end
subgraph Rules[Rules]
Eligibility[Eligibility]
Pricing[Pricing]
Processing[Processing]
Monitoring[Monitoring]
end
DepositTypes --> Features
Features --> Rules
```
Fixed asset products can be configured for various types of asset financing with specific terms and conditions.
### Product Parameters
* Asset types
* Financing terms
* Depreciation methods
* Insurance requirements
* Maintenance schedules
* Disposal rules
* Valuation methods
### Asset Features
Fixed asset products can be customized based on asset type and customer requirements.
* Asset tracking
* Depreciation calculation
* Maintenance scheduling
* Insurance management
* Disposal processing
* Reporting
* Analytics
```mermaid theme={null}
flowchart TD
subgraph AssetTypes[Asset Types]
Equipment[Equipment]
Vehicles[Vehicles]
Property[Property]
Machinery[Machinery]
end
subgraph Management[Management]
Track[Tracking]
Depreciate[Depreciation]
Maintain[Maintenance]
Dispose[Disposal]
end
subgraph Reporting[Reporting]
Value[Valuation]
Report[Reports]
Audit[Audit]
Analytics[Analytics]
end
AssetTypes --> Management
Management --> Reporting
```
## Product Configuration
Product configuration involves setting up specific parameters, rules, and features for each product type.
### Configuration Elements
* Product parameters
* Pricing rules
* Eligibility rules
* Processing rules
* Documentation requirements
* Regulatory compliance
* Reporting requirements
### Product Lifecycle
1. Product creation
2. Parameter configuration
3. Rule setup
4. Testing and validation
5. Product activation
6. Monitoring and maintenance
7. Product deactivation
## Integration Points
The Product Management module integrates with:
* Account Management
* Client Management
* Transaction Processing
* Risk Management
* Reporting Systems
* Marketing Systems
* Compliance Systems
## Next Steps
Explore related modules to learn more about:
* [Account Management](/modules/core-banking/accounts)
* [Transaction Processing](/modules/core-banking/transactions)
* [Charges Management](/modules/core-banking/charges)
* [Compliance Management](/modules/core-banking/compliance)
# Transaction Processing
Source: https://docs.woodcore.co/modules/core-banking/transactions
Comprehensive transaction processing system handling all financial transactions including deposits, withdrawals, liens, holds, and automated processes.
The Transaction Processing module is the heart of the core banking system, handling all financial transactions with real-time processing capabilities, automated workflows, and robust security measures.
## Overview
The Transaction Processing module provides a comprehensive framework for handling all types of financial transactions in the core banking system. From basic deposits and withdrawals to complex automated processes, the system ensures secure, efficient, and compliant transaction processing.
The system supports various transaction types, each with specific processing requirements and security measures.
### Deposit Transactions
* Cash deposits
* Check deposits
* Electronic transfers
* Interest calculations
* Automated posting
* Statement updates
* Receipt generation
* Transaction history
### Withdrawal Transactions
* Cash withdrawals
* Check payments
* Electronic debits
* Standing orders
* Direct debits
* ATM withdrawals
* Mobile withdrawals
### Account Holds & Liens
* PND (Post No Debit)
* PNC (Post No Credit)
* ISO (International Standard Organization)
* Liens
* Legal holds
* Administrative holds
* System holds
```mermaid theme={null}
flowchart TB
subgraph TransactionTypes[Transaction Types]
Deposit[Deposits]
Withdrawal[Withdrawals]
Transfer[Transfers]
Hold[Account Holds]
Lien[Liens]
end
subgraph Processing[Processing Types]
RealTime[Real-time]
Batch[Batch]
Automated[Automated]
Scheduled[Scheduled]
end
subgraph Security[Security]
Validation[Validation]
Limits[Limits]
Audit[Audit]
Fraud[Fraud]
end
TransactionTypes --> Processing
Processing --> Security
```
Deposit transactions are fundamental to banking operations, supporting various deposit types and automated interest calculations.
### Deposit Features
* Cash deposits
* Check deposits
* Electronic transfers
* Interest calculations
* Automated posting
* Statement updates
* Receipt generation
* Transaction history
### Interest Processing
Interest calculations can be automated for various account types with different interest rate structures.
* Daily interest calculation
* Monthly interest posting
* Interest rate management
* Interest tax handling
* Interest statements
* Interest adjustments
* Interest reversals
```mermaid theme={null}
flowchart LR
subgraph DepositTypes[Deposit Types]
Cash[Cash Deposit]
Check[Check Deposit]
Transfer[Transfer Deposit]
Interest[Interest Credit]
end
subgraph Processing[Processing]
Validation[Validation]
Posting[Posting]
InterestCalc[Interest Calculation]
Statement[Statement Update]
end
DepositTypes --> Processing
```
Withdrawal transactions include various types of debits from accounts with appropriate validations and limits.
### Withdrawal Controls
All withdrawals are subject to account limits, available balance, and security controls.
* Balance verification
* Limit checks
* Security validation
* Transaction limits
* Channel restrictions
* Time restrictions
* Geographic restrictions
Account holds and liens are crucial for managing account restrictions and securing funds for specific purposes.
### Hold Management
* Place holds
* Modify holds
* Release holds
* Hold reporting
* Hold history
* Hold notifications
* Hold documentation
```mermaid theme={null}
flowchart TD
subgraph HoldTypes[Hold Types]
PND[PND Hold]
PNC[PNC Hold]
ISO[ISO Hold]
Lien[Lien]
end
subgraph Operations[Operations]
Place[Place Hold]
Modify[Modify Hold]
Release[Release Hold]
Report[Report]
end
HoldTypes --> Operations
```
## Transaction Automation
The system provides comprehensive automation capabilities for various transaction types and processes.
### Scheduled Transactions
* Standing orders
* Direct debits
* Interest payments
* Fee calculations
* Statement generation
* Report generation
* Reconciliation
### Batch Processing
Batch processing is used for high-volume transactions that don't require real-time processing.
* End-of-day processing
* Interest calculations
* Fee assessments
* Statement generation
* Report generation
* Reconciliation
* System maintenance
### Conditional Processing
* Balance-based triggers
* Time-based triggers
* Event-based triggers
* Threshold-based triggers
* Rule-based processing
* Exception handling
* Notification generation
```mermaid theme={null}
flowchart LR
subgraph Automation[Automation Types]
Scheduled[Scheduled]
Recurring[Recurring]
Conditional[Conditional]
Batch[Batch]
end
subgraph Processing[Processing]
Validation[Validation]
Execution[Execution]
Confirmation[Confirmation]
Reporting[Reporting]
end
subgraph Monitoring[Monitoring]
Status[Status]
Alerts[Alerts]
Logs[Logs]
Reports[Reports]
end
Automation --> Processing
Processing --> Monitoring
```
## Security & Compliance
All transactions are subject to comprehensive security measures and validations to prevent fraud and ensure compliance.
* Multi-factor authentication
* Transaction limits
* Risk scoring
* Fraud detection
* Audit logging
* Compliance checks
* Security monitoring
## Integration Points
The Transaction Processing module integrates with various systems to provide comprehensive banking services.
* Account Management
* Client Management
* Payment Systems
* Reporting Systems
* Reconciliation Systems
* Security Systems
* Compliance Systems
## Next Steps
Explore related modules to learn more about:
* [Account Management](/modules/core-banking/accounts)
* [Client Management](/modules/core-banking/clients)
* [Payment Systems](/modules/core-banking/payments)
* [Security & Compliance](/modules/core-banking/security)
# Digital Accounts
Source: https://docs.woodcore.co/modules/digital-services/accounts
The Digital Account Management component provides comprehensive capabilities for managing customer accounts through digital channels.
## Account Types
* Savings Accounts
* Current Accounts
* Fixed Deposit Accounts
* Investment Accounts
* Digital Wallets
* Business Current Accounts
* Business Savings Accounts
* Corporate Accounts
* Merchant Accounts
* Escrow Accounts
## Account Features
```mermaid theme={null}
graph TD
A[Account Management] --> B[Account Opening]
A --> C[Account Maintenance]
A --> D[Account Services]
A --> E[Account Security]
B --> F[Digital KYC]
B --> G[Document Upload]
C --> H[Profile Updates]
C --> I[Preferences]
D --> J[Statements]
D --> K[Notifications]
E --> L[Access Control]
E --> M[Security Settings]
```
## Key Capabilities
| Capability | Description | Features |
| ----------------------- | -------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| **Account Opening** | Initial account setup and verification | • Digital KYC verification
• Document management
• Account type selection
• Initial deposit processing
• Account activation |
| **Account Maintenance** | Ongoing account management | • Profile updates
• Account preferences
• Service subscriptions
• Document updates
• Account status management |
| **Account Services** | Customer service and support features | • Statement generation
• Transaction history
• Account alerts
• Service requests
• Account closure |
> ℹ️ **Digital Account Features**
>
> All account management features are available through multiple digital channels including mobile apps, internet banking, and API access. This ensures customers can manage their accounts conveniently through their preferred platform.
## Security Features
* Multi-factor authentication
* Role-based access
* Session management
* Device management
* IP restrictions
* Transaction limits
* Approval workflows
* Fraud monitoring
* Alert notifications
* Activity logging
> ⚠️ **Important Security Note**
>
> Ensure proper KYC verification and security measures are in place before enabling account access through digital channels. This includes thorough identity verification, risk assessment, and compliance checks.
# Digital Deposits
Source: https://docs.woodcore.co/modules/digital-services/deposits
Modern digital deposit management system providing comprehensive account management, automated deposit processing, and secure digital banking capabilities. Features include real-time deposit processing, multi-currency support, and integrated account services.
The Digital Deposit Services component provides comprehensive capabilities for managing deposit products and services through digital channels. This modern banking solution enables customers to manage their savings and investments efficiently through various digital platforms, offering convenience and flexibility in managing their financial assets.
## Deposit Types
* Fixed Deposits: Long-term investment options with guaranteed returns
* Term Deposits: Flexible duration deposits with competitive interest rates
* Certificate of Deposits: Secure investment instruments with fixed terms
* Structured Deposits: Customized investment products with market-linked returns
* Call Deposits: Flexible deposits with instant access to funds
* Savings Accounts: Interest-bearing accounts for personal savings
* Current Accounts: Transaction accounts for daily banking needs
* Money Market Accounts: High-yield accounts with check-writing privileges
* Digital Wallets: Electronic payment and storage solutions
* Escrow Accounts: Secure holding accounts for third-party transactions
## Deposit Process
```mermaid theme={null}
graph TD
A[Account Selection] --> B[Deposit Creation]
B --> C[Fund Transfer]
C --> D[Confirmation]
D --> E[Certificate]
E --> F[Management]
style A fill:#f9f,stroke:#333,stroke-width:2px
style F fill:#9f9,stroke:#333,stroke-width:2px
```
## Key Capabilities
| Capability | Description | Features |
| ---------------------- | ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Deposit Creation** | Initial deposit setup and processing | • Comprehensive product selection with detailed comparisons
• Flexible term selection with rate optimization
• Advanced rate calculation with market analysis
• Secure fund transfer system
• Digital certificate generation and storage |
| **Deposit Management** | Ongoing deposit account management | • Real-time balance tracking and monitoring
• Automated interest calculation and crediting
• Proactive maturity management
• Streamlined renewal processing
• Simplified early withdrawal procedures |
| **Deposit Services** | Customer service and support features | • Automated statement generation and delivery
• Scheduled interest payment processing
• Secure deposit transfer capabilities
• Comprehensive lien management
• Efficient closure processing |
> ℹ️ **Digital Deposit Features**
>
> Our digital deposit services are accessible through multiple channels including mobile applications, internet banking, and API interfaces. The system provides automated processing capabilities, ensuring efficient management of deposit accounts and timely service delivery.
## Security Features
* Multi-layer fund transfer security
* Dynamic transaction limits
* Multi-level approval workflows
* Advanced fraud prevention
* Real-time security alerts
* Role-based access control
* Multi-factor authentication
* Comprehensive activity monitoring
* Secure document management
* Detailed audit logging
> ⚠️ **Important Security Note**
>
> Before processing any deposit transactions, it is essential to ensure that all necessary security measures and compliance requirements are properly implemented. This includes thorough verification processes, transaction monitoring, and regulatory compliance checks.
> 💡 **Integration Note**
>
> The Digital Deposit Services module integrates with multiple systems to provide a seamless experience:
>
> * Core Banking System for seamless transaction processing
> * Document Management System for secure file handling
> * Authentication Systems for user verification
> * Notification Systems for real-time updates
> * Reporting Systems for comprehensive analytics
# Digital Service
Source: https://docs.woodcore.co/modules/digital-services/intro
The Digital Services module is the cornerstone of Woodcore's digital banking transformation, providing a comprehensive suite of digital banking capabilities that enable financial institutions to deliver seamless banking experiences across multiple channels.
:::tip Digital Banking Evolution
Woodcore's Digital Services module is designed to help financial institutions transition from traditional banking to modern digital banking, ensuring they stay competitive in today's rapidly evolving financial landscape.
:::
## Key Features
* Self-service account opening
* Account maintenance and updates
* Digital KYC and onboarding
* Account preferences management
* Document management
* Real-time transaction processing
* Multi-currency support
* Transaction scheduling
* Standing instructions
* Transaction limits management
* Digital loan applications
* Loan status tracking
* Digital loan disbursement
* Loan repayment management
* Loan statement generation
* P2P transfers
* Bill payments
* Merchant payments
* International remittances
* Payment scheduling
## Digital Channels
```mermaid theme={null}
graph TD
A[Digital Services] --> B[Mobile Banking]
A --> C[Internet Banking]
A --> D[SMS Banking]
A --> E[USSD Banking]
A --> F[API Banking]
A --> G[Digital Kiosks]
B --> H[Android App]
B --> I[iOS App]
C --> J[Web Portal]
C --> K[Responsive Design]
```
## Security Architecture
* Multi-factor Authentication (MFA)
* Biometric Authentication
* OTP-based verification
* Device fingerprinting
* Risk-based authentication
* End-to-end encryption
* Secure key management
* Data masking
* Secure session handling
* Audit logging
* Real-time fraud monitoring
* Transaction screening
* Behavioral analytics
* Risk scoring
* Alert management
## System Integration
```mermaid theme={null}
graph LR
A[Digital Services] --> B[Core Banking]
A --> C[Payment Systems]
A --> D[Security Systems]
A --> E[Notification Systems]
A --> F[Analytics Systems]
style A fill:#f9f,stroke:#333,stroke-width:4px
```
:::note Integration Capabilities
The Digital Services module is designed with a microservices architecture, allowing seamless integration with existing systems while maintaining high performance and scalability.
:::
## Getting Started
1. **System Requirements**
* Core Banking System Integration
* Security Infrastructure
* Network Infrastructure
* Database Systems
2. **Implementation Steps**
* System Assessment
* Integration Planning
* Security Configuration
* Channel Setup
* Testing and Validation
3. **Deployment Options**
* Cloud Deployment
* On-premise Deployment
* Hybrid Deployment
:::warning Important Note
Ensure all security measures are properly configured before going live with any digital channel.
:::
# Digital Loans
Source: https://docs.woodcore.co/modules/digital-services/loans
Advanced digital lending solution offering comprehensive loan management, automated processing, and secure digital loan origination. Features include multi-channel loan applications, real-time risk assessment, and integrated payment processing.
The Digital Loan Services component provides comprehensive capabilities for managing loan products and services through digital channels. This modern banking solution enables customers to access various loan products, manage their applications, and handle loan-related transactions entirely through digital platforms.
## Loan Types
* Personal Loans: Flexible financing options for individual needs
* Education Loans: Specialized funding for academic pursuits
* Vehicle Loans: Financing solutions for automobile purchases
* Home Improvement Loans: Funding for property renovations and upgrades
* Emergency Loans: Quick access to funds for urgent situations
* Business Loans: Comprehensive financing for business operations
* Working Capital Loans: Short-term funding for daily operations
* Equipment Financing: Specialized loans for business equipment
* Trade Finance: Solutions for international trade activities
* Project Finance: Long-term funding for major business projects
## Loan Process
```mermaid theme={null}
graph TD
A[Loan Application] --> B[Eligibility Check]
B --> C[Documentation]
C --> D[Underwriting]
D --> E[Approval]
E --> F[Disbursement]
style A fill:#f9f,stroke:#333,stroke-width:2px
style F fill:#9f9,stroke:#333,stroke-width:2px
```
## Key Capabilities
| Capability | Description | Features |
| -------------------- | --------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Loan Application** | Digital loan application and processing | • Digital application forms with intuitive user interface
• Advanced eligibility calculator with real-time assessment
• Secure document upload system with multiple format support
• Comprehensive application tracking with status updates
• Automated status notifications and follow-ups |
| **Loan Processing** | Automated loan processing and decision making | • Automated underwriting with AI-powered decision making
• Comprehensive credit assessment and scoring
• Advanced risk scoring algorithms
• Multi-level approval workflows
• Streamlined disbursement processing |
| **Loan Management** | Ongoing loan servicing and management | • Flexible repayment scheduling options
• Automated payment processing system
• Detailed statement generation and delivery
• Dynamic loan restructuring capabilities
• Simplified early settlement processing |
> ℹ️ **Digital Loan Features**
>
> Our digital loan services are accessible through multiple channels including mobile applications, internet banking, and API interfaces. The system provides automated processing capabilities, ensuring quick turnaround times and efficient service delivery.
## Security Features
* Advanced document verification system
* Multi-factor identity verification
* Comprehensive credit checks
* Sophisticated risk assessment
* Real-time fraud prevention
* Multi-layer payment authentication
* Real-time transaction monitoring
* Secure disbursement protocols
* Automated repayment tracking
* Proactive security alerts
> ⚠️ **Important Security Note**
>
> Before processing any loan applications, it is crucial to ensure that all necessary security measures and compliance requirements are properly implemented. This includes thorough verification processes, risk assessment protocols, and regulatory compliance checks.
> 💡 **Integration Note**
>
> The Digital Loan Services module integrates with multiple systems to provide a seamless experience:
>
> * Core Banking System for seamless transaction processing
> * Document Management System for secure file handling
> * Authentication Systems for user verification
> * Notification Systems for real-time updates
> * Reporting Systems for comprehensive analytics
# Digital Payments
Source: https://docs.woodcore.co/modules/digital-services/payments
Comprehensive digital payment solution offering secure payment processing, blockchain integration, and multi-channel payment capabilities. Features include real-time payment processing, cryptocurrency support, and advanced payment security measures.
The Digital Payment Services component provides comprehensive capabilities for processing and managing various types of payments through digital channels. This modern banking solution enables customers to conduct secure and efficient financial transactions across multiple platforms, offering convenience and flexibility in managing their payment needs.
## Payment Types
* P2P Transfers: Instant person-to-person money transfers
* Bill Payments: Automated utility and service bill payments
* Merchant Payments: Secure business-to-consumer transactions
* Utility Payments: Scheduled payments for essential services
* Government Payments: Official payment processing for government services
* International Remittances: Cross-border money transfers
* Foreign Exchange: Currency conversion and transfer services
* Cross-border Payments: Global business transaction processing
* Trade Payments: International trade settlement services
* SWIFT Transfers: Secure international wire transfers
* Cryptocurrency Transfers: Secure digital currency transactions
* Smart Contract Payments: Automated contract-based payments
* Tokenized Assets: Digital asset transfer and management
* Cross-chain Transactions: Interoperable blockchain transfers
* DeFi Payments: Decentralized finance transactions
## Payment Process
```mermaid theme={null}
graph TD
A[Payment Initiation] --> B[Validation]
B --> C[Processing]
C --> D[Routing]
D --> E[Execution]
E --> F[Confirmation]
style A fill:#f9f,stroke:#333,stroke-width:2px
style F fill:#9f9,stroke:#333,stroke-width:2px
```
## Key Capabilities
| Capability | Description | Features |
| ---------------------- | ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Payment Processing** | Core payment handling and execution | • Real-time payment processing with instant confirmation
• Efficient batch processing for multiple transactions
• Flexible scheduled payment management
• Automated recurring payment handling
• Intelligent payment routing optimization |
| **Payment Management** | Comprehensive payment oversight | • Comprehensive payment tracking system
• Real-time status monitoring
• Dynamic payment limits management
• Multi-level approval workflows
• Detailed payment history and analytics |
| **Payment Services** | Advanced payment features and support | • Multi-currency support with real-time rates
• Competitive exchange rate calculations
• Transparent fee structure and calculation
• Automated settlement processing
• Comprehensive reconciliation services |
> ℹ️ **Digital Payment Features**
>
> Our digital payment services are accessible through multiple channels including mobile applications, internet banking, and API interfaces. The system provides real-time processing capabilities, ensuring quick and efficient payment execution across all supported channels.
## Woodcore Integration
| Integration Type | Description | Benefits |
| ----------------------- | ---------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Traditional Banking** | Integration with core banking systems | • Seamless transaction processing
• Real-time account updates
• Automated reconciliation
• Comprehensive reporting
• Regulatory compliance |
| **Blockchain Payments** | Support for cryptocurrency and smart contracts | • Multi-cryptocurrency support
• Smart contract integration
• Cross-chain compatibility
• DeFi protocol support
• Secure wallet management |
| **Payment Gateways** | Integration with payment processors | • Multiple payment methods
• Global payment networks
• Real-time processing
• Fraud prevention
• Settlement automation |
> 💡 **Woodcore Blockchain Capabilities**
>
> Woodcore provides comprehensive blockchain payment solutions:
>
> * Support for multiple cryptocurrencies and tokens
> * Integration with major blockchain networks
> * Smart contract execution and management
> * Cross-chain transaction capabilities
> * DeFi protocol integration
> * Secure digital asset management
> * Real-time blockchain transaction monitoring
> * Automated compliance and reporting
## Security Features
* Multi-factor payment authentication
* Advanced fraud detection systems
* Real-time risk scoring
* Dynamic transaction limits
* Proactive security alerts
* Comprehensive payment monitoring
* Automated regulatory reporting
* Detailed audit logging
* Real-time compliance checks
* Advanced risk management
> ⚠️ **Important Security Note**
>
> Before processing any live payments, it is crucial to ensure that all necessary security measures and compliance requirements are properly implemented. This includes thorough verification processes, transaction monitoring, and regulatory compliance checks.
## Payment Management
| Function | Description | Features |
| ---------------------- | ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------- |
| **Payment Initiation** | Secure payment creation | • Multi-factor authentication
• Real-time validation
• Risk assessment
• Compliance checks
• Transaction limits |
| **Payment Processing** | Efficient transaction handling | • Real-time processing
• Automated routing
• Status tracking
• Error handling
• Confirmation delivery |
| **Payment Monitoring** | Comprehensive oversight | • Real-time tracking
• Status updates
• Alert management
• Performance metrics
• Compliance monitoring |
> 🔄 **Integration Note**
>
> The Digital Payment Services module integrates with multiple systems to provide a seamless experience:
>
> * Core Banking System for seamless transaction processing
> * Payment Gateways for secure transaction routing
> * Authentication Systems for user verification
> * Notification Systems for real-time updates
> * Reporting Systems for comprehensive analytics
> * Blockchain Networks for cryptocurrency support
> * Smart Contract Platforms for automated payments
> * DeFi Protocols for decentralized finance
# Digital Transactions
Source: https://docs.woodcore.co/modules/digital-services/transactions
The Digital Transaction Management component provides comprehensive capabilities for processing and managing financial transactions through digital channels.
## Transaction Types
* Fund Transfers
* Bill Payments
* Standing Instructions
* Recurring Payments
* Scheduled Payments
* P2P Transfers
* Merchant Payments
* International Remittances
* QR Code Payments
* Contactless Payments
## Transaction Flow
```mermaid theme={null}
graph LR
A[Transaction Initiation] --> B[Validation]
B --> C[Processing]
C --> D[Authorization]
D --> E[Execution]
E --> F[Confirmation]
style A fill:#f9f,stroke:#333,stroke-width:2px
style F fill:#9f9,stroke:#333,stroke-width:2px
```
## Key Capabilities
| Capability | Description | Features |
| -------------------------- | -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| **Transaction Processing** | Core transaction handling capabilities | • Real-time processing
• Batch processing
• Scheduled transactions
• Recurring transactions
• Transaction routing |
| **Transaction Management** | Comprehensive transaction oversight | • Transaction monitoring
• Status tracking
• Transaction limits
• Approval workflows
• Transaction history |
| **Payment Processing** | Advanced payment handling features | • Multiple payment methods
• Currency conversion
• Fee calculation
• Payment routing
• Settlement processing |
## Transaction Features
All transaction features are available through multiple digital channels with real-time processing capabilities.
## Security Features
* Transaction authentication
* Fraud detection
* Risk scoring
* Transaction limits
* Security alerts
* Transaction monitoring
* Regulatory reporting
* Audit logging
* Compliance checks
* Risk management
> ⚠️ **Important Security Note**
>
> Ensure proper transaction security measures and compliance requirements are in place before processing live transactions. This includes thorough verification processes, transaction monitoring, and regulatory compliance checks.
# Orchestrator
Source: https://docs.woodcore.co/modules/orchestrator/intro
Advanced system orchestration and service bus solution providing comprehensive workflow management, service integration, and system coordination capabilities. Features include microservices orchestration, event-driven architecture, and real-time system monitoring.
The Orchestrator module serves as the central nervous system of Woodcore's banking platform, managing and coordinating complex workflows across different modules and systems. It ensures seamless integration and communication between various banking services while maintaining high performance and reliability.
> 💡 **System Orchestration**
>
> The Orchestrator module is the backbone of Woodcore's microservices architecture, enabling efficient service coordination and workflow management across the entire banking platform. It provides a robust service bus layer that allows for flexible integration and extension of banking capabilities.
## Core Capabilities
| Capability | Description | Features |
| -------------------------- | -------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| **Workflow Management** | Process orchestration and coordination | • Process orchestration
• Service coordination
• Task scheduling
• Workflow monitoring
• Error handling |
| **Integration Management** | Service integration and communication | • Service discovery
• API management
• Protocol translation
• Message routing
• Load balancing |
| **Event Management** | Event-driven architecture support | • Event processing
• Event routing
• Event persistence
• Event monitoring
• Event recovery |
| **System Monitoring** | Comprehensive system oversight | • Performance monitoring
• Health checks
• Resource utilization
• Alert management
• Logging and tracing |
## Service Bus Architecture
```mermaid theme={null}
graph TD
A[Orchestrator] --> B[Digital Services]
A --> C[Lending]
A --> D[Card Services]
A --> E[Core Banking]
A --> F[External Systems]
B --> G[Service Bus]
C --> G
D --> G
E --> G
F --> G
style A fill:#f9f,stroke:#333,stroke-width:4px
style G fill:#9f9,stroke:#333,stroke-width:2px
```
> 🔄 **Service Bus Layer**
>
> Woodcore's service bus layer provides a powerful foundation for building and extending banking capabilities:
>
> * Message-based communication between services
> * Event-driven architecture support
> * Protocol-agnostic service integration
> * Real-time data streaming capabilities
> * Asynchronous processing support
> * Service discovery and registration
> * Dynamic routing and load balancing
> * Message transformation and enrichment
## Key Features
| Feature Category | Description | Components |
| ---------------------------- | ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------- |
| **Service Orchestration** | Microservices coordination | • Microservices coordination
• Service discovery
• Load balancing
• Circuit breaking
• Service mesh integration |
| **Workflow Management** | Process automation and control | • Process automation
• Task scheduling
• State management
• Error recovery
• Transaction management |
| **Integration Capabilities** | System integration features | • API gateway
• Protocol translation
• Message transformation
• Service routing
• Security management |
| **Monitoring and Analytics** | System oversight and analysis | • Performance metrics
• System health
• Resource utilization
• Error tracking
• Usage analytics |
## Integration Points
```mermaid theme={null}
graph LR
A[Orchestrator] --> B[Core Banking]
A --> C[Digital Services]
A --> D[Lending]
A --> E[Card Services]
A --> F[External APIs]
style A fill:#f9f,stroke:#333,stroke-width:4px
```
> ℹ️ **System Integration**
>
> The Orchestrator module provides a unified interface for all system integrations, ensuring consistent communication and data flow across the entire banking platform. The service bus layer enables:
>
> * Seamless integration with legacy systems
> * Real-time data synchronization
> * Bi-directional communication
> * Protocol translation
> * Message transformation
> * Service discovery
> * Load balancing
> * Circuit breaking
## Technology Extension Capabilities
| Extension Type | Description | Benefits |
| ------------------- | ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Custom Services** | Build and deploy new services | • Rapid service development
• Standardized integration
• Automated deployment
• Service monitoring
• Performance optimization |
| **API Extensions** | Extend existing APIs | • API versioning
• Custom endpoints
• Enhanced security
• Rate limiting
• Documentation |
| **Event Handlers** | Custom event processing | • Event subscription
• Custom processing
• Event transformation
• Error handling
• Monitoring |
> 💡 **Technology Advancement**
>
> Woodcore's service bus layer enables organizations to:
>
> * Build custom services on top of core banking
> * Integrate with emerging technologies
> * Implement new payment methods
> * Add blockchain capabilities
> * Deploy AI/ML services
> * Create custom workflows
> * Extend existing functionality
> * Implement new business rules
## Security and Performance
| Aspect | Features | Capabilities |
| ------------------------ | ------------------- | --------------------------------------------------------------------------------------------------------- |
| **Security Features** | System protection | • API security
• Authentication
• Authorization
• Encryption
• Audit logging |
| **Performance Features** | System optimization | • Caching
• Load balancing
• Rate limiting
• Circuit breaking
• Resource optimization |
> ⚠️ **Important Note**
>
> Ensure proper configuration of service endpoints and security policies before deploying the Orchestrator in production. This includes:
>
> * Service endpoint configuration
> * Security policy implementation
> * Performance tuning
> * Monitoring setup
> * Backup and recovery procedures
# Approve Key
Source: https://docs.woodcore.co/security/endpoint/approve
POST /gateway/apiKeys/ipwhitelist/approve/{otp}
This endpoint approves a whitelisted IP address with the use of an OTP in the path sent to the user's email address as an extra layer of security.
# Security Endpoints
Source: https://docs.woodcore.co/security/endpoint/introduction
API endpoints for managing security and access control
The security endpoints provide essential functionality for managing API access, IP whitelisting, and monitoring the health of the API gateway. These endpoints are crucial for maintaining a secure and controlled environment for your API integrations.
**Important**: All security endpoints (except health check) require a valid API key in the Authorization header. Make sure to include the `Bearer` token in your requests.
Manage IP whitelisting for your API keys. This endpoint allows you to add IP addresses that are authorized to make API calls, providing an additional layer of security.
View detailed information about your API keys, including permissions, associated users, and usage statistics. Essential for monitoring and auditing API access.
Monitor the status and availability of the API gateway. This public endpoint helps you verify that the service is operational and responding correctly.
Remove IP addresses from the whitelist when they are no longer needed or when you need to revoke access. Important for maintaining security when IP addresses change.
**Best Practice**: Regularly review your IP whitelist and API key usage to ensure only authorized systems have access to your API endpoints.
## Security Considerations
When working with these endpoints, keep in mind:
1. **IP Whitelisting**: Always whitelist only the necessary IP addresses to minimize the attack surface
2. **API Key Management**: Rotate API keys periodically and remove unused keys
3. **Monitoring**: Use the health check endpoint to monitor service availability
4. **Audit Trail**: Regularly review key profiles to track API usage and detect any suspicious activity
For additional security features or custom requirements, please contact our support team at [compliance@woodcore.co](mailto:compliance@woodcore.co)
# Create IP Whitelist
Source: https://docs.woodcore.co/security/endpoint/ipwhitelist
POST /gateway/apiKeys/ipwhitelist
This endpoint is responsible for whitelisting an IP address which is to be attached to a particular API KEY.
This endpoint is responsible for whitelisting an IP address which is to be attached to a particular API KEY. This adds an extra layer of security by ensuring that API calls can only be made from approved IP addresses.
The IP address must be approved using the OTP sent to the user's email address before it becomes active.
# Key Profile
Source: https://docs.woodcore.co/security/endpoint/keyprofile
GET /gateway/keyprofile
Fetch the details associated with an API KEY with this endpoint.
Fetch the details associated with an API KEY with this endpoint. This includes information about the key's permissions, associated user, and usage statistics.
This endpoint requires a valid API key in the Authorization header.
# Authentication
Source: https://docs.woodcore.co/start/authentication
Guide to authentication and authorization of Woodcore API access
Woodcore has an AWS-like API structure so if you are familair with AWS access and secret key you will this process even more descriptive but if you dont, hang on tight.
First, you need to have or have done the following
* An employee creation completed
* A user account associated with the employee created - \[Allow API access]
* Have assigned requisite permissions on user
Then you create an API by clicking on the Generate API key inside the user profile.
Take note of the following
* You can only create an APi key to a user that has api access enabled
* You can only generate two (2) api key per user
* You must provide an IP to be whitelisted. This may not be effective on sandbox but will be sure reject your request if they do not come from the whitelisted IP
Now you have your freshly baked API key and please remember to keep this super safe because it has every level of permision trusted on the base user on it, happy hacking! 🚀
```bash theme={null}
curl -X GET https://base_url/api/v1/clients \
-H "Authorization: Bearer wc_env_xxxxxxxxxxx"
```
## Asymmetric Authentication \[Recommended]
For enhanced security, Woodcore supports asymmetric authentication using RSA key pairs. This approach provides better security than simple API keys.
### Step 1: Generate Private Key
First, call the endpoint to generate your private key:
```bash theme={null}
curl -X POST https://api.woodcore.co/v2/gateway/generateKey \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_API_KEY"
```
**Important**: Store the private key securely as it will not be displayed again. This key is used to sign all your API requests.
### Step 2: Sign Your Messages
Use your private key to sign your request payload. Here are examples in different programming languages:
```javascript theme={null}
const crypto = require('crypto');
async function signRequest(payload, privateKey) {
const dataToSign = typeof payload === 'string' ? payload : JSON.stringify(payload);
const sign = crypto.createSign('RSA-SHA256');
sign.update(dataToSign);
const signature = sign.sign(privateKey, 'base64');
return signature;
}
// Example usage
const payload = {
name: "Cash at Office Vault",
glCode: "960F05F3FB39",
manualEntriesAllowed: true,
type: "asset",
parentId: "29",
usage: "header",
description: "Cash at Head office branch"
};
const signature = await signRequest(payload, privateKey);
const timestamp = new Date().getTime();
// API Request
const response = await fetch('https://api.woodcore.co/v2/endpoint', {
method: 'POST',
headers: {
'X-Signature': signature,
'X-Timestamp': timestamp,
'Content-Type': 'application/json'
},
body: JSON.stringify(payload)
});
```
```java theme={null}
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.util.Base64;
import com.fasterxml.jackson.databind.ObjectMapper;
public class WoodcoreAuth {
private static String signRequest(String payload, String privateKeyPEM) throws Exception {
// Remove PEM headers and decode
String privateKeyContent = privateKeyPEM
.replace("-----BEGIN PRIVATE KEY-----", "")
.replace("-----END PRIVATE KEY-----", "")
.replaceAll("\\s", "");
byte[] privateKeyBytes = Base64.getDecoder().decode(privateKeyContent);
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
// Sign the payload
Signature signature = Signature.getInstance("SHA256withRSA");
signature.initSign(privateKey);
signature.update(payload.getBytes("UTF-8"));
return Base64.getEncoder().encodeToString(signature.sign());
}
}
```
```python theme={null}
import base64
import json
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.backends import default_backend
def sign_request(payload, private_key_pem):
# Load private key
private_key = serialization.load_pem_private_key(
private_key_pem.encode(),
password=None,
backend=default_backend()
)
# Prepare data to sign
data_to_sign = json.dumps(payload) if isinstance(payload, dict) else payload
# Sign the data
signature = private_key.sign(
data_to_sign.encode(),
padding.PKCS1v15(),
hashes.SHA256()
)
return base64.b64encode(signature).decode()
# Example usage
payload = {
"name": "Cash at Office Vault",
"glCode": "960F05F3FB39",
"manualEntriesAllowed": True,
"type": "asset",
"parentId": "29",
"usage": "header",
"description": "Cash at Head office branch"
}
signature = sign_request(payload, private_key_pem)
timestamp = int(time.time() * 1000)
```
```go theme={null}
package main
import (
"crypto"
"crypto/rand"
"crypto/rsa"
"crypto/sha256"
"crypto/x509"
"encoding/base64"
"encoding/json"
"encoding/pem"
"fmt"
)
func signRequest(payload interface{}, privateKeyPEM string) (string, error) {
// Decode PEM block
block, _ := pem.Decode([]byte(privateKeyPEM))
if block == nil {
return "", fmt.Errorf("failed to decode PEM block")
}
// Parse private key
privateKey, err := x509.ParsePKCS8PrivateKey(block.Bytes)
if err != nil {
return "", err
}
rsaPrivateKey, ok := privateKey.(*rsa.PrivateKey)
if !ok {
return "", fmt.Errorf("not an RSA private key")
}
// Prepare data to sign
var dataToSign []byte
if str, ok := payload.(string); ok {
dataToSign = []byte(str)
} else {
dataToSign, err = json.Marshal(payload)
if err != nil {
return "", err
}
}
// Sign the data
hashed := sha256.Sum256(dataToSign)
signature, err := rsa.SignPKCS1v15(rand.Reader, rsaPrivateKey, crypto.SHA256, hashed[:])
if err != nil {
return "", err
}
return base64.StdEncoding.EncodeToString(signature), nil
}
```
```rust theme={null}
use base64;
use rsa::{pkcs8::DecodePrivateKey, RsaPrivateKey};
use rsa::signature::{Signer, Verifier};
use rsa::pkcs1v15::{SigningKey, VerifyingKey};
use sha2::Sha256;
use serde_json;
fn sign_request(payload: &str, private_key_pem: &str) -> Result> {
// Parse private key
let private_key = RsaPrivateKey::from_pkcs8_pem(private_key_pem)?;
let signing_key = SigningKey::::new(private_key);
// Sign the payload
let signature = signing_key.sign(payload.as_bytes());
// Encode to base64
Ok(base64::encode(signature.to_bytes()))
}
```
```csharp theme={null}
using System;
using System.Security.Cryptography;
using System.Text;
using Newtonsoft.Json;
public class WoodcoreAuth
{
public static string SignRequest(object payload, string privateKeyPEM)
{
// Remove PEM headers
string privateKeyContent = privateKeyPEM
.Replace("-----BEGIN PRIVATE KEY-----", "")
.Replace("-----END PRIVATE KEY-----", "")
.Replace("\n", "")
.Replace("\r", "");
byte[] privateKeyBytes = Convert.FromBase64String(privateKeyContent);
using (RSA rsa = RSA.Create())
{
rsa.ImportPkcs8PrivateKey(privateKeyBytes, out _);
// Prepare data to sign
string dataToSign = payload is string ? (string)payload : JsonConvert.SerializeObject(payload);
byte[] dataBytes = Encoding.UTF8.GetBytes(dataToSign);
// Sign the data
byte[] signatureBytes = rsa.SignData(dataBytes, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
return Convert.ToBase64String(signatureBytes);
}
}
}
```
### Step 3: Make API Requests
Include the signature and timestamp in your request headers:
```bash theme={null}
curl -X POST https://api.woodcore.co/v2/endpoint \
-H "X-Signature: YOUR_SIGNATURE" \
-H "X-Timestamp: TIMESTAMP" \
-H "Content-Type: application/json" \
-d '{"your": "payload"}'
```
**Best Practice**: Always include a timestamp in your requests to prevent replay attacks. The timestamp should be within 5 minutes of the server time.
# Environments
Source: https://docs.woodcore.co/start/environments
Guide for the environmencts on Woodcore
Our API provides two distinct environments for integration: **Sandbox** and **Live**. Each environment serves a unique purpose and has specific requirements for access and usage. However, both environments have similar behaviour but with different security covrage. Stay with me...
The **Sandbox** environment is designed for testing and development. It allows you to simulate API requests and responses without affecting real-world data. Worry not becasue you will have the exact same experince on the production environment.
### Base URLs
* **Sandbox Environment**: `https://spark.test.woodcore.co/api/v2`
* **Production Environment**: `https://api.woodcore.co/api/v2`
We encourage you to change your base URL from `woodcoreapp.com` if you still have it in use to `woodcore.co`. The `woodcoreapp.com` will be depreciated soon.
### Live (Production) Environment
The Live environment is used for production purposes, where all operations process real-world data. This environment requires strict security measures to ensure data integrity and compliance. Below are some things to take note of before requesting for a go-live access on Woodcore.
* Every API Request must come from the whitelisted IP
* Based on request, your API can be wrapped into a VPN, this means you have to establish a site to site vpn connection with Woodcore to get it working `depreciated feature`
* Every request you make has a TLS Encryption
# Errors & Handling
Source: https://docs.woodcore.co/start/errors
Guide to custom error response and handling patterns
* **01 Passed Request:**
* This means the request was either passed `200` or accepted `202`
* **0 Failed Request:**
* This means the request failed and the reasosn will be returned. This usually has a `404` `400` `403` HTTP response code
* **500 Internal Server Error:**
* An unexpected error occurred on the server side. This may be due to a bug, temporary system issue, or other unforeseen circumstances.
## Error Responses
When an error occurs, the API will typically return a JSON response with the following structure:
```json theme={null}
{
"status": "01",
"message": "Success",
"data": {}
}
```
```json theme={null}
{
"status": "0",
"message": "failed",
"data": {}
}
```
```json theme={null}
{
"status": "500",
"message": "failed",
"data": {}
}
```
#### Error Handling
**Client-Side**:
Check the HTTP status code of the response.
If the status code indicates an error, parse the JSON response to extract the error details.
Display an appropriate error message to the user.
Implement retry logic for transient errors (e.g., network issues, temporary server errors) if necessary.
**Server-Side**:
Implement proper error logging to help diagnose and fix issues.
Use a consistent error handling mechanism throughout the API.
Consider using a centralized error handling library or framework.
#### Best Practices
Provide clear and informative error messages.
Avoid exposing sensitive information in error messages.
Document all possible error codes and their corresponding messages.
Test error handling thoroughly.
This document provides a general overview of API errors and their handling. Specific error handling mechanisms and responses may vary depending on the individual API endpoints and their functionality.
Note: This is a basic template, and you may need to adjust it based on the specific needs and complexity of your API.
# Hook & Events
Source: https://docs.woodcore.co/start/notifications
Sending webhook events for actions on Woodcore
Webhooks are a powerful tool for integrating real-time notifications into your application. They allow your system to receive updates when specific events occur on Woodcore, without needing to poll for changes. This guide explains how webhooks work on Woodcore, how to use them, and recommened practices for handling events effectively.
### Alloweds Events
There are just a few limitations with the type of events that can trigger a hook on Woodcore. Almsot all the `POST` event are webhook enabled and you have the flexiblity to turn it on or off, disable or enable the hook and event based on your specific requirements.
### Event Data & Security
Some perculiar details are sent on the header and body of every event, they're signed and also travel with the signature for client's server validation. See example below;
```http theme={null}
POST /your_hook_path HTTP/1.1
Content-Type: application/json
x-wc-signature: e90f7a24c9009a07f4b404d1f40eefd26dac062e64bbb65781e99b099f864073
x-wc-user-action: action
x-wc-instruction: do not use if signature does not match
{
event: "taxes-group",
status: 200,
event_state: "event.success",
reference: "FMCS5sEAshkvhiAyDtnA",
data: {
request: null,
response: {
date_format: "dd MMMM yyyy",
locale: "en",
name: "tax group 1",
resourceId: 55,
tax_components: [
{
start_date: "11 April 2016",
tax_component_id: 7
}
]
}
}
}
```
Here are some comon ways to sign and validate the event hook on your server - AI can also be helpful generating usefull samples for you based on the language you write.
```javascript theme={null}
const signature = crypto
.createHmac("sha256", api_key)
.update(JSON.stringify(req.body))
.digest("hex");
if (signature == req.headers["x-swim-token"]) {
// Body is signed and valid. Goodluck
}
```
```java theme={null}
package hmacexample;
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import javax.xml.bind.DatatypeConverter;
import org.json.JSONException;
import org.json.JSONObject;
public class HMacExample {
public static void main(String[] args) throws UnsupportedEncodingException, InvalidKeyException, NoSuchAlgorithmException, JSONException {
String key = "YOUR_API_KEY"; //replace with your key
String rawJson = "{}";
JSONObject body = new JSONObject(rawJson);
String result = "";
String HMAC_SHA256 = "HmacSHA256";
String signature = ""; //put in the request's header value for x-swim-token
byte [] byteKey = key.getBytes("UTF-8");
SecretKeySpec keySpec = new SecretKeySpec(byteKey, HMAC_SHA256);
Mac sha256_HMAC = Mac.getInstance(HMAC_SHA256);
sha256_HMAC.init(keySpec);
byte [] mac_data = sha256_HMAC.
doFinal(body.toString().getBytes("UTF-8"));
result = DatatypeConverter.printHexBinary(mac_data);
if(result.toLowerCase().equals(signature)) {
// you can trust the event, it came from woodcore
// respond with the http 200 response immediately before attempting to process the response
}else{
// this isn't from woodcore, ignore it
}
}
}
```
```go theme={null}
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"net/http"
"io/ioutil"
)
func main() {
apiKey := "YOUR_API_KEY" // replace with your woodcore
reqBody := `{"example": "data"}` // replace with actual request body
// Create HMAC-SHA256 signature
h := hmac.New(sha256.New, []byte(apiKey))
h.Write([]byte(reqBody))
signature := hex.EncodeToString(h.Sum(nil))
// Simulate incoming request with headers
req, err := http.NewRequest("POST", "https://example.com", nil)
if err != nil {
fmt.Println("Error creating request:", err)
return
}
req.Header.Set("x-swim-token", signature)
// Read the x-swim-token header from the request
xSwimToken := req.Header.Get("x-swim-token")
// Verify the signature
if signature == xSwimToken {
fmt.Println("Body is signed and valid. Good luck")
} else {
fmt.Println("Invalid signature")
}
}
```
```python theme={null}
import hmac
import hashlib
signature = request.headers.get("x-wc-signature")
key = secret_key.encode("utf-8")
mes = json.dumps(payload, separators=(',', ':')).encode("utf-8")
encoded_payload = hmac.new(key, mes, hashlib.sha256).hexdigest()
if encoded_payload == signature:
return True
else:
return False
```
# Overview
Source: https://docs.woodcore.co/start/overview
Welcome to Woodcore developers docs
Woodcore is a robust Core Banking Platform built for modern generation banking operations. Our API's have been tested, trusted and currently in use by over 24 financial institutions, helping them to manage thier day to day analog or digital banking operations.
This guide will provide you insights on sevarla explorations you can do with the Woodcore API's. Some of which will be for Banking as a service, Payment Gateway, Agency Banking, Card Issuing and Processing and Buy now pay later.
## Use Guide
This documentation will provide you direct and generic access to the core banking Api's and also provide you with a curated list of possible usecase you may need to explore using the API's.
Core banking operations including accounts, loans, transactions, and accounting
Digital banking services including accounts, transactions, loans, deposits, and payments
Service orchestration and workflow management for seamless integration
Card management and transaction processing capabilities
We don't expect you will but if you require an elaborate technical support navigating our API's please use the support button at the top of this page or sey `Hey I'd love your help integrating` as a subject to `tech@woodcore.co`
# Pagination
Source: https://docs.woodcore.co/start/pagination
Guide for ensure accurate pagination on Woodcore
Pagination is a technique used to divide a large set of data into smaller, manageable chunks, or "pages." This is particularly useful in web applications to improve performance and enhance user experience by loading data incrementally.
#### Using `page` and `perPage` Parameters
To implement pagination, two key parameters are commonly used:
* **`page`**: Indicates the current page number.
* **`perPage`**: Specifies the number of items to display per page.
### Example Usage
Assume you have an API endpoint that returns a list of items. You can use the `page` and `perPage` parameters to control the pagination:
```javascript theme={null}
// Example API request in JavaScript
const page = 1; // Current page number
const perPage = 10; // Number of items per page
fetch(`https://api.woodcore.co/items?page=${page}&perPage=${perPage}`)
.then(response => response.json())
.then(data => {
console.log(data);
});
```
```python theme={null}
# Example API request in Python
import requests
page = 1 # Current page number
perPage = 10 # Number of items per page
url = f"https://api.woodcore.co/items?page={page}&perPage={perPage}"
response = requests.get(url)
if response.status_code == 200:
data = response.json()
print(data)
else:
print(f"Error: {response.status_code}")
```
```go theme={null}
// Example API request in Go
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
page := 1 // Current page number
perPage := 10 // Number of items per page
url := fmt.Sprintf("https://api.woodcore.co/items?page=%d&perPage=%d", page, perPage)
resp, err := http.Get(url)
if err != nil {
fmt.Println("Error:", err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println("Error:", err)
return
}
fmt.Println(string(body))
}
```
In this example, the API request fetches the first page of items, with 10 items per page. Adjusting the page and perPage values allows you to navigate through the dataset efficiently.
Conclusion
Pagination is an essential technique for managing large datasets in web applications. By using the page and perPage parameters, you can easily control the amount of data displayed and improve the overall performance and user experience of your application.