Developer Onboarding

curl -X POST ${AUTH_BASE_URL}/dcr \
  -H "Content-Type: application/json" \
  -d '{
      "username": "john.doe@example.com",
      "password": "password",
      "app_name": "My Open Banking App",
      "app_description": "A test application for Open Banking integration",
      "app_developer_name": "Fantastic Fintech Ltd",
      "app_developer_address": "Plot 1354, Okokomaiko, Lagos",
      "app_developer_contact_email": "john.doe@example.com",
      "app_developer_contact_phone": "+2348012345678",
      "redirect_url": "https://myapp.com/callback"
  }'

const response = await fetch('${AUTH_BASE_URL}/dcr', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    username: "john.doe@example.com",
    password: "password",
    app_name: "My Open Banking App",
    app_description: "A test application for Open Banking integration",
    app_developer_name: "Fantastic Fintech Ltd",
    app_developer_address: "Plot 1354, Okokomaiko, Lagos",
    app_developer_contact_email: "john.doe@example.com",
    app_developer_contact_phone: "+2348012345678",
    redirect_url: "https://myapp.com/callback"
  })
});

const credentials = await response.json();
console.log('Client credentials:', credentials);

import requests

response = requests.post('${AUTH_BASE_URL}/dcr', json={
    "username": "john.doe@example.com",
    "password": "password",
    "app_name": "My Open Banking App",
    "app_description": "A test application for Open Banking integration",
    "app_developer_name": "Fantastic Fintech Ltd",
    "app_developer_address": "Plot 1354, Okokomaiko, Lagos",
    "app_developer_contact_email": "john.doe@example.com",
    "app_developer_contact_phone": "+2348012345678",
    "redirect_url": "https://myapp.com/callback"
})

credentials = response.json()
print('Client credentials:', credentials)

curl -X GET ${AUTH_BASE_URL}/dcr \
  -H "Authorization: Basic base64(username:password)"

const response = await fetch('${AUTH_BASE_URL}/dcr', {
  method: 'GET',
  headers: {
    'Authorization': 'Basic base64(username:password)'
  }
});

const credentials = await response.json();
console.log('credentials:', credentials);

// Generate PKCE challenge
const generatePKCE = () => {
  const codeVerifier = crypto.randomUUID();
  const codeChallenge = btoa(codeVerifier);
  return { codeVerifier, codeChallenge };
};

// Redirect to authorization
const { codeVerifier, codeChallenge } = generatePKCE();
const authUrl = `${AUTH_BASE_URL}/oauth/authorize?` +
  `client_id=${credentials.client_id}&` +
  `redirect_uri=${encodeURIComponent(credentials.redirect_url)}&` +
  `response_type=code&` +
  `scope=customers.readonly accounts.list.readonly&` +
  `code_challenge=${codeChallenge}&` +
  `code_challenge_method=S256`;

// Store code verifier for token exchange
sessionStorage.setItem('code_verifier', codeVerifier);
window.location.href = authUrl;

// Handle callback and exchange code for token
const handleCallback = async (code) => {
  const codeVerifier = sessionStorage.getItem('code_verifier');
  
  const tokenResponse = await fetch(`${AUTH_BASE_URL}/oauth/token`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded',
      'Authorization': `Basic ${btoa(`${credentials.client_id}:${credentials.client_secret}`)}`
    },
    body: new URLSearchParams({
      grant_type: 'authorization_code',
      code: code,
      redirect_uri: credentials.redirect_url,
      code_verifier: codeVerifier
    })
  });
  
  const tokens = await tokenResponse.json();
  console.log('Access token:', tokens.access_token);
  return tokens;
};

// Step 1: Redirect to authorization
const authUrl = `${AUTH_BASE_URL}/oauth/authorize?` +
  `client_id=${credentials.client_id}&` +
  `redirect_uri=${encodeURIComponent(credentials.redirect_url)}&` +
  `response_type=code&` +
  `scope=customers.readonly accounts.list.readonly&` +
  `state=${crypto.randomUUID()}`;

window.location.href = authUrl;

// Step 2: Handle callback and exchange code for token
const handleCallback = async (code) => {
  const tokenResponse = await fetch(`${AUTH_BASE_URL}/oauth/token`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded',
      'Authorization': `Basic ${btoa(`${credentials.client_id}:${credentials.client_secret}`)}`
    },
    body: new URLSearchParams({
      grant_type: 'authorization_code',
      code: code,
      redirect_uri: credentials.redirect_url
    })
  });
  
  const tokens = await tokenResponse.json();
  console.log('Access token:', tokens.access_token);
  return tokens;
};

// Step 3: Refresh token when needed
const refreshToken = async (refreshToken) => {
  const response = await fetch(`${AUTH_BASE_URL}/oauth/token`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded',
      'Authorization': `Basic ${btoa(`${credentials.client_id}:${credentials.client_secret}`)}`
    },
    body: new URLSearchParams({
      grant_type: 'refresh_token',
      refresh_token: refreshToken
    })
  });
  
  const tokens = await response.json();
  console.log('New access token:', tokens.access_token);
  return tokens;
};

// Step 1: Request device authorization
const requestDeviceCode = async () => {
  const response = await fetch(`${AUTH_BASE_URL}/oauth2/device/code`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded'
    },
    body: new URLSearchParams({
      scope: 'customers.readonly accounts.list.readonly',
      client_id: '${client_id}',
      target_connection_id: '${target_connection_id}'
    })
  });
  
  const deviceCode = await response.json();
  console.log('Device code:', deviceCode.device_code);
  console.log('User code:', deviceCode.user_code);
  console.log('Verification URI:', deviceCode.verification_uri);
  
  return deviceCode;
};

// Step 2: Poll for token
const pollForToken = async (deviceCode, interval = 5000) => {
  const pollInterval = setInterval(async () => {
    try {
      const response = await fetch(`${AUTH_BASE_URL}/oauth/token`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded'
        },
        body: new URLSearchParams({
          grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
          device_code: deviceCode.device_code,
          client_id: ${client_id}
        })
      });
      
      if (response.status === 200) {
        const tokens = await response.json();
        console.log('Access token received:', tokens.access_token);
        clearInterval(pollInterval);
        return tokens;
      } else if (response.status === 400) {
        const error = await response.json();
        if (error.error === 'authorization_pending') {
          console.log('Waiting for user authorization...');
        } else if (error.error === 'authorization_declined') {
          console.log('User declined authorization');
          clearInterval(pollInterval);
        } else if (error.error === 'expired_token') {
          console.log('Device code expired');
          clearInterval(pollInterval);
        }
      }
    } catch (error) {
      console.error('Polling error:', error);
      clearInterval(pollInterval);
    }
  }, interval);
};

# Get accounts
curl -X GET ${API_BASE_URL}/accounts \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "idempotency_key: IDEMPOTENCY_KEY" \
  -H "signature: SIGNATURE"

// Test account information
const accountsResponse = await fetch('${API_BASE_URL}/accounts', {
  headers: {
    'Authorization': `Bearer ${accessToken}`,
    'idempotency_key': $idempotency_key,
    'signature': $signature
  }
});

const accounts = await accountsResponse.json();
console.log('Test accounts:', accounts);