8 Practical xargs Command Examples for Linux Power Users

1. What the xargs Command Does

The xargs command reads items from standard input and runs a command with those items as arguments. Think of it as a bridge between pipes and commands that don’t accept piped input. You pipe data into xargs, and xargs feeds that data one line at a time to whatever program you specify.

A lot of Linux tools accept input from stdin directly. Things like grep, sort, and awk read pipes naturally. But some commands only take file names or arguments on the command line. That’s where xargs steps in. It’s been around since the early days of Unix and it’s still one of the most practical tools in the terminal.

2. Basic Syntax of the xargs Command

The basic form of the xargs command looks like this:

command | xargs [options] [target_command]

If you don’t specify a target command, xargs defaults to echo. So echo something | xargs prints “something.” Not very useful on its own, but it shows how the pipeline works.

Here’s a real example. I use this all the time to remove temporary files:

find /tmp -name "*.tmp" | xargs rm

The find command outputs a list of .tmp files. Xargs collects them and passes them to rm as arguments. Without xargs, you’d need a loop or a different approach.

3. Pass Arguments at the End With Placeholder

Some programs expect arguments at the start rather than the end. The xargs command handles this with the -I flag, which lets you specify a placeholder.

find . -name "*.txt" | xargs -I {} cp {} /backup/

Here {} is replaced with each filename. The copy command takes source then destination, so the placeholder lets xargs put the filename in the right spot. Without -I, xargs would just tack arguments at the end, which would fail for commands like cp that need two arguments.

This is one of those things that looks confusing at first but clicks fast once you use it a few times. I use -I mostly with cp and mv when batching file operations.

4. Control How Many Arguments Are Passed at Once

By default, xargs packs as many arguments as it can into a single command. That’s usually fine, but sometimes you need to limit it. The -n option controls how many arguments go to each invocation.

echo "one two three four" | xargs -n 2 echo

This runs echo one two, then echo three four. Each invocation gets exactly 2 arguments. I use -n 1 a lot when I need to run a command once per file, especially with tools like wc or head where processing multiple files together gives a different result than processing them one at a time.

Pairing -n with the xargs command gives you fine-grained control over batching. You can tune it for performance too. Sending 100 arguments per invocation is faster than 1 at a time, but some commands hit argument length limits.

5. Handle Unusual Filenames With Null Separators

Here’s a gotcha that catches everyone. Filenames with spaces, tabs, or newlines break the default xargs behavior. If you have a file called My Documents.txt, xargs treats it as two separate arguments.

The fix is to use null-separated xargs command with the -0 flag. Combine it with find‘s -print0 option:

find . -type f -name "*.log" -print0 | xargs -0 rm

This uses null characters as delimiters instead of spaces and newlines. Null characters can’t appear in filenames, so it’s completely safe. I always use -print0 and -0 together in scripts. It’s one more flag to type, but it saves you from nasty surprises.

6. Run Commands in Parallel With the xargs Command

One of the best features of the xargs command is the -P flag for parallel execution. This tells xargs to run multiple processes at the same time.

find . -name "*.jpg" -print0 | xargs -0 -P 4 -n 1 convert -resize 50%

This resizes JPEG images using 4 parallel processes. On a machine with multiple cores, that’s nearly a 4x speedup. Without -P, each resize runs one at a time.

I use parallel xargs for batch operations all the time. Compressing files, converting images, running checksums. Just be careful not to set -P too high on a machine with limited memory. Each parallel process uses its own share of RAM.

7. Limit Memory Usage by Running Interactive

If you’re about to run a destructive command like rm or mv across many files, the -p flag adds an interactive prompt before each invocation.

find . -name "*.conf" | xargs -p rm

Xargs prints the command it’s about to run and waits for confirmation. Type y to proceed or anything else to skip. It’s a safety net for those times when you’re not 100% sure your command matches the right files.

For a less aggressive version, use -t (trace mode). This prints each command to stderr before running it. No prompts, just visibility into what’s happening. I use -t when I’m debugging a pipeline and -p when I’m feeling cautious.

8. Replace find -exec With the xargs Command

If you’ve used find -exec before, you might wonder why you’d bother with xargs. The answer is performance. Each -exec invocation spawns a new process for every single file. The xargs command batches arguments and spawns far fewer processes.

# Slow way - one process per file
find . -name "*.py" -exec wc -l {} \;

# Fast way - batched with xargs
find . -name "*.py" | xargs wc -l

The difference is massive. On a directory with 1000 Python files, -exec spawns 1000 processes. Xargs spawns maybe 10 to 20. For small directories it doesn’t matter. For large ones, xargs finishes in seconds instead of minutes.

This is the main reason I reach for xargs over -exec. Combined with fd (which I covered in a previous article) or ripgrep (covered here), xargs creates a fast search-and-act pipeline that’s hard to beat.

When Not to Use the xargs Command

The xargs command is powerful, but it’s not always the right tool. If the command you’re piping to already accepts input from stdin, xargs is just extra complexity. Don’t use xargs with grep, sort, or cut. They handle pipes fine on their own.

Also, xargs has a limit on total argument length. For enormous file lists (hundreds of thousands of files), the command may fail with “Argument list too long.” In those cases, use find -exec or a loop instead. The GNU xargs manual has details on all the flags.

For parallel execution across many machines, consider GNU Parallel instead. But for everyday single-machine work, xargs is more than enough. It’s installed by default on every Linux system. The xargs man page is short and worth reading once.

I use xargs daily. Combined with find, fd, or grep, it handles most of my batch operations. For debugging tricky processes, the strace command is my go-to. But for getting work done fast, xargs is the tool I reach for every time.