DEV Community: Anmol Sethi

Mac Text Replacement Not Working? Here's Every Fix

Anmol Sethi — Sun, 08 Nov 2026 18:36:40 +0000

You set up omw to type “On my way!” and it works in Messages. Then you try it in Slack, or Word, or a Google Doc, and nothing happens.

Text Replacements are the Mac’s built-in text expander, and they fail for a small number of reasons. Here’s each one, in the order worth checking.

The quick answer

Try the shortcut in TextEdit first. If it expands there, your replacement is fine and the app you were in either has the feature switched off (Edit → Substitutions → Text Replacement) or doesn’t use Apple’s text system at all. If it doesn’t expand in TextEdit either, check the shortcut’s spelling in System Settings → Keyboard → Text Replacements… and remember it only expands after you type a space or punctuation.

1. Test it in TextEdit

This one step tells you which half of the problem you have. Open TextEdit, make a new document, type your shortcut and press Space.

If it expands, the replacement itself is fine, and the rest of this article is about the app you were using. If it doesn’t, the problem is the replacement or the Mac, so go to step 3.

2. Turn it on in the app

Text Replacement is a per-app switch in every app that has an Edit menu built on Apple’s text system: TextEdit, Mail, Notes, Pages, Messages and many others. It can be off in one app and on in the rest.

Click into a text field, then open Edit → Substitutions and make sure Text Replacement has a tick. While you’re there, Show Substitutions lists every switch for that app in one small window.

If there’s no Substitutions menu at all, the app draws its own text fields. Skip to step 5.

3. Check the shortcut itself

Open System Settings → Keyboard and click Text Replacements…. Then check three things:

Spelling. The shortcut has to match exactly what you type. A stray space at the end is easy to miss.
No spaces inside. A shortcut is one word. my addr won’t work; myaddr will.
Not a real word. If your shortcut is a word you also type for real, like addr or sig, you’ll get the replacement when you don’t want it. Start shortcuts with a character you never type, like ; or @@.

4. Finish the word

A Text Replacement doesn’t fire when you finish typing the shortcut. It fires on the space or punctuation after it. Type omw and stop, and nothing happens. Type omw and a space, and it expands.

In some apps it shows as a suggestion instead: a small bubble under the word that you accept with Space, or dismiss with Esc. If you press Esc out of habit, you’ve turned it down.

5. The apps that never expand them

Text Replacements are part of Apple’s text system, so they only work in text fields that use it. Plenty of popular apps draw their own:

Microsoft Word, Excel and PowerPoint. They use Office’s own AutoCorrect instead. Add the same shortcut in Word under Tools → AutoCorrect.
Google Docs. It has its own list under Tools → Preferences → Substitutions.
Electron apps, such as Slack, Discord, VS Code, Notion and Obsidian. Some pick up the Mac’s spelling, but your replacements usually don’t expand.
Terminals: Terminal, iTerm2, Ghostty and the rest.
Web apps with their own editors, like many chat and email tools in the browser. A plain text box on a web page often works in Safari, but a fancy editor usually doesn’t.

There’s no setting on the Mac that changes this. You either add the shortcut again inside the app (Word, Google Docs) or use a text expander that types into any app.

6. When they don’t reach your iPhone

Text Replacements sync through iCloud, and when they don’t arrive it’s usually one of these:

Both devices must be signed in to the same Apple Account, with iCloud on.
Syncing can take a while. Add one test replacement on the Mac, and give it time before you change anything else.
If one device never gets them, signing out of iCloud and back in on that device is the usual last resort. Make sure your other iCloud data is synced first.

7. See every replacement from Terminal

The Settings list is fine for ten replacements and painful for fifty. Your Mac keeps them in a small database you can read:

sqlite3 ~/Library/KeyboardServices/TextReplacements.db \
  "select ZSHORTCUT, ZPHRASE from ZTEXTREPLACEMENTENTRY where ZWASDELETED = 0;"

