Skip to content
Klutch.sh Docs

Deploying SANE Network Scanning

Introduction

SANE (Scanner Access Now Easy) is a standardized API that provides access to image scanning hardware such as flatbed scanners, handheld scanners, and cameras. The SANE network daemon (saned) enables sharing scanners over a network, allowing multiple clients to access scanning hardware remotely.

SANE supports an extensive range of scanning devices through its modular backend architecture. Each scanner manufacturer or device type has a dedicated backend that handles device-specific communication while presenting a uniform interface to applications. This design enables any SANE-compatible application to work with any supported scanner.

Key highlights of SANE Network Scanning:

  • Universal Scanner Access: Support for hundreds of scanner models from major manufacturers
  • Network Transparency: Share USB-connected scanners with network clients seamlessly
  • Cross-Platform Clients: Connect from Linux, macOS, Windows, and mobile devices
  • Web Interface Options: Integrate with web-based scanning frontends
  • Batch Scanning: Support for automatic document feeders and batch operations
  • Image Format Flexibility: Output to various formats including TIFF, PNG, JPEG, and PDF
  • Resolution Control: Fine-grained control over scan resolution and quality
  • Color Mode Options: Grayscale, color, and lineart scanning modes
  • Authentication Support: Secure access with username and password authentication
  • Open Standard: Well-documented API for custom integrations

This guide walks through deploying a SANE network scanning server on Klutch.sh using Docker, enabling remote scanner access for your organization.

Why Deploy SANE on Klutch.sh

Deploying SANE on Klutch.sh provides several advantages for network scanning:

Simplified Deployment: Klutch.sh automatically builds your SANE server configuration without manual server setup. Push to GitHub for automatic deployment.

Centralized Management: Manage scanner access and configuration from a single deployment rather than configuring each workstation individually.

HTTPS Web Interface: When combined with web-based scanning frontends, Klutch.sh provides automatic SSL certificates for secure access.

GitHub Integration: Store your configuration in version control. Changes trigger automatic redeployments.

Scalable Resources: Allocate resources based on scanning volume and concurrent users.

Environment Variable Management: Securely configure authentication and access controls through Klutch.sh’s environment system.

Prerequisites

Before deploying SANE on Klutch.sh, ensure you have:

  • A Klutch.sh account
  • A GitHub account with a repository for your SANE configuration
  • Basic familiarity with Docker and containerization concepts
  • Understanding of your scanner hardware and network requirements
  • (Optional) A custom domain for web-based scanning access

Deploying SANE on Klutch.sh

    Create Your Repository

    Create a new GitHub repository for your SANE deployment. Add a Dockerfile:

    FROM debian:bookworm-slim
    

    RUN apt-get update && apt-get install -y \
        sane-utils \
        libsane1 \
        sane-airscan \
        && rm -rf /var/lib/apt/lists/*
    

    # Configure saned for network access
    RUN mkdir -p /etc/sane.d
    COPY saned.conf /etc/sane.d/saned.conf
    COPY net.conf /etc/sane.d/net.conf
    

    EXPOSE 6566
    

    CMD ["saned", "-a", "-d128"]

    Create a saned.conf file:

    # Hosts allowed to connect
    # Adjust based on your network
    0.0.0.0/0

    Create a net.conf file:

    # Network scanner backends
    connect_timeout = 60

    Push to GitHub

    Commit and push your configuration files to your GitHub repository.

    Create a New Project on Klutch.sh

    Navigate to the Klutch.sh dashboard and create a new project.

    Create a New App

    Within your project, create a new app and connect your GitHub repository.

    Configure TCP Traffic

    SANE uses TCP port 6566 for network scanner access:

    • Select TCP as the traffic type
    • Set the internal port to 6566

    Attach Persistent Volumes

    Add volumes for scan output and configuration:

    Mount PathRecommended SizePurpose
    /etc/sane.d100 MBSANE configuration files
    /scans50 GBScanned document storage

    Deploy Your Application

    Click Deploy to build and start your SANE server.

    Configure Clients

    On client machines, add your Klutch.sh deployment address to /etc/sane.d/net.conf:

    your-app-name.klutch.sh

Web-Based Scanning Frontend

For browser-based scanning access, deploy a web frontend alongside your SANE server.

phpSANE Integration

Add a web interface by extending your Dockerfile:

FROM php:8.2-apache


RUN apt-get update && apt-get install -y \
    sane-utils \
    libsane1 \
    imagemagick \
    && rm -rf /var/lib/apt/lists/*


# Install phpSANE
COPY phpsane/ /var/www/html/


EXPOSE 80

Scanner Configuration

Supported Backends

SANE supports numerous scanner backends:

  • epson2: Epson flatbed and all-in-one scanners
  • canon_dr: Canon document scanners
  • brother: Brother multifunction devices
  • hp: HP scanners via HPLIP
  • airscan: Network scanners via eSCL/WSD protocols
  • fujitsu: Fujitsu document scanners

Adding Custom Backends

Configure specific backends in /etc/sane.d/dll.conf:

# Enable specific backends
net
airscan
epson2

Authentication Setup

Enabling Authentication

Create an authentication file for secure access:

/etc/sane.d/saned.users
username:password:backend

Access Control

Restrict access by IP ranges in saned.conf:

# Allow specific subnets only
192.168.1.0/24
10.0.0.0/8

Best Practices

Performance Optimization

  • Resolution Settings: Use appropriate resolution for document type (300 DPI for documents, 600+ for photos)
  • Compression: Enable JPEG compression for large scans
  • Batch Processing: Use automatic document feeders for multi-page documents

Security Considerations

  • Access Restrictions: Limit access to trusted networks only
  • Authentication: Enable username/password authentication for sensitive environments
  • Encryption: Use VPN or SSH tunneling for remote scanning access

Troubleshooting

Scanner Not Detected

  • Verify backend is enabled in dll.conf
  • Check network connectivity between client and server
  • Review saned logs for connection issues

Permission Errors

  • Ensure saned has access to scanner devices
  • Verify user permissions on scan output directories

Slow Scanning

  • Check network bandwidth between client and server
  • Reduce scan resolution for faster transfers
  • Consider enabling compression

Additional Resources

Conclusion

Deploying SANE network scanning on Klutch.sh enables centralized scanner access for your organization. With support for hundreds of scanner models and flexible client options, you can provide scanning capabilities to users across your network without configuring individual workstations.