Auto-Upload Screenshots to EasySend (Linux, macOS, Windows)

Developers take screenshots constantly - bug reports, UI comparisons, terminal output, error messages. The annoying part is what happens next: open a browser, navigate to a file-sharing site, drag the image in, wait for the upload, copy the link. That is a lot of friction for something you do dozens of times a day. Here is how to make it automatic. Take a screenshot and the share link appears on your clipboard within seconds.

Linux: fswatch/inotifywait + CLI

On Linux, inotifywait watches a directory for new files and triggers a command when one appears. Pair it with the EasySend CLI and you get instant screenshot sharing.

First, install the prerequisites:

sudo apt install inotify-tools xclip
curl -fsSL https://easysend.co/cli/install.sh | bash

Then create a watcher script:

#!/bin/bash
# auto-share-screenshots.sh
WATCH_DIR="$HOME/Pictures/Screenshots"

inotifywait -m -e create --format '%f' "$WATCH_DIR" | while read FILENAME; do
    # Wait briefly for the file to finish writing
    sleep 0.5
    FILEPATH="$WATCH_DIR/$FILENAME"

    # Upload and grab the share URL
    RESULT=$(easysend "$FILEPATH" --json)
    URL="https://easysend.co$(echo "$RESULT" | jq -r '.share_url')"

    # Copy to clipboard
    echo -n "$URL" | xclip -selection clipboard

    # Desktop notification
    notify-send "Screenshot shared" "$URL"
done

Run this script at login (add it to your .xinitrc, systemd user service or desktop autostart) and every screenshot you take automatically gets uploaded to EasySend. The share link lands on your clipboard and a notification confirms it. Paste the link into Slack, a GitHub issue or an email.

On systems without inotifywait, you can use fswatch as a drop-in replacement:

fswatch -0 ~/Pictures/Screenshots | while IFS= read -r -d '' FILEPATH; do
    RESULT=$(easysend "$FILEPATH" --json)
    URL="https://easysend.co$(echo "$RESULT" | jq -r '.share_url')"
    echo -n "$URL" | xclip -selection clipboard
done

macOS: Automator + CLI

macOS saves screenshots to ~/Desktop by default (or a custom folder if you changed it). You can use Automator to watch that folder and run a shell script whenever a new file arrives.

Open Automator, create a new Folder Action and set it to watch your screenshot directory. Add a "Run Shell Script" action with the input passed as arguments:

#!/bin/bash
for f in "$@"; do
    # Only process image files
    case "$f" in
        *.png|*.jpg|*.jpeg|*.gif|*.webp)
            RESULT=$(/usr/local/bin/easysend "$f" --json)
            URL="https://easysend.co$(echo "$RESULT" | jq -r '.share_url')"
            echo -n "$URL" | pbcopy
            osascript -e "display notification \"$URL\" with title \"Screenshot Shared\""
            ;;
    esac
done

Save the Folder Action and you are done. Every screenshot you take gets uploaded automatically. The share link goes to your clipboard via pbcopy and a macOS notification confirms the upload.

If you prefer Homebrew-based tools, fswatch works on macOS too:

brew install fswatch jq
fswatch -0 ~/Desktop | while IFS= read -r -d '' f; do
    [[ "$f" == *.png ]] && easysend "$f" --copy
done

Windows: PowerShell FileSystemWatcher

On Windows, PowerShell has a built-in FileSystemWatcher class that monitors directories for changes. Here is a script that watches your screenshot folder and uploads new images:

# auto-share-screenshots.ps1
$watcher = New-Object System.IO.FileSystemWatcher
$watcher.Path = "$env:USERPROFILE\Pictures\Screenshots"
$watcher.Filter = "*.png"
$watcher.EnableRaisingEvents = $true

$action = {
    Start-Sleep -Seconds 1  # Let the file finish writing
    $filePath = $Event.SourceEventArgs.FullPath
    $result = & easysend $filePath --json | ConvertFrom-Json
    $url = "https://easysend.co$($result.share_url)"

    # Copy to clipboard
    Set-Clipboard -Value $url

    # Toast notification
    [System.Windows.Forms.MessageBox]::Show("Link copied: $url", "Screenshot Shared")
}

Register-ObjectEvent $watcher "Created" -Action $action
Write-Host "Watching for screenshots... Press Ctrl+C to stop."
while ($true) { Start-Sleep -Seconds 1 }

To run this at startup, save it as a .ps1 file and add a shortcut to your Startup folder, or register it as a scheduled task that triggers at logon.

For Windows Terminal users who prefer a lighter approach, you can combine the Windows Snipping Tool with a one-liner:

# After taking a screenshot saved to clipboard, upload from clipboard
Get-Clipboard -Format Image | ForEach-Object {
    $_.Save("$env:TEMP\screenshot.png")
    $url = (easysend "$env:TEMP\screenshot.png" --json | ConvertFrom-Json).share_url
    Set-Clipboard "https://easysend.co$url"
}

Share Link Straight to Clipboard

All the examples above copy the URL to your clipboard automatically. But if you just want the simplest possible workflow without watchers or background scripts, the EasySend CLI has a built-in --copy flag:

# Take screenshot, then immediately share it
easysend ~/Pictures/Screenshots/latest.png --copy

This uploads the file and copies the share link to your clipboard in one step. Bind it to a keyboard shortcut in your OS and you have a two-key screenshot sharing workflow: one key to capture, one key to share.

On Linux with xdotool and a custom keybinding:

# Bind to Super+Shift+S in your window manager
gnome-screenshot -f /tmp/share-screenshot.png && easysend /tmp/share-screenshot.png --copy

On macOS, you can create a custom keyboard shortcut in System Settings that triggers an Automator Quick Action running the same CLI command.

Why This Beats Cloud Screenshot Tools

Dedicated screenshot-sharing apps like CloudApp or Droplr charge monthly fees and lock you into their ecosystem. With the EasySend CLI approach, you get the same result using open tools you already have. The screenshots live on EasySend's photo sharing infrastructure with optional E2E encryption, no account required and no monthly bill.

For teams, this pairs well with the EasySend API. You can build a shared screenshot workflow where every upload goes to a team dashboard, gets tagged by project or lands in a channel. The developer use case page covers more integration patterns for engineering teams.

Pick the method that matches your OS, run it in the background and forget about it. Every screenshot you take from now on is one paste away from being shared.