It prints one replacement per line, shortcut first:

;addr|221B Baker Street, London NW1 6XE
omw|On my way!
;sig|Thanks, Anmol

Mine listed 10 (those three are examples, not mine). Change the end to select count(*) from ZTEXTREPLACEMENTENTRY where ZWASDELETED = 0; to get only the number. It’s a quick way to spot a typo in a shortcut, or a duplicate where two shortcuts fight. Only read it: changes made here don’t sync, so edit replacements in System Settings.

To back them up, select them all in the Text Replacements window (⌘A) and drag them to the desktop. You get a .plist file you can drag back in on any Mac.

When Text Replacements aren’t enough

If most of your typing happens in Slack, a terminal or Word, step 5 is the wall you keep hitting. That’s where a text expander takes over, because it watches the keyboard instead of relying on each app’s text system.

Full disclosure, I built one: Snipora. It reads your Text Replacements the first time it opens and expands them in every app, Electron apps and terminals included, and Esc undoes an expansion you didn’t want. It’s free for 15 snippets; the lifetime licence is $8.99 for the first 50 buyers, then $39.99. If your replacements only need to work in Apple’s apps, you don’t need it: the built-in ones are free and sync to your iPhone.

Back to the built-in ones.

One habit that prevents most of this

Start every shortcut with the same character. I use ;: ;addr, ;sig, ;mtg. You’ll never type it by accident, you can see all of them at a glance in the Settings list, and when one stops working, you know it’s the app and not a clash with a real word.

FAQ

Where are Text Replacements on a Mac?

System Settings → Keyboard → Text Replacements…. Click + to add one.

Why does my text replacement work in Notes but not in Word?

Word uses Office’s own AutoCorrect, not the Mac’s list. Add the shortcut under Tools → AutoCorrect in Word.

Why don’t text replacements work in Slack or VS Code?

They’re Electron apps that draw their own text fields, so Apple’s text system never sees what you type. Nothing in System Settings changes that.

Can a text replacement contain today’s date?

No. Text Replacements are fixed text. A Shortcuts keyboard shortcut or a text expander can type the date.

Can a text replacement have more than one line?

Yes, but you can’t type a line break in the Settings field. Write the text in TextEdit, copy it, and paste it into the Replace With field.

The bottom line

Test in TextEdit first. If it works there, the app is the problem: switch it on under Edit → Substitutions, or add the shortcut to the app’s own list. If it doesn’t, check the spelling, and remember the space at the end.

Which app do your text replacements fail in most? Tell me in the comments.

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

How to Test Your Local Dev Server on Your Phone

Anmol Sethi — Thu, 05 Nov 2026 15:14:44 +0000

Your Vite app loads on your phone. Then every API call fails, and the page sits there with a spinner.

Nothing is wrong with your code. On the phone, localhost is the phone. Here's how to open a dev server from your Mac on your phone, and make the API calls work too.

The short answer

Let Vite listen on your network: server.host: true in vite.config.js (or vite --host).
Open the Network address Vite prints, on a phone on the same Wi-Fi.
Proxy your API through Vite and call /api/... instead of http://localhost:3001/api/....

The rest of this post is why each step is needed, and what to do when one of them doesn't work.

Step 1: let the dev server listen on your network

Run npm run dev in a fresh Vite project and you get this:

  ➜  Local:   http://localhost:5173/
  ➜  Network: use --host to expose

Vite listens on localhost only, on purpose: nothing outside your Mac can reach a dev server by accident. To open it from your phone, tell it to listen on every network interface. You can pass --host each time, but putting it in the config means you never forget:

// vite.config.js
export default {
  server: { host: true },
};

Start it again and Vite prints a second address:

  ➜  Local:   http://localhost:5173/
  ➜  Network: http://192.168.1.33:5173/

That 192.168.1.33 is your Mac's address on your Wi-Fi. Yours will differ. If you need it outside Vite, this prints it:

