Skip to main content

SDKs

Official IDkollen SDKs wrap the REST API and handle authentication, serialization, and response parsing for you.

C# / .NET​

A typed .NET API client for server-side applications.

Installation​

dotnet add package Identisure.Client

Example​

using Identisure.Client;
using Identisure.Client.Models;

var client = new IdentisureClientBuilder("client_id", "client_secret")
    .Environment(IdentisureEnvironment.Staging)
    .Build();

var session = await client.BankIdSe.AuthAsync(new BankIdSeAuthRequest());
if (session is BankIdSePending pending)
{
    Console.WriteLine($"Session ID: {pending.Id}");

    var result = await client.BankIdSe.WaitForAuthAsync(pending.Id);
    switch (result)
    {
        case BankIdSeCompleted done:
            Console.WriteLine($"Authenticated: {done.Name} ({done.Ssn})");
            break;
        case BankIdSeFailed failed:
            Console.WriteLine($"Failed: {failed.Error}");
            break;
    }
}

Dart​

A typed Dart API client for Flutter and server-side applications.

Installation​

dart pub add identisure_client

Example​

import 'package:identisure_client/identisure_client.dart';

Future<void> main() async {
  final client = IdentisureClientBuilder('client_id', 'client_secret')
      .environment(Environment.staging)
      .build();

  final session = await client.bankIdSe.auth(const BankIdSeAuthRequest());
  if (session is BankIdSePending) {
    print('Session ID: ${session.id}');

    final result = await client.bankIdSe.waitForAuth(session.id);
    final message = switch (result) {
      BankIdSeCompleted(:final name, :final ssn) => 'Authenticated: $name ($ssn)',
      BankIdSeFailed(:final error) => 'Failed: $error',
      BankIdSePending() => 'Still pending',
      BankIdSeUnknown(:final status) => 'Unknown status: $status',
    };
    print(message);
  }

  client.close();
}

Go​

A typed Go API client for server-side applications.

Installation​

go get github.com/identisure/api-client-go

Example​

package main

import (
  "context"
  "fmt"

  identisure "github.com/identisure/api-client-go"
)

func main() {
  client := identisure.NewClientBuilder("client_id", "client_secret").
    Environment(identisure.Staging).
    Build()

  response, err := client.BankIdSe().Auth(context.Background(), identisure.BankIdSeAuthRequest{})
  if err != nil {
    panic(err)
  }

  if pending, ok := response.(*identisure.BankIdSePending); ok {
    fmt.Println(pending.Id)
  }
}

JavaScript / TypeScript​

A typed JavaScript/TypeScript API client with support for Node.js, Deno, Bun and browser environments.

Installation​

npm install @identisure/client

Example​

import { IdentisureClientBuilder } from "@identisure/client";

const client = new IdentisureClientBuilder("client_id", "client_secret")
  .environment("staging")
  .build();

const response = await client.bankidSe().auth({});

console.log(response.id);

JVM (Java / Kotlin)​

A JVM API client with support for Java and Kotlin.

Installation​

Gradle (Kotlin DSL):

implementation("com.identisure:identisure-client:0.1.0")
// Kotlin coroutines extensions
// implementation("com.identisure:identisure-client-kotlin:0.1.0")

Maven:

<dependency>
  <groupId>com.identisure</groupId>
  <artifactId>identisure-client</artifactId>
  <version>0.1.0</version>
</dependency>

Example​

Kotlin:

import com.identisure.client.*
import com.identisure.client.models.BankIdSeAuthRequest
import com.identisure.client.models.BankIdSeStatus

suspend fun main() {
    val client = identisureClient("client_id", "client_secret") {
        environment(Environment.STAGING)
    }

    val response = client.bankIdSe().authAsync(BankIdSeAuthRequest())

    if (response is BankIdSeStatus.Pending) {
        println(response.id)
    }
}

Java:

import com.identisure.client.Environment;
import com.identisure.client.IdentisureClientBuilder;
import com.identisure.client.models.BankIdSeAuthRequest;
import com.identisure.client.models.BankIdSeStatus;

void main() {
    var client = new IdentisureClientBuilder("client_id", "client_secret")
        .environment(Environment.STAGING)
        .build();

    var response = client.bankIdSe().auth(new BankIdSeAuthRequest()).join();

    if (response instanceof BankIdSeStatus.Pending pending) {
        IO.println(pending.id);
    }
}

