The one-liner

Find the process listening on the port and ask it to quit:

lsof -ti tcp:3000 -sTCP:LISTEN | xargs kill

-t prints only PIDs. -sTCP:LISTEN is the part most snippets leave out, and it matters: without it, lsof also returns every client connected to the port. If you have the app open in a browser, that includes the browser, and you quit it instead of the server.

A range of ports works too:

lsof -ti tcp:3000-3010 -sTCP:LISTEN | xargs kill

The careful version

When you're not sure what's on the port, take it in four steps:

1. See what's listening: lsof -nP -iTCP:3000 -sTCP:LISTEN
2. Check it's the right thing: ps -p <PID> -o command=
3. Ask it to quit: kill <PID>
4. Check again after a second. Only if it's still there: kill -9 <PID>

Step 2 is the one people skip. node on port 3000 could be your app, or a different project you forgot was running.

kill, kill -INT or kill -9?

A database killed with -9 has to recover on its next start, and a dev server may leave a lock or socket file behind. Give SIGTERM a second before reaching for it.

Make it a command

If you do this every day, add a function to ~/.zshrc, open a new terminal, and run killport 3000:

killport() { lsof -ti tcp:"$1" -sTCP:LISTEN | xargs kill; }

There are npm tools too. npx kill-port 3000 sends SIGKILL straight away, with no grace period. npx fkill-cli :3000 stops the process on a port, and npx fkill-cli on its own opens an interactive picker.

If you do this several times a day: full disclosure, I built Portlivo, a Mac menu bar app that lists every dev server and port. Select one and press K, and it stops it safely, including Homebrew services and Docker containers. It's $8.99 once (early-bird) after a 7-day free trial.

Stop it by name instead

When you know what it is but not which port it took:

pgrep -lf "vite"    # list matches first
pkill -f "vite"     # then stop them

-f matches anywhere in the command line, so pkill -f node also stops your editor's helpers. Always run pgrep -lf with the same pattern first.

Check the port is free

nc -z localhost 3000 2>/dev/null && echo taken || echo free

If it still says taken a second after you stopped the process, something restarted it.

When it comes straight back

That's a supervisor doing its job. Homebrew services run under launchd with KeepAlive, so a killed Postgres is restarted within a second. Killing it harder doesn't help. Stop it where it's managed:

Not sure which one it is? brew services list and docker ps cover most cases. For other launchd agents, look in ~/Library/LaunchAgents or run launchctl list | grep <name>.

"Operation not permitted"

The process belongs to root or another user. sudo kill <PID> works, but check what it is first. One to leave alone: ControlCe on port 5000 or 7000 is macOS's AirPlay Receiver. Turn it off in System Settings → General → AirDrop & Handoff instead.

That covers every way I free a port. If it saved you a trip to Stack Overflow, follow me for more Mac developer fixes like this one.

What you actually need is the folder it was started from. macOS doesn’t have Linux’s pwdx, but lsof can tell you, and it takes about ten seconds.

The quick answer

Swap 3000 for your port:

lsof -a -p "$(lsof -ti tcp:3000 -sTCP:LISTEN | head -1)" -d cwd -Fn | sed -n 's/^n//p'

It prints the working directory of whatever is listening on the port, like /Users/you/Code/acme-web. The rest of this post is what each part does, how to get the branch and the command too, and what to do when the answer is just /.

Step 1: find the PID

lsof -nP -iTCP:3000 -sTCP:LISTEN

COMMAND   PID  USER   FD   TYPE  DEVICE SIZE/OFF NODE NAME
node    48211   you   23u  IPv6  0x7e9…      0t0  TCP *:3000 (LISTEN)

-n and -P skip the DNS and port-name lookups, so it answers instantly and shows 3000 instead of hbci. -sTCP:LISTEN keeps only the server. Without it you also get every client connected to the port, including your browser tab.

Add -t when you only want the number: lsof -ti tcp:3000 -sTCP:LISTENprints 48211.

Step 2: ask lsof for its working directory

Every process has a current directory, and lsof lists it as a file descriptor called cwd:

lsof -a -p 48211 -d cwd

COMMAND   PID USER   FD   TYPE DEVICE SIZE/OFF      NODE NAME
node    48211  you  cwd    DIR   1,18      640 382905693 /Users/you/Code/acme-web

-p picks the process, -d cwd picks the descriptor, and -a means both must match. Leave out -a and lsof ORs them, so you get every process’s cwd on the machine.

For scripts, -Fn prints just the path with an n in front, which sed -n 's/^n//p' strips off. That’s the quick answer above.

For most dev servers this is the project folder, because npm run dev, pnpm dev, rails s and go run . all run where you typed them.

Step 3: see the full command

ps -o command= -p 48211

This shows the whole command line, which often holds the path as well: node /Users/you/Code/acme-web/node_modules/.bin/vite. It also tells two servers in the same folder apart, like vite and storybook.

To see when it started, which helps spot the one you left running yesterday:

ps -o lstart= -p 48211

Step 4: get the git branch

git -C /Users/you/Code/acme-web branch --show-current

-C runs git as if you were in that folder, so you don’t have to cd. This matters more than it used to. If you keep several worktrees of one repo, or a coding agent runs servers in its own worktree, you can have three copies of the same app on three ports. The folder and the branch are the only things that tell them apart.

Two more that help here:

• git -C <folder> rev-parse --show-toplevel gives the repo root when the server runs in a subfolder, like packages/web in a monorepo.

• git -C <folder> worktree list shows every worktree of that repo and its branch.