ipconfig getifaddr en0

On some Macs Wi-Fi is en1, not en0; if the first prints nothing, try the second.

Type the Network address into Safari or Chrome on your phone. The phone has to be on the same Wi-Fi as the Mac; mobile data won't work, and neither will most guest networks or office networks that keep devices apart.

If the page doesn't load at all:

The macOS firewall may be blocking node. If it's on (System Settings → Network → Firewall), macOS asks whether to allow incoming connections the first time node listens on the network. Say Allow. If you clicked Deny once, find node in the firewall's Options list and change it.
A VPN on the Mac or the phone can route the request somewhere else. Turn it off for the test.
You typed localhost on the phone out of habit. It has to be the IP.

Step 2: why your API calls fail on the phone

This is the one that gets people second. The page loads, the styles load, hot reload even works, and then nothing comes back from the API.

Look at how the app calls it:

fetch("http://localhost:3001/api/projects")

On your Mac, localhost:3001 is your API, so this works. On your phone, the same JavaScript runs in the phone's browser, and localhost means the phone itself. Nothing listens on port 3001 on your phone, so the request fails. Vite isn't involved; the browser goes straight to the address in the code.

There are a few ways around it. The cleanest one is to stop the browser from calling the API at all.

The fix: proxy the API through Vite

Vite has a built-in proxy. You tell it which paths belong to the API, and it forwards those requests to the API on your Mac:

// vite.config.js
export default {
  server: {
    host: true,
    proxy: { "/api": "http://localhost:3001" },
  },
};

Then change the app to call relative paths:

fetch("/api/projects")

Now the phone only ever talks to Vite, at the Network address it already loaded the page from. Vite runs on your Mac, so when it forwards the request to localhost:3001, that's your Mac's localhost, where your API is.

Here's the result on an iPhone: the page comes from 192.168.1.33:5173, and the fetch to /api/health comes back 200 from the API on port 3001 on the Mac.

What this gets you:

The same code on the Mac and the phone. /api/... works on localhost:5173 and on the Network address, with no environment variable to switch.
No CORS. The browser sees one origin, Vite's, so there's no cross-origin request to allow.
The API stays private. It can keep listening on localhost only; just Vite has to listen on the network.

If your API's routes don't start with /api (say the backend serves /projects and the app calls /api/projects), strip the prefix on the way through:

proxy: {
  "/api": {
    target: "http://localhost:3001",
    rewrite: (path) => path.replace(/^\/api/, ""),
  },
},

If the backend is a NestJS app with app.setGlobalPrefix("api"), its routes already start with /api and the short version works as it is.

Other ways, and when they're better

Put the Mac's IP in the API URL. For example VITE_API_URL=http://192.168.1.33:3001 and fetch(import.meta.env.VITE_API_URL + "/projects"). It works, but the API now has to listen on the network too, it needs CORS for the phone's origin, and the IP changes when you switch networks or the router hands out a new one. Fine for a quick check; the proxy is less to keep in sync.

Use a tunnel. cloudflared tunnel --url http://localhost:5173 (Cloudflare) or ngrok http 5173 gives you a public HTTPS address. That's the one to use when the phone isn't on your Wi-Fi, when you want to send the link to someone else, or when you're testing anything a browser only allows over HTTPS: the camera, geolocation, service workers, Web Share. Keep the Vite proxy; the tunnel only needs to reach Vite. Vite may block the tunnel's hostname until you add it to server.allowedHosts.

A real device over USB. Safari's Web Inspector (Develop menu → your iPhone) and Chrome's remote debugging for Android let you see the phone's console and network tab from the Mac. Turn it on once and you'll see the failed localhost request straight away next time, instead of guessing.

Typing the IP gets old

You'll do this often enough that typing 192.168.1.33:5173 on a phone keyboard gets tedious. Two shortcuts:

In Chrome on the Mac, open the Network address, then the share menu (or right-click the page) → Create QR Code, and scan it with the phone's camera.
Bookmark the address on the phone. It stays right as long as your Mac keeps the same IP, which on a home network is usually true for a while.

I also build a menu bar app for local dev servers, Portlivo (full disclosure, it's mine). It marks the servers your phone can reach and has a Show QR Code for Phone item for each one, so I scan instead of typing. Servers that only listen on localhost don't get one, which is a handy hint that host: true is missing. It's at portlivo.com. Back to the setup.

A checklist for next time

server.host: true in vite.config.js.
Phone on the same Wi-Fi, opened at the Network address, not localhost.
Firewall allows node.
API calls are relative (/api/...) and server.proxy sends them to the backend.
Need HTTPS or a different network: a tunnel to Vite.

What's the first thing that broke the last time you tested a local app on your phone?

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

How to kill the process on a port on a Mac (and what to do when it comes back)

Anmol Sethi — Fri, 23 Oct 2026 13:30:00 +0000

You kill whatever is on port 5432, run your app, and get the same error. The process is back with a new PID. Most guides stop at kill -9, which is the wrong fix for this. Here's the full routine, in the order I use it.

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:

See what's listening: lsof -nP -iTCP:3000 -sTCP:LISTEN
Check it's the right thing: ps -p <PID> -o command=
Ask it to quit: kill <PID>
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?

Command	Signal	When to use it
`kill <PID>`	SIGTERM	First choice. The server closes files and connections, then exits.
`kill -INT <PID>`	SIGINT	What Ctrl-C sends. Some servers only clean up on this one.
`kill -9 <PID>`	SIGKILL	Last resort. It can't be caught, so nothing gets cleaned up.

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:

What holds the port	Stop it with
Homebrew service (Postgres, MySQL, Redis)	`brew services stop <name>`
Docker or OrbStack container	`docker stop <container>`
pm2	`pm2 stop <name>`
nodemon or a file watcher	Ctrl-C in the terminal that runs it
launchd agent	`launchctl bootout gui/$(id -u)/<label>`
Laravel Herd (nginx, PHP, dnsmasq)	Stop it from Herd

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.

How to Find Which Project Is Running on a Port on Mac

Anmol Sethi — Thu, 22 Oct 2026 04:54:49 +0000

You open localhost:3000 and it's the wrong app. Or npm run dev says the port is taken, and lsof tells you it's node. Every dev server is node.

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:LISTEN prints 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:

Editor	Command	Install the command
VS Code	`code ~/Code/acme-web`	Command Palette → Shell Command: Install 'code' command in PATH
Cursor	`cursor ~/Code/acme-web`	Command Palette → Shell Command: Install 'cursor' command
Zed	`zed ~/Code/acme-web`	Zed menu → Install CLI
Any app	`open -a "Visual Studio Code" ~/Code/acme-web`	Nothing to install

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.

What you see	What it is	Where to look instead
`com.docker.backend` or OrbStack holds the port	A container	`docker ps --filter publish=3000`, then the Compose label below
Folder is `/`, command is `postgres`, `redis-server` or `mysqld`	A Homebrew service, started by launchd	`brew services list`. It isn't tied to a project.
Folder is `/`, command is `nginx`	Laravel Herd or Valet	`herd links` or `valet links` list the folder behind each `.test` site
Folder ends in `/public`	`php artisan serve`, which runs from the public folder	`git -C <folder> rev-parse --show-toplevel` for the project root
Folder is your home folder or `/`, process is `node`	Started by pm2 or another process manager	`pm2 list`, then `pm2 describe <name>` shows its exec cwd
lsof prints nothing, but the port is taken	A process owned by root or another user	Run the same commands with `sudo`

For a Docker Compose container, this prints the folder of the project that started it:

docker inspect <container> | grep working_dir

"com.docker.compose.project.working_dir": "/Users/you/Code/acme-web",

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.

What's running on my Mac? How to see every dev server and port

Anmol Sethi — Mon, 19 Oct 2026 02:24:46 +0000

A Vite app from this morning, an artisan serve from yesterday, Postgres, Redis, and whatever your coding agent started in the background. By the afternoon most of us have no idea what's actually running. Here's how to see all of it from Terminal.

The one command

This lists every TCP port something is listening on, with the program and its PID:

lsof -nP -iTCP -sTCP:LISTEN

A typical afternoon looks like this:

COMMAND     PID USER   FD   TYPE  DEVICE SIZE/OFF NODE NAME
node      48213 you    23u  IPv6  0x8c2f…      0t0  TCP *:3000 (LISTEN)
node      51877 you    24u  IPv4  0x1d07…      0t0  TCP 127.0.0.1:5173 (LISTEN)
php       52210 you     8u  IPv4  0x6b3a…      0t0  TCP 127.0.0.1:8000 (LISTEN)
postgres    611 you     7u  IPv6  0x4e19…      0t0  TCP [::1]:5432 (LISTEN)
redis-ser   702 you     6u  IPv4  0x93c4…      0t0  TCP 127.0.0.1:6379 (LISTEN)
ControlCe   423 you     9u  IPv4  0x2f88…      0t0  TCP *:7000 (LISTEN)

Three things worth knowing when you read it:

*:3000 accepts connections from other devices on your network. 127.0.0.1 or [::1] means only this Mac.
Names are cut to nine characters: redis-ser is redis-server, and ControlCe is ControlCenter, which is macOS's AirPlay Receiver (it's why port 5000 is often taken). Add +c 0 for full names.
One server can appear twice, once for IPv4 and once for IPv6, with the same PID.