PHP​

A typed PHP API client for server-side applications.

Installation​

composer require identisure/client guzzlehttp/guzzle

A PSR-18 HTTP client is required. The client auto-discovers Guzzle if installed; alternatively, inject any PSR-18 client via the builder.

Example​

<?php

use Identisure\Client\Environment;
use Identisure\Client\IdentisureClientBuilder;
use Identisure\Client\Models\BankIdSe\BankIdSeAuthRequest;
use Identisure\Client\Models\BankIdSe\BankIdSePending;

$client = (new IdentisureClientBuilder('client_id', 'client_secret'))
    ->environment(Environment::Staging)
    ->build();

$response = $client->bankIdSe()->auth(new BankIdSeAuthRequest());

if ($response instanceof BankIdSePending) {
    echo $response->id . PHP_EOL;
}

Python​

A typed Python API client with support for both synchronous and asynchronous usage via httpx.

Installation​

pip install identisure-client

Example​

Sync:

from identisure_client import IdentisureClientBuilder
from identisure_client.models import BankIdSeAuthRequest

client = (
    IdentisureClientBuilder("client_id", "client_secret")
    .environment("staging")
    .build()
)

response = client.bankid_se().auth(BankIdSeAuthRequest())

print(response.id)

Async:

import asyncio
from identisure_client import IdentisureClientBuilder
from identisure_client.models import BankIdSeAuthRequest

async def main():
    client = (
        IdentisureClientBuilder("client_id", "client_secret")
        .environment("staging")
        .build_async()
    )

    response = await client.bankid_se().auth(BankIdSeAuthRequest())

    print(response.id)

asyncio.run(main())

Ruby​

A typed Ruby API client for server-side applications.

Installation​

gem install identisure-client

Or add to your Gemfile:

gem 'identisure-client', '~> 0.1'

Example​

require 'identisure/client'

client = Identisure::ClientBuilder.new('client_id', 'client_secret')
                                  .environment(Identisure::Environment::STAGING)
                                  .build

session = client.bank_id_se.auth(Identisure::BankIdSe::AuthRequest.new)
puts "Session ID: #{session.id}" if session.is_a?(Identisure::BankIdSe::Pending)

result = client.bank_id_se.wait_for_auth(session.id)

case result
in Identisure::BankIdSe::Completed(ssn:, name:)
  puts "Authenticated: #{name} (#{ssn})"
in Identisure::BankIdSe::Failed(error:)
  puts "Failed: #{error}"
end

Rust​

A type-safe sync/async Rust API client for the IDkollen REST API.

Installation​

cargo add identisure-client

Example​

use identisure_client::models::{BankIdSeAuthRequest, BankIdSeStatus};
use identisure_client::{Environment, IdentisureClientBuilder};

#[tokio::main]
async fn main() {
    let client = IdentisureClientBuilder::new("client_id", "client_secret")
        .environment(Environment::Staging)
        .build()
        .unwrap();

    let response = client
        .bankid_se()
        .auth(BankIdSeAuthRequest::new())
        .await
        .unwrap();

    if let BankIdSeStatus::Pending(pending) = response {
        println!("{}", pending.id);
    }
}

Swift​

A typed Swift API client for iOS, macOS, tvOS and watchOS applications. Supports iOS 15+, macOS 12+, tvOS 15+ and watchOS 8+.

Installation​

Add to Package.swift:

dependencies: [
    .package(url: "https://github.com/identisure/api-client-swift.git", from: "0.1.0")
],
targets: [
    .target(name: "MyApp", dependencies: [
        .product(name: "IdentisureClient", package: "api-client-swift")
    ])
]

Example​

import IdentisureClient

let client = IdentisureClientBuilder(clientId: "client_id", clientSecret: "client_secret")
    .environment(.staging)
    .build()

let session = try await client.bankIdSe.auth(BankIdSeAuthRequest())
if case .pending(let pending) = session {
    print("Session ID: \(pending.id)")

    let result = try await client.bankIdSe.waitForAuth(id: pending.id)
    switch result {
    case .completed(let done):
        print("Authenticated: \(done.name) (\(done.ssn))")
    case .failed(let failed):
        print("Failed: \(failed.error)")
    case .pending, .unknown:
        break
    }
}