Make it one command

Add this to ~/.zshrc, open a new terminal, and run whoport 3000:

whoport() {
  local pid dir
  pid=$(lsof -ti tcp:"$1" -sTCP:LISTEN | head -1)
  [[ -z $pid ]] && { echo "Nothing is listening on :$1"; return 1; }
  dir=$(lsof -a -p "$pid" -d cwd -Fn | sed -n 's/^n//p')
  echo "PID     $pid"
  echo "Command $(ps -o command= -p "$pid")"
  echo "Folder  $dir"
  git -C "$dir" rev-parse --is-inside-work-tree &>/dev/null &&
    echo "Branch  $(git -C "$dir" branch --show-current)"
}

% whoport 3000
PID     48211
Command node /Users/you/Code/acme-web/node_modules/.bin/vite
Folder  /Users/you/Code/acme-web
Branch  feature/search

To see every listening server with its folder at once:

lsof -tiTCP -sTCP:LISTEN | sort -u | while read pid; do
  printf '%-6s %-18.18s %s\n' "$pid" "$(ps -o comm= -p "$pid" | sed 's#.*/##')" \
    "$(lsof -a -p "$pid" -d cwd -Fn | sed -n 's/^n//p')"
done

You’ll see a few apps of your own in there too, like your editor’s helpers. Their folder is usually /.

If you check this more than once a day: full disclosure, I built Portlivo, a Mac menu bar app that shows every dev server with its project, git branch and port. Press E on one and its folder opens in VS Code, Cursor or Zed. It’s $8.99 once for the first 50 licences, after a 7-day free trial. The commands above are free and enough if you only need this now and then.

Open it in your editor

Once you have the folder, one command opens it:

Put them together and you jump from a port straight to its code: code "$(lsof -a -p "$(lsof -ti tcp:3000 -sTCP:LISTEN | head -1)" -d cwd -Fn | sed -n 's/^n//p')".

When the folder is / or makes no sense

Some servers aren’t started from a project folder. lsof is still right; the folder just isn’t the useful answer.

If the port is taken and you want it back, I wrote up how to stop the process on a port safely, including the ones that come straight back.

FAQ

Is there a pwdx command on Mac?
No. pwdx and /proc/<PID>/cwd are Linux only. On macOS, lsof -a -p <PID> -d cwd does the same job.

How do I find which port a project is using?
Run the loop from “Make it one command”, which lists every listening server with its folder, and look for yours. Or check the project’s config: Vite defaults to 5173, Next.js and Rails to 3000, Laravel to 8000.

Does this work for Python, Ruby, Go and PHP servers?
Yes. lsof and ps don’t care what language the process is in. I tested the steps above with python3 -m http.server.

Why does lsof show nothing for a port I know is in use?
Usually the process belongs to another user, so try sudo. If it’s a Docker container, lsof shows Docker’s own process, not the app inside it.

Can I see this without the terminal?
Activity Monitor shows a process’s open files and ports (double-click it, then Open Files and Ports), and the cwd is in that list. It’s slower for this than lsof, but it works.

The bottom line

lsof finds the PID, lsof -d cwd turns it into a folder, and git -C gives you the branch. Put them in a whoport function and “which project is this?” takes one command.

How many dev servers do you usually have running at once?

I’m Anmol. I build Mac apps and write about Mac productivity. Follow me on X at @anmolsethi_dev.

Error: listen EADDRINUSE: address already in use :::3000

Something is already listening on port 3000. Usually it's a dev server you started earlier and forgot about: a terminal tab you closed without stopping it, a project from yesterday, or something a coding agent started in the background.

Fix it in two commands

Find what's holding the port:

lsof -i :3000

The output lists the process name and its PID (process ID):

COMMAND   PID   USER   FD   TYPE  DEVICE  SIZE/OFF NODE NAME
node    41234  you    23u  IPv6  0x...       0t0  TCP *:hbci (LISTEN)

Then stop it:

kill 41234

If it won't go, kill -9 41234 forces it. Use that as a last resort: the process gets no chance to clean up.

One-liner, if you're sure whatever is on the port can go:

lsof -ti :3000 | xargs kill

Why it keeps happening

A modern project rarely runs one server. A frontend on 5173, an API on 8000, Postgres on 5432, Redis on 6379, maybe a worker and a docs site. Multiply that by the three projects you touched this week, and nothing on macOS shows you the full picture. Activity Monitor lists processes, not ports. lsof answers one port at a time, and only when you already know which one to ask about.

So stale servers pile up quietly, and you only notice when one blocks the port you need.

What I built instead

I got tired of the lsof ritual, so I built Portlivo, a Mac menu bar app that shows every local dev server and port at once:

• which project each server belongs to, and the command that started it

• whether it's actually answering, plus CPU and memory

• one click to open it in the browser, restart it, tail its logs or kill it

• Homebrew services like Postgres and Redis in the same list

• a QR code to open any server on your phone

When a port clash happens, it notifies you with a Kill holder & retry button, which is the button I'd wanted for years. There's also a command palette, keyboard shortcuts and a devports command-line tool if you'd rather stay in the terminal.

It's a native SwiftUI app for macOS 14 or later, on Apple silicon and Intel. No account, no subscription: a 7-day free trial, then a one-time licence.

Takeaways

• lsof -i :<port> shows what's on a port; kill <pid> stops it.

• Prefer kill over kill -9.

• The port clash is a symptom. The real problem is not being able to see what's running.

If you'd like to see everything at a glance, Portlivo is free to try for 7 days.