Find (and kill) process locking port 3000 on Mac [closed]

Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.

---

This question does not appear to be about a specific programming problem, a software algorithm, or software tools primarily used by programmers. If you believe the question would be on-topic on another Stack Exchange site, you can leave a comment to explain where the question may be able to be answered.

Closed 12 months ago.

The community reviewed whether to reopen this question 6 months ago and left it closed:

Original close reason(s) were not resolved

Improve this question

How do I find (and kill) processes that listen to/use my TCP ports? I'm on macOS.

Sometimes,开发者_开发技巧 after a crash or some bug, my Rails app is locking port 3000. I can't find it using ps -ef...

When running

rails server

I get

Address already in use - bind(2) (Errno::EADDRINUSE)

The same issue happens when stopping Node.js process. Even after the process is stopped and the app stops running, port 3000 is locked. When starting the app again, getting

Address already in use (Errno::EADDRINUSE)

---

1. You can try netstat

   netstat -vanp tcp | grep 3000
   

2. For macOS El Capitan and newer (or if your netstat doesn't support -p), use lsof

   lsof -i tcp:3000
   

---

Find:

sudo lsof -i :3000

Kill:

kill -9 <PID>

PLEASE NOTE: -9 kills the process immediately, and gives it no chance of cleaning up after itself. This may cause problems. Consider using -15 (TERM) or -3 (QUIT) for a softer termination which allows the process to clean up after itself.

---

Quick and easiest solution:

kill -9 $(lsof -ti:3000)

For multiple ports:

kill -9 $(lsof -ti:3000,3001)

#3000 is the port to be freed

Kill multiple ports with single line command:

kill -9 $(lsof -ti:3000,3001)

#Here multiple ports 3000 and 3001 are the ports to be freed

lsof -ti:3000

If the port is occupied, the above command will return something like this: 82500 (Process ID)

lsof -ti:3001

82499

lsof -ti:3001,3000

82499 82500

kill -9 $(lsof -ti:3001,3000)

Terminates both 82499 and 82500 processes in a single command.

For using this in package.json scripts:

"scripts": {
   "start": "kill -9 $(lsof -ti:3000,3001) && npm start"
}

In terminal you can use:

npm run start

---

Nothing above worked for me. Anyone else with my experience could try the following (worked for me):

Run:

lsof -i :3000 (where 3000 is your current port in use)

then check status of the reported PID :

ps ax | grep <PID>

finally, "begone with it":

kill -QUIT <PID>

---

A one-liner to extract the PID of the process using port 3000 and kill it.

lsof -ti:3000 | xargs kill

The -t flag removes everything but the PID from the lsof output, making it easy to kill it.

---

This single command line is easy to remember:

npx kill-port 3000

You can also kill multiple ports at once:

npx kill-port 3000 3001 3002

For a more powerful tool with search:

npx fkill-cli

---

PS: They use third party javascript packages. npx comes built in with Node.js.

Sources: tweet | github

---

You can use lsof -i:3000.

That is "List Open Files". This gives you a list of the processes and which files and ports they use.

---

To forcefully kill a process like that, use the following command

lsof -n -i4TCP:3000  

OR lsof -i:3000

Where 3000 is the port number the process is running at

this returns the process id(PID) and run

kill -9 "PID"

Replace PID with the number you get after running the first command

Why kill -9 PID does not work? If you trying to kill a process with its PID and it still runs on another PID, it looks like you have started that process in a different account most probably root account. so Login in with sudo su and kill it

---

In your .bash_profile, create a shortcut for terminate the 3000 process:

terminate(){
  lsof -P | grep ':3000' | awk '{print $2}' | xargs kill -9 
}

Then, call $terminate if it's blocked.

---

To kill multi ports.

$ npx kill-port 3000 8080 8081

Process on port 3000 killed
Process on port 8080 killed
Process on port 8081 killed

Hope this help!

---

lsof -P | grep ':3000' | awk '{print $2}'

This will give you just the pid, tested on MacOS.

---

Execute in command line on OS-X El Captain:

kill -kill `lsof -t -i tcp:3000`

Terse option of lsof returns just the PID.

---

One of the ways to kill a process on a port is to use the python library: freeport (https://pypi.python.org/pypi/freeport/0.1.9) . Once installed, simply:

# install freeport
pip install freeport

# Once freeport is installed, use it as follows
$ freeport 3000
Port 3000 is free. Process 16130 killed successfully

---

To view the processes blocking the port:

netstat -vanp tcp | grep 3000

To Kill the processes blocking the port:

kill $(lsof -t -i :3000)

---

Find and kill:

This single command line is easy and works correctly.

kill -9 $(lsof -ti tcp:3000)

---

Find the open connection

lsof -i -P | grep -i "listen"

Kill by process ID

kill -9 'PID'

---

Possible ways to achieve this:

top

The top command is the traditional way to view your system’s resource usage and see the processes that are taking up the most system resources. Top displays a list of processes, with the ones using the most CPU at the top.

ps

The ps command lists running processes. The following command lists all processes running on your system:

ps -A

You could also pipe the output through grep to search for a specific process without using any other commands. The following command would search for the Firefox process:

ps -A | grep firefox

The most common way of passing signals to a program is with the kill command.

kill PID_of_target_process

lsof

List of all open files and the processes that opened them.

lsof -i -P | grep -i "listen"
kill -9 PID

or

 lsof -i tcp:3000 

---

lsof -i tcp:port_number - will list the process running on that port

kill -9 PID - will kill the process

in your case, it will be

lsof -i tcp:3000 from your terminal find the PID of process

kill -9 PID

---

I made a little function for this, add it to your rc file (.bashrc, .zshrc or whatever)

function kill-by-port {
  if [ "$1" != "" ]
  then
    kill -9 $(lsof -ni tcp:"$1" | awk 'FNR==2{print $2}')
  else
    echo "Missing argument! Usage: kill-by-port $PORT"
  fi
}

then you can just type kill-by-port 3000 to kill your rails server (substituting 3000 for whatever port it's running on)

failing that, you could always just type kill -9 $(cat tmp/pids/server.pid) from the rails root directory

---

These two commands will help you find and kill server process

1. lsof -wni tcp:3000
2. kill -9 pid

---

kill -9 $(lsof -ti:3000)

works for me on macOS always.

If you're working on a node.js project, you can add it to package.json scripts like;

"scripts": {
    ...
    "killme": "kill -9 $(lsof -ti:3000)",
    ...
  },

then

npm run killme

--

Also if you want to add system wide alias for your macOS, follow these steps;

Navigate to your home directory:

cd ~

Open up .bash_profile or zsh profile using nano or vim:

vi .bash_profile

Add an alias (press i):

alias killme="kill -9 $(lsof -ti:3000)"

save file

restart terminal

type killme to the terminal

Of course you can change port 3000 to what you want.

---

Add to ~/.bash_profile:

function killTcpListen () {
  kill -QUIT $(sudo lsof -sTCP:LISTEN -i tcp:$1 -t)
}

Then source ~/.bash_profile and run

killTcpListen 8080

---

Using sindresorhus's fkill tool, you can do this:

$ fkill :3000

---

Works for me for terminating node (Mac OS Catalina)

killall -9 node

---

TL;DR:

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

If you're in a situation where there are both clients and servers using the port, e.g.:

$ lsof -i tcp:3000
COMMAND     PID         USER   FD   TYPE             DEVICE SIZE/OFF NODE NAME
node       2043 benjiegillam   21u  IPv4 0xb1b4330c68e5ad61      0t0  TCP localhost:3000->localhost:52557 (ESTABLISHED)
node       2043 benjiegillam   22u  IPv4 0xb1b4330c8d393021      0t0  TCP localhost:3000->localhost:52344 (ESTABLISHED)
node       2043 benjiegillam   25u  IPv4 0xb1b4330c8eaf16c1      0t0  TCP localhost:3000 (LISTEN)
Google    99004 benjiegillam  125u  IPv4 0xb1b4330c8bb05021      0t0  TCP localhost:52557->localhost:3000 (ESTABLISHED)
Google    99004 benjiegillam  216u  IPv4 0xb1b4330c8e5ea6c1      0t0  TCP localhost:52344->localhost:3000 (ESTABLISHED)

then you probably don't want to kill both.

In this situation you can use -sTCP:LISTEN to only show the pid of processes that are listening. Combining this with the -t terse format you can automatically kill the process:

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

---

Here's a helper bash function to kill multiple processes by name or port

fkill() {
  for i in $@;do export q=$i;if [[ $i == :* ]];then lsof -i$i|sed -n '1!p';
  else ps aux|grep -i $i|grep -v grep;fi|awk '{print $2}'|\
  xargs -I@ sh -c 'kill -9 @&&printf "X %s->%s\n" $q @';done
}

Usage:

$ fkill [process name] [process port]

Example:

$ fkill someapp :8080 node :3333 :9000

---

You can try this

netstat -vanp tcp | grep 3000

---

I use:

lsof -wni tcp:3000

Get the PID, and:

kill -9 <PID>

---

my fav one-liner: sudo kill `sudo lsof -t -i:3000`

---

To kill port 3000 on mac, run the below command

kill -9 $(lsof -t -i:3000 -sTCP:LISTEN)