Skip to main content

C quick start for the Linux Barcode Scanner SDK

Build a lightweight barcode scanner in C for Linux. The command-line interface accepts a single image path as input, and the Scanbot SDK license key is embedded directly in the source code.

Install a C compiler, CMake and wget:​

Install a C compiler, CMake, and wget

sudo apt update
sudo apt install -y cmake build-essential wget

Project layout​

Create a minimal project.

mkdir -p barcode-quickstart-c && \
cd barcode-quickstart-c && \
touch CMakeLists.txt main.c

main.c​

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#include <ScanbotSDK.h>

// 👉 Replace this with your Scanbot SDK license key
static const char *SCANBOTSDK_LICENSE_KEY = "<SCANBOTSDK-LICENSE-KEY>";

/** Load an image from a file path using Scanbot SDK API. */
static scanbotsdk_error_code_t load_image_from_path(const char *path, scanbotsdk_image_t **out_image) {
    scanbotsdk_path_image_load_options_t *options = NULL;
    scanbotsdk_error_code_t ec = scanbotsdk_path_image_load_options_create_with_defaults(&options);
    if (ec != SCANBOTSDK_OK) return ec;

    ec = scanbotsdk_image_create_from_path(path, options, out_image);
    scanbotsdk_path_image_load_options_free(options);
    return ec;
}

/** Run the barcode scanner and print results. */
static scanbotsdk_error_code_t run_barcode_scanner(scanbotsdk_image_t *image) {
    scanbotsdk_error_code_t ec = SCANBOTSDK_OK;

    scanbotsdk_barcode_scanner_configuration_t *config = NULL;
    scanbotsdk_barcode_scanner_t *scanner = NULL;
    scanbotsdk_barcode_scanner_result_t *result = NULL;

    // Create scanner config with defaults
    ec = scanbotsdk_barcode_scanner_configuration_create_with_defaults(&config);
    if (ec != SCANBOTSDK_OK) { fprintf(stderr, "config_create: %d\n", ec); goto cleanup; }

    // Create scanner instance
    ec = scanbotsdk_barcode_scanner_create(config, &scanner);
    if (ec != SCANBOTSDK_OK) { fprintf(stderr, "scanner_create: %d\n", ec); goto cleanup; }

    // Run scanner
    ec = scanbotsdk_barcode_scanner_run(scanner, image, &result);
    if (ec != SCANBOTSDK_OK) { fprintf(stderr, "scanner_run: %d\n", ec); goto cleanup; }

    bool success = false;
    scanbotsdk_barcode_scanner_result_get_success(result, &success);
    if (!success) {
        printf("No barcodes found.\n");
        goto cleanup;
    }

    size_t count = 0;
    ec = scanbotsdk_barcode_scanner_result_get_barcodes_size(result, &count);
    if (ec != SCANBOTSDK_OK) { fprintf(stderr, "get_barcodes_size: %d\n", ec); goto cleanup; }

    scanbotsdk_barcode_item_t **barcodes = calloc(count, sizeof(*barcodes));
    if (!barcodes) { fprintf(stderr, "calloc failed\n"); ec = SCANBOTSDK_ERROR_OUT_OF_MEMORY; goto cleanup; }

    ec = scanbotsdk_barcode_scanner_result_get_barcodes(result, barcodes, count);
    if (ec != SCANBOTSDK_OK) { fprintf(stderr, "get_barcodes: %d\n", ec); goto cleanup; }

    for (size_t i = 0; i < count; i++) {
        const char *text = NULL;
        scanbotsdk_barcode_item_get_text(barcodes[i], &text);
        printf("  %zu) %s\n", i + 1, text ? text : "(null)");
    }

    free(barcodes);

cleanup:
    scanbotsdk_barcode_scanner_result_free(result);
    scanbotsdk_barcode_scanner_free(scanner);
    scanbotsdk_barcode_scanner_configuration_free(config);
    return ec;
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <image_path>\n", argv[0]);
        return 1;
    }
    const char *file_path = argv[1];

    // Init SDK with license
    scanbotsdk_init_params_t params = (scanbotsdk_init_params_t){0};
    params.license_key    = (char *)SCANBOTSDK_LICENSE_KEY;
    params.writeable_path = ".";

    scanbotsdk_error_code_t ec = scanbotsdk_initialize(&params);
    if (ec != SCANBOTSDK_OK) { fprintf(stderr, "initialize: %d\n", ec); goto cleanup; }

    // Load image and scan
    scanbotsdk_image_t *image = NULL;
    ec = load_image_from_path(file_path, &image);
    if (ec != SCANBOTSDK_OK) { fprintf(stderr, "load_image_from_path: %d\n", ec); goto cleanup; }

    ec = run_barcode_scanner(image);
    if (ec != SCANBOTSDK_OK) { fprintf(stderr, "run_barcode_scanner: %d\n", ec); }

    scanbotsdk_image_free(image);