Which project is it?

lsof says node or php, not "the shop frontend". To get the full command and the folder a process runs in:

ps -p <PID> -o command=
lsof -a -p <PID> -d cwd -Fn | sed -n 's/^n//p'

Or for every listening process at once, folder first:

for pid in $(lsof -ti -iTCP -sTCP:LISTEN | sort -u); do
  printf '%s\t%s\n' "$(lsof -a -p "$pid" -d cwd -Fn | sed -n 's/^n//p')" "$(ps -p "$pid" -o command=)"
done

A folder of / usually means a system or app process, like an editor helper, rather than one of your projects.

Which ones can your phone reach?

Anything not bound to 127.0.0.1 or [::1] is reachable from your network:

lsof -nP -iTCP -sTCP:LISTEN | grep -vE '127\.0\.0\.1|\[::1\]'

That's what you want when testing on a phone, and worth checking on café Wi-Fi. Most dev servers only listen on localhost unless you pass --host (Vite) or -H 0.0.0.0 (Next.js).

Docker and Homebrew hide behind other names

Ports published by Docker show up in lsof as com.docker.backend (or OrbStack), not as your app. Homebrew services show as the database itself. List them directly:

docker ps --format '{{.Names}}\t{{.Ports}}'
brew services list

Why not Activity Monitor?

Activity Monitor shows processes with CPU and memory, but not their ports. You can double-click a process and open Open Files and Ports, one process at a time. Fine for one server, slow for ten.

Or keep it in the menu bar

I ran these commands often enough that I built Portlivo, a Mac menu bar app that keeps this list live: every server named by its project, with the command, uptime, whether it's answering, CPU and memory, and Docker and Homebrew services alongside. One click opens, restarts, tails or stops any of them. It's a native app with a 7-day free trial.

Takeaways

lsof -nP -iTCP -sTCP:LISTEN shows every listening port.
ps -p <PID> -o command= and the cwd lookup tell you which project it is.
* in the address means your network can reach it; 127.0.0.1 means only you.

How to fix "port already in use" on a Mac (and stop it happening)

Anmol Sethi — Sun, 18 Oct 2026 10:30:00 +0000

You run npm run dev and get this:

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.