cleanup:
    return (ec == SCANBOTSDK_OK) ? 0 : 1;
}

CMakeLists​

CMakeLists.txt
cmake_minimum_required(VERSION 3.16)
project(scanbot_barcode_quickstart C)
set(CMAKE_C_STANDARD 11)

# Pass the SDK version like:
#   cmake -DSCANBOTSDK_VERSION=<version> ..
if(NOT SCANBOTSDK_VERSION)
  message(FATAL_ERROR "You must set -DSCANBOTSDK_VERSION=<version>")
endif()

# Where to extract and use the Scanbot SDK
set(SCANBOTSDK_DIR "${CMAKE_CURRENT_BINARY_DIR}/scanbotsdk" CACHE PATH "Scanbot SDK directory")

# --- Download & extract SDK if missing ---
if(NOT EXISTS "${SCANBOTSDK_DIR}/include" OR NOT EXISTS "${SCANBOTSDK_DIR}/lib")
  find_program(WGET_PATH wget REQUIRED)
  find_program(TAR_PATH tar REQUIRED)

  # Detect architecture
  if("${CMAKE_HOST_SYSTEM_PROCESSOR}" MATCHES ".*(arm|aarch64).*")
    set(SCANBOTSDK_ARCHITECTURE "aarch64")
  else()
    set(SCANBOTSDK_ARCHITECTURE "x86_64")
  endif()

  set(TARBALL "scanbotsdk-${SCANBOTSDK_VERSION}-linux-${SCANBOTSDK_ARCHITECTURE}.tar.gz")
  set(URL "https://github.com/doo/scanbot-sdk-example-linux/releases/download/standalone-sdk%2Fv${SCANBOTSDK_VERSION}/${TARBALL}")

  message(STATUS "Downloading ${URL}")
  execute_process(
    COMMAND ${WGET_PATH} -q -O "${TARBALL}" "${URL}"
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    RESULT_VARIABLE WGET_RES
  )
  if(NOT WGET_RES EQUAL 0)
    message(FATAL_ERROR "Failed to download ${URL}")
  endif()

  # Extract directly into SCANBOTSDK_DIR (flatten with --strip-components=1)
  file(MAKE_DIRECTORY "${SCANBOTSDK_DIR}")
  execute_process(
    COMMAND ${TAR_PATH} -xzf "${TARBALL}" -C "${SCANBOTSDK_DIR}" --strip-components=1
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    RESULT_VARIABLE TAR_RES
  )
  if(NOT TAR_RES EQUAL 0)
    message(FATAL_ERROR "Failed to extract ${TARBALL}")
  endif()
endif()

# --- Locate headers and libraries ---
find_library(ScanbotSDK_LIBS
  NAMES scanbotsdk libscanbotsdk.so
  HINTS ${SCANBOTSDK_DIR}/lib
)

find_path(ScanbotSDK_INCLUDE_DIRS
  NAMES ScanbotSDK.h
  HINTS ${SCANBOTSDK_DIR}/include
)

if(NOT ScanbotSDK_LIBS OR NOT ScanbotSDK_INCLUDE_DIRS)
  message(FATAL_ERROR "Could not find Scanbot SDK inside ${SCANBOTSDK_DIR}")
endif()

# --- Import the SDK as a library target ---
add_library(scanbotsdk SHARED IMPORTED)
set_target_properties(scanbotsdk PROPERTIES
  IMPORTED_LOCATION "${ScanbotSDK_LIBS}"
  INTERFACE_INCLUDE_DIRECTORIES "${ScanbotSDK_INCLUDE_DIRS}"
)

# --- Build your app ---
add_executable(barcode-quickstart main.c)
target_link_libraries(barcode-quickstart scanbotsdk m pthread)

Build​

# Create a build directory (keeps generated files separate from your source)
mkdir -p build
cd build

# Run CMake, passing the Scanbot SDK version and your API token
cmake -DSCANBOTSDK_VERSION=<SCANBOTSDK_VERSION> ..

# Compile the project
make -j

Run​

Run the app with the path to an image file containing barcodes.

./barcode-quickstart /path/to/image_with_barcodes.jpg

🚀 That's it! You've built a minimal barcode scanner in C on Linux.

💡 In this quick start guide, we use the SDK's default scanner settings. However, you can freely customize the configuration, supported barcode types, and performance options.

Get in touch​

If you need further information or are interested in licensing the Scanbot SDK, please get in touch with our solution experts.

Scanbot SDK is part of the Apryse SDK product family

A mobile scan is just the start. With Apryse SDKs, you can expand mobile workflows into full cross‑platform document processing. Whether you need to edit PDFs, add secure digital signatures, or use a fast, customizable document viewer and editor, Apryse gives you the tools to build powerful features quickly.

Learn more
Apryse Logo Glass lightApryse Logo Glass dark

On this page