diff --git a/cmd/exec.go b/cmd/exec.go
index b14ab6c5ab58..e6708755df56 100644
--- a/cmd/exec.go
+++ b/cmd/exec.go
@@ -110,7 +110,7 @@ func executeExec(ctx context.Context, dev *model.Dev, args []string) error {
 	if dev.RemoteModeEnabled() {
 		log.Infof("executing remote command over SSH")
 		dev.LoadRemote(ssh.GetPublicKey())
-		return ssh.Exec(ctx, dev.RemotePort, true, os.Stdin, os.Stdout, os.Stderr, wrapped)
+		return ssh.Exec(ctx, dev.Interface, dev.RemotePort, true, os.Stdin, os.Stdout, os.Stderr, wrapped)
 	}
 
 	return exec.Exec(ctx, client, cfg, dev.Namespace, p.Name, dev.Container, true, os.Stdin, os.Stdout, os.Stderr, wrapped)
diff --git a/cmd/up/up.go b/cmd/up/up.go
index d2695fedfadc..11d684e217bc 100644
--- a/cmd/up/up.go
+++ b/cmd/up/up.go
@@ -54,7 +54,7 @@ import (
 const ReconnectingMessage = "Trying to reconnect to your cluster. File synchronization will automatically resume when the connection improves."
 
 var (
-	localClusters = []string{"127.", "172.", "192.", "169.", "localhost", "::1", "fe80::", "fc00::"}
+	localClusters = []string{"127.", "172.", "192.", "169.", model.Localhost, "::1", "fe80::", "fc00::"}
 )
 
 //Up starts a development container
@@ -588,7 +588,7 @@ func (up *upContext) forwards(ctx context.Context) error {
 	}
 
 	log.Infof("starting port forwards")
-	up.Forwarder = forward.NewPortForwardManager(ctx, up.RestConfig, up.Client)
+	up.Forwarder = forward.NewPortForwardManager(ctx, up.Dev.Interface, up.RestConfig, up.Client)
 
 	for _, f := range up.Dev.Forward {
 		if err := up.Forwarder.Add(f); err != nil {
@@ -609,12 +609,12 @@ func (up *upContext) forwards(ctx context.Context) error {
 
 func (up *upContext) sshForwards(ctx context.Context) error {
 	log.Infof("starting SSH port forwards")
-	f := forward.NewPortForwardManager(ctx, up.RestConfig, up.Client)
+	f := forward.NewPortForwardManager(ctx, up.Dev.Interface, up.RestConfig, up.Client)
 	if err := f.Add(model.Forward{Local: up.Dev.RemotePort, Remote: up.Dev.SSHServerPort}); err != nil {
 		return err
 	}
 
-	up.Forwarder = ssh.NewForwardManager(ctx, fmt.Sprintf(":%d", up.Dev.RemotePort), "localhost", "0.0.0.0", f)
+	up.Forwarder = ssh.NewForwardManager(ctx, fmt.Sprintf(":%d", up.Dev.RemotePort), up.Dev.Interface, "0.0.0.0", f)
 
 	if err := up.Forwarder.Add(model.Forward{Local: up.Sy.RemotePort, Remote: syncthing.ClusterPort}); err != nil {
 		return err
@@ -636,7 +636,7 @@ func (up *upContext) sshForwards(ctx context.Context) error {
 		}
 	}
 
-	if err := ssh.AddEntry(up.Dev.Name, up.Dev.RemotePort); err != nil {
+	if err := ssh.AddEntry(up.Dev.Name, up.Dev.Interface, up.Dev.RemotePort); err != nil {
 		log.Infof("failed to add entry to your SSH config file: %s", err)
 		return fmt.Errorf("failed to add entry to your SSH config file")
 	}
@@ -843,7 +843,7 @@ func (up *upContext) runCommand(ctx context.Context) error {
 	up.updateStateFile(ready)
 
 	if up.Dev.RemoteModeEnabled() {
-		return ssh.Exec(ctx, up.Dev.RemotePort, true, os.Stdin, os.Stdout, os.Stderr, up.Dev.Command.Values)
+		return ssh.Exec(ctx, up.Dev.Interface, up.Dev.RemotePort, true, os.Stdin, os.Stdout, os.Stderr, up.Dev.Command.Values)
 	}
 
 	return exec.Exec(
diff --git a/pkg/cmd/build/image.go b/pkg/cmd/build/image.go
index 6e6e8ae222b0..713a4f3f86c7 100644
--- a/pkg/cmd/build/image.go
+++ b/pkg/cmd/build/image.go
@@ -35,7 +35,7 @@ func GetRepoNameWithoutTag(name string) string {
 		return name[:i]
 	}
 	i = strings.IndexRune(name, '/')
-	if i == -1 || (!strings.ContainsAny(name[:i], ".:") && name[:i] != "localhost") {
+	if i == -1 || (!strings.ContainsAny(name[:i], ".:") && name[:i] != model.Localhost) {
 		domain, remainder = "", name
 	} else {
 		domain, remainder = name[:i], name[i+1:]
diff --git a/pkg/cmd/login/login.go b/pkg/cmd/login/login.go
index 913758baf978..753575c6e257 100644
--- a/pkg/cmd/login/login.go
+++ b/pkg/cmd/login/login.go
@@ -80,7 +80,7 @@ func StartWithBrowser(ctx context.Context, url string) (*Handler, error) {
 		return nil, fmt.Errorf("couldn't generate a random token, please try again")
 	}
 
-	port, err := model.GetAvailablePort()
+	port, err := model.GetAvailablePort(model.Localhost)
 
 	if err != nil {
 		log.Infof("couldn't access the network: %s", err)
diff --git a/pkg/k8s/forward/manager.go b/pkg/k8s/forward/manager.go
index 22bc57ae399b..0f2adf507149 100644
--- a/pkg/k8s/forward/manager.go
+++ b/pkg/k8s/forward/manager.go
@@ -19,7 +19,7 @@ import (
 	"fmt"
 	"io/ioutil"
 	"net/http"
-	"os"
+	"runtime"
 	"time"
 
 	"github.com/okteto/okteto/pkg/k8s/pods"
@@ -39,6 +39,7 @@ const devName = "okteto-development"
 // PortForwardManager keeps a list of all the active port forwards
 type PortForwardManager struct {
 	stopped        bool
+	iface          string
 	ports          map[int]model.Forward
 	services       map[string]struct{}
 	activeDev      *active
@@ -78,9 +79,10 @@ func (a *active) error() error {
 }
 
 // NewPortForwardManager initializes a new instance
-func NewPortForwardManager(ctx context.Context, restConfig *rest.Config, c kubernetes.Interface) *PortForwardManager {
+func NewPortForwardManager(ctx context.Context, iface string, restConfig *rest.Config, c kubernetes.Interface) *PortForwardManager {
 	return &PortForwardManager{
 		ctx:        ctx,
+		iface:      iface,
 		ports:      make(map[int]model.Forward),
 		services:   make(map[string]struct{}),
 		restConfig: restConfig,
@@ -94,8 +96,17 @@ func (p *PortForwardManager) Add(f model.Forward) error {
 		return fmt.Errorf("port %d is listed multiple times, please check your configuration", f.Local)
 	}
 
-	if !model.IsPortAvailable(f.Local) {
-		return fmt.Errorf("port %d is already in use in your local machine, please check your configuration", f.Local)
+	if !model.IsPortAvailable(p.iface, f.Local) {
+		if f.Local <= 1024 {
+			os := runtime.GOOS
+			switch os {
+			case "darwin":
+				return fmt.Errorf("local port %d is privileged. Define 'interface: 0.0.0.0' in your okteto manifest and try again", f.Local)
+			case "linux":
+				return fmt.Errorf("local port %d is privileged. Try running \"sudo setcap 'cap_net_bind_service=+ep' /usr/local/bin/okteto\" and try again", f.Local)
+			}
+		}
+		return fmt.Errorf("local port %d is already in-use in your local machine", f.Local)
 	}
 
 	p.ports[f.Local] = f
@@ -170,7 +181,6 @@ func (p *PortForwardManager) buildForwarderToDevPod(namespace, pod string) (*act
 }
 
 func (p *PortForwardManager) buildForwarder(name, namespace, pod string, ports []string) (*active, *portforward.PortForwarder, error) {
-	addresses := getListenAddresses()
 	dialer, err := p.buildDialer(namespace, pod)
 	if err != nil {
 		return nil, nil, err
@@ -184,7 +194,7 @@ func (p *PortForwardManager) buildForwarder(name, namespace, pod string, ports [
 
 	pf, err := portforward.NewOnAddresses(
 		dialer,
-		addresses,
+		[]string{p.iface},
 		ports,
 		a.stopChan,
 		a.readyChan,
@@ -275,13 +285,3 @@ func (p *PortForwardManager) forwardService(ctx context.Context, namespace, serv
 		<-t.C
 	}
 }
-
-func getListenAddresses() []string {
-	addresses := []string{"localhost"}
-	extraAddress := os.Getenv("OKTETO_ADDRESS")
-	if len(extraAddress) > 0 {
-		addresses = append(addresses, extraAddress)
-	}
-
-	return addresses
-}
diff --git a/pkg/k8s/forward/manager_test.go b/pkg/k8s/forward/manager_test.go
index 61ea3f03df68..799cd0dce332 100644
--- a/pkg/k8s/forward/manager_test.go
+++ b/pkg/k8s/forward/manager_test.go
@@ -15,7 +15,6 @@ package forward
 
 import (
 	"context"
-	"os"
 	"reflect"
 	"sort"
 	"testing"
@@ -25,7 +24,7 @@ import (
 
 func TestAdd(t *testing.T) {
 
-	pf := NewPortForwardManager(context.Background(), nil, nil)
+	pf := NewPortForwardManager(context.Background(), model.Localhost, nil, nil)
 	if err := pf.Add(model.Forward{Local: 10100, Remote: 1010}); err != nil {
 		t.Fatal(err)
 	}
@@ -52,7 +51,7 @@ func TestAdd(t *testing.T) {
 }
 
 func TestStop(t *testing.T) {
-	pf := NewPortForwardManager(context.Background(), nil, nil)
+	pf := NewPortForwardManager(context.Background(), model.Localhost, nil, nil)
 	pf.activeDev = &active{
 		readyChan: make(chan struct{}, 1),
 		stopChan:  make(chan struct{}, 1),
@@ -147,36 +146,6 @@ func Test_active_closeReady(t *testing.T) {
 	}
 }
 
-func Test_getListenAddresses(t *testing.T) {
-	tests := []struct {
-		name  string
-		want  []string
-		extra string
-	}{
-		{
-			name: "default",
-			want: []string{"localhost"},
-		},
-		{
-			name:  "from-env",
-			want:  []string{"localhost", "0.0.0.0"},
-			extra: "0.0.0.0",
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			os.Unsetenv("OKTETO_ADDRESS")
-			if len(tt.extra) > 0 {
-				os.Setenv("OKTETO_ADDRESS", tt.extra)
-			}
-
-			if got := getListenAddresses(); !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("getListenAddresses() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
 func Test_getServicePorts(t *testing.T) {
 	tests := []struct {
 		name     string
diff --git a/pkg/model/dev.go b/pkg/model/dev.go
index cd015b56d2db..7e77e11fcefb 100644
--- a/pkg/model/dev.go
+++ b/pkg/model/dev.go
@@ -36,6 +36,8 @@ import (
 )
 
 const (
+	//Localhost localhost
+	Localhost                   = "localhost"
 	oktetoSSHServerPortVariable = "OKTETO_REMOTE_PORT"
 	oktetoDefaultSSHServerPort  = 2222
 	//OktetoDefaultPVSize default volume size
@@ -131,6 +133,7 @@ type Dev struct {
 	parentSyncFolder     string                `json:"-" yaml:"-"`
 	Forward              []Forward             `json:"forward,omitempty" yaml:"forward,omitempty"`
 	Reverse              []Reverse             `json:"reverse,omitempty" yaml:"reverse,omitempty"`
+	Interface            string                `json:"interface,omitempty" yaml:"interface,omitempty"`
 	Resources            ResourceRequirements  `json:"resources,omitempty" yaml:"resources,omitempty"`
 	Services             []*Dev                `json:"services,omitempty" yaml:"services,omitempty"`
 	PersistentVolumeInfo *PersistentVolumeInfo `json:"persistentVolume,omitempty" yaml:"persistentVolume,omitempty"`
@@ -438,6 +441,9 @@ func (dev *Dev) setDefaults() error {
 	if dev.Annotations == nil {
 		dev.Annotations = map[string]string{}
 	}
+	if dev.Interface == "" {
+		dev.Interface = Localhost
+	}
 	if dev.SSHServerPort == 0 {
 		dev.SSHServerPort = oktetoDefaultSSHServerPort
 	}
@@ -576,7 +582,7 @@ func validateSecrets(secrets []Secret) error {
 //LoadRemote configures remote execution
 func (dev *Dev) LoadRemote(pubKeyPath string) {
 	if dev.RemotePort == 0 {
-		p, err := GetAvailablePort()
+		p, err := GetAvailablePort(dev.Interface)
 		if err != nil {
 			log.Infof("failed to get random port for SSH connection: %s", err)
 			p = 2222
diff --git a/pkg/model/port.go b/pkg/model/port.go
index cddfb6a5d754..efee74a995d1 100644
--- a/pkg/model/port.go
+++ b/pkg/model/port.go
@@ -21,8 +21,8 @@ import (
 )
 
 // GetAvailablePort returns a random port that's available
-func GetAvailablePort() (int, error) {
-	address, err := net.ResolveTCPAddr("tcp", "127.0.0.1:0")
+func GetAvailablePort(iface string) (int, error) {
+	address, err := net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:0", iface))
 	if err != nil {
 		return 0, err
 	}
@@ -38,8 +38,8 @@ func GetAvailablePort() (int, error) {
 }
 
 // IsPortAvailable returns true if the port is already taken
-func IsPortAvailable(port int) bool {
-	address := fmt.Sprintf("127.0.0.1:%d", port)
+func IsPortAvailable(iface string, port int) bool {
+	address := fmt.Sprintf("%s:%d", iface, port)
 	listener, err := net.Listen("tcp", address)
 	if err != nil {
 		log.Infof("port %s is taken: %s", address, err)
diff --git a/pkg/model/port_test.go b/pkg/model/port_test.go
index a34eeffd87fd..77f8109c709e 100644
--- a/pkg/model/port_test.go
+++ b/pkg/model/port_test.go
@@ -20,7 +20,7 @@ import (
 )
 
 func TestGetAvailablePort(t *testing.T) {
-	p, err := GetAvailablePort()
+	p, err := GetAvailablePort(Localhost)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -31,23 +31,23 @@ func TestGetAvailablePort(t *testing.T) {
 }
 
 func TestIsPortAvailable(t *testing.T) {
-	p, err := GetAvailablePort()
+	p, err := GetAvailablePort(Localhost)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	if !IsPortAvailable(p) {
+	if !IsPortAvailable(Localhost, p) {
 		t.Fatalf("port %d wasn't available", p)
 	}
 
-	l, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", p))
+	l, err := net.Listen("tcp", fmt.Sprintf("%s:%d", Localhost, p))
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	defer l.Close()
 
-	if IsPortAvailable(p) {
+	if IsPortAvailable(Localhost, p) {
 		t.Fatalf("port %d was available", p)
 	}
 }
diff --git a/pkg/ssh/exec.go b/pkg/ssh/exec.go
index e85d966e496d..7fbc69fa1c60 100644
--- a/pkg/ssh/exec.go
+++ b/pkg/ssh/exec.go
@@ -29,7 +29,7 @@ import (
 )
 
 // Exec executes the command over SSH
-func Exec(ctx context.Context, remotePort int, tty bool, inR io.Reader, outW, errW io.Writer, command []string) error {
+func Exec(ctx context.Context, iface string, remotePort int, tty bool, inR io.Reader, outW, errW io.Writer, command []string) error {
 	log.Info("starting SSH connection")
 	sshConfig, err := getSSHClientConfig()
 	if err != nil {
@@ -39,7 +39,7 @@ func Exec(ctx context.Context, remotePort int, tty bool, inR io.Reader, outW, er
 	var connection *ssh.Client
 	t := time.NewTicker(100 * time.Millisecond)
 	for i := 0; i < 100; i++ {
-		connection, err = ssh.Dial("tcp", fmt.Sprintf("localhost:%d", remotePort), sshConfig)
+		connection, err = ssh.Dial("tcp", fmt.Sprintf("%s:%d", iface, remotePort), sshConfig)
 		if err == nil {
 			break
 		}
diff --git a/pkg/ssh/manager.go b/pkg/ssh/manager.go
index 2a93c2846936..5c2cb629725d 100644
--- a/pkg/ssh/manager.go
+++ b/pkg/ssh/manager.go
@@ -16,6 +16,7 @@ package ssh
 import (
 	"context"
 	"fmt"
+	"runtime"
 
 	k8sforward "github.com/okteto/okteto/pkg/k8s/forward"
 	"github.com/okteto/okteto/pkg/log"
@@ -55,8 +56,17 @@ func (fm *ForwardManager) canAdd(localPort int) error {
 		return fmt.Errorf("port %d is listed multiple times, please check your forwards configuration", localPort)
 	}
 
-	if !model.IsPortAvailable(localPort) {
-		return fmt.Errorf("port %d is already in use in your local machine, please check your configuration", localPort)
+	if !model.IsPortAvailable(fm.localInterface, localPort) {
+		if localPort <= 1024 {
+			os := runtime.GOOS
+			switch os {
+			case "darwin":
+				return fmt.Errorf("local port %d is privileged. Define 'interface: 0.0.0.0' in your okteto manifest and try again", localPort)
+			case "linux":
+				return fmt.Errorf("local port %d is privileged. Try running \"sudo setcap 'cap_net_bind_service=+ep' /usr/local/bin/okteto\" and try again", localPort)
+			}
+		}
+		return fmt.Errorf("local port %d is already in-use in your local machine", localPort)
 	}
 
 	return nil
diff --git a/pkg/ssh/manager_test.go b/pkg/ssh/manager_test.go
index 2263ab5db8c0..ae20b981aba2 100644
--- a/pkg/ssh/manager_test.go
+++ b/pkg/ssh/manager_test.go
@@ -53,7 +53,7 @@ func (t *testSSHHandler) listenAndServe(address string) {
 
 func TestForward(t *testing.T) {
 	ctx := context.Background()
-	sshPort, err := model.GetAvailablePort()
+	sshPort, err := model.GetAvailablePort(model.Localhost)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -61,7 +61,7 @@ func TestForward(t *testing.T) {
 	sshAddr := fmt.Sprintf("localhost:%d", sshPort)
 	ssh := testSSHHandler{}
 	go ssh.listenAndServe(sshAddr)
-	fm := NewForwardManager(ctx, sshAddr, "localhost", "0.0.0.0", nil)
+	fm := NewForwardManager(ctx, sshAddr, model.Localhost, "0.0.0.0", nil)
 
 	if err := startServers(fm); err != nil {
 		t.Fatal(err)
@@ -84,7 +84,7 @@ func TestForward(t *testing.T) {
 
 func TestReverse(t *testing.T) {
 	ctx := context.Background()
-	sshPort, err := model.GetAvailablePort()
+	sshPort, err := model.GetAvailablePort(model.Localhost)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -92,7 +92,7 @@ func TestReverse(t *testing.T) {
 	sshAddr := fmt.Sprintf("localhost:%d", sshPort)
 	ssh := testSSHHandler{}
 	go ssh.listenAndServe(sshAddr)
-	fm := NewForwardManager(ctx, sshAddr, "localhost", "0.0.0.0", nil)
+	fm := NewForwardManager(ctx, sshAddr, model.Localhost, "0.0.0.0", nil)
 
 	if err := connectReverseForwards(fm); err != nil {
 		t.Fatal(err)
@@ -114,12 +114,12 @@ func TestReverse(t *testing.T) {
 
 func startServers(fm *ForwardManager) error {
 	for i := 0; i < 1; i++ {
-		local, err := model.GetAvailablePort()
+		local, err := model.GetAvailablePort(model.Localhost)
 		if err != nil {
 			return err
 		}
 
-		remote, err := model.GetAvailablePort()
+		remote, err := model.GetAvailablePort(model.Localhost)
 		if err != nil {
 			return err
 		}
@@ -139,12 +139,12 @@ func startServers(fm *ForwardManager) error {
 
 func connectReverseForwards(fm *ForwardManager) error {
 	for i := 0; i < 1; i++ {
-		local, err := model.GetAvailablePort()
+		local, err := model.GetAvailablePort(model.Localhost)
 		if err != nil {
 			return err
 		}
 
-		remote, err := model.GetAvailablePort()
+		remote, err := model.GetAvailablePort(model.Localhost)
 		if err != nil {
 			return err
 		}
diff --git a/pkg/ssh/ssh.go b/pkg/ssh/ssh.go
index c44a1edc55d7..f5711c694562 100644
--- a/pkg/ssh/ssh.go
+++ b/pkg/ssh/ssh.go
@@ -27,11 +27,11 @@ func buildHostname(name string) string {
 }
 
 // AddEntry adds an entry to the user's sshconfig
-func AddEntry(name string, port int) error {
-	return add(getSSHConfigPath(), buildHostname(name), port)
+func AddEntry(name, iface string, port int) error {
+	return add(getSSHConfigPath(), buildHostname(name), iface, port)
 }
 
-func add(path, name string, port int) error {
+func add(path, name, iface string, port int) error {
 	cfg, err := getConfig(path)
 	if err != nil {
 		return err
@@ -44,7 +44,7 @@ func add(path, name string, port int) error {
 	host := newHost([]string{name}, []string{"entry generated by okteto"})
 	host.params = []*param{
 		newParam(forwardAgentKeyword, []string{"yes"}, nil),
-		newParam(hostNameKeyword, []string{"localhost"}, nil),
+		newParam(hostNameKeyword, []string{iface}, nil),
 		newParam(portKeyword, []string{strconv.Itoa(port)}, nil),
 		newParam(strictHostKeyCheckingKeyword, []string{"no"}, nil),
 		newParam(userKnownHostsFileKeyword, []string{"/dev/null"}, nil),
@@ -89,8 +89,7 @@ func findHost(cfg *sshConfig, name string) (int, bool) {
 			if hn == name {
 				p := h.getParam(portKeyword)
 				s := h.getParam(strictHostKeyCheckingKeyword)
-				h := h.getParam(hostNameKeyword)
-				if p != nil && s != nil && h != nil && h.value() == "localhost" {
+				if p != nil && s != nil {
 					return i, true
 				}
 			}
diff --git a/pkg/ssh/ssh_test.go b/pkg/ssh/ssh_test.go
index b4c0e61a17ac..0869fce1b7ba 100644
--- a/pkg/ssh/ssh_test.go
+++ b/pkg/ssh/ssh_test.go
@@ -19,6 +19,8 @@ import (
 	"path/filepath"
 	"strings"
 	"testing"
+
+	"github.com/okteto/okteto/pkg/model"
 )
 
 func Test_addOnEmpty(t *testing.T) {
@@ -35,7 +37,7 @@ func Test_addOnEmpty(t *testing.T) {
 
 	sshConfig := filepath.Join(dir, "config")
 
-	if err := add(sshConfig, "test.okteto", 8080); err != nil {
+	if err := add(sshConfig, "test.okteto", model.Localhost, 8080); err != nil {
 		t.Fatal(err)
 	}
 
@@ -62,11 +64,11 @@ func Test_add(t *testing.T) {
 	defer os.RemoveAll(dir)
 	sshConfig := filepath.Join(dir, "config")
 
-	if err := add(sshConfig, "test.okteto", 8080); err != nil {
+	if err := add(sshConfig, "test.okteto", model.Localhost, 8080); err != nil {
 		t.Fatal(err)
 	}
 
-	if err := add(sshConfig, "test2.okteto", 8081); err != nil {
+	if err := add(sshConfig, "test2.okteto", model.Localhost, 8081); err != nil {
 		t.Fatal(err)
 	}
 
@@ -120,7 +122,7 @@ func Test_removeHost(t *testing.T) {
 					{
 						hostnames: []string{"test.okteto"},
 						params: []*param{
-							newParam(hostNameKeyword, []string{"localhost"}, nil),
+							newParam(hostNameKeyword, []string{model.Localhost}, nil),
 							newParam(portKeyword, []string{"8080"}, nil),
 							newParam(strictHostKeyCheckingKeyword, []string{"no"}, nil),
 						},
@@ -137,7 +139,7 @@ func Test_removeHost(t *testing.T) {
 					{
 						hostnames: []string{"test.okteto"},
 						params: []*param{
-							newParam(hostNameKeyword, []string{"localhost"}, nil),
+							newParam(hostNameKeyword, []string{model.Localhost}, nil),
 							newParam(portKeyword, []string{"8080"}, nil),
 							newParam(strictHostKeyCheckingKeyword, []string{"no"}, nil),
 						},
@@ -154,7 +156,7 @@ func Test_removeHost(t *testing.T) {
 					{
 						hostnames: []string{"test.okteto"},
 						params: []*param{
-							newParam(hostNameKeyword, []string{"localhost"}, nil),
+							newParam(hostNameKeyword, []string{model.Localhost}, nil),
 							newParam(portKeyword, []string{"8080"}, nil),
 							newParam(strictHostKeyCheckingKeyword, []string{"no"}, nil),
 						},
@@ -162,7 +164,7 @@ func Test_removeHost(t *testing.T) {
 					{
 						hostnames: []string{"test2.okteto"},
 						params: []*param{
-							newParam(hostNameKeyword, []string{"localhost"}, nil),
+							newParam(hostNameKeyword, []string{model.Localhost}, nil),
 							newParam(portKeyword, []string{"8080"}, nil),
 							newParam(strictHostKeyCheckingKeyword, []string{"no"}, nil),
 						},
@@ -170,7 +172,7 @@ func Test_removeHost(t *testing.T) {
 					{
 						hostnames: []string{"test3.okteto"},
 						params: []*param{
-							newParam(hostNameKeyword, []string{"localhost"}, nil),
+							newParam(hostNameKeyword, []string{model.Localhost}, nil),
 							newParam(portKeyword, []string{"8080"}, nil),
 							newParam(strictHostKeyCheckingKeyword, []string{"no"}, nil),
 						},
@@ -187,7 +189,7 @@ func Test_removeHost(t *testing.T) {
 					{
 						hostnames: []string{"test.okteto"},
 						params: []*param{
-							newParam(hostNameKeyword, []string{"localhost"}, nil),
+							newParam(hostNameKeyword, []string{model.Localhost}, nil),
 							newParam(portKeyword, []string{"8080"}, nil),
 							newParam(strictHostKeyCheckingKeyword, []string{"no"}, nil),
 						},
@@ -195,7 +197,7 @@ func Test_removeHost(t *testing.T) {
 					{
 						hostnames: []string{"test2.okteto"},
 						params: []*param{
-							newParam(hostNameKeyword, []string{"localhost"}, nil),
+							newParam(hostNameKeyword, []string{model.Localhost}, nil),
 							newParam(portKeyword, []string{"8080"}, nil),
 							newParam(strictHostKeyCheckingKeyword, []string{"no"}, nil),
 						},
@@ -203,7 +205,7 @@ func Test_removeHost(t *testing.T) {
 					{
 						hostnames: []string{"test3.okteto"},
 						params: []*param{
-							newParam(hostNameKeyword, []string{"localhost"}, nil),
+							newParam(hostNameKeyword, []string{model.Localhost}, nil),
 							newParam(portKeyword, []string{"8080"}, nil),
 							newParam(strictHostKeyCheckingKeyword, []string{"no"}, nil),
 						},
diff --git a/pkg/syncthing/syncthing.go b/pkg/syncthing/syncthing.go
index da19053e6e46..10e97e43ecf8 100644
--- a/pkg/syncthing/syncthing.go
+++ b/pkg/syncthing/syncthing.go
@@ -140,22 +140,22 @@ type FolderError struct {
 // New constructs a new Syncthing.
 func New(dev *model.Dev) (*Syncthing, error) {
 	fullPath := getInstallPath()
-	remotePort, err := model.GetAvailablePort()
+	remotePort, err := model.GetAvailablePort(dev.Interface)
 	if err != nil {
 		return nil, err
 	}
 
-	remoteGUIPort, err := model.GetAvailablePort()
+	remoteGUIPort, err := model.GetAvailablePort(dev.Interface)
 	if err != nil {
 		return nil, err
 	}
 
-	guiPort, err := model.GetAvailablePort()
+	guiPort, err := model.GetAvailablePort(dev.Interface)
 	if err != nil {
 		return nil, err
 	}
 
-	listenPort, err := model.GetAvailablePort()
+	listenPort, err := model.GetAvailablePort(dev.Interface)
 	if err != nil {
 		return nil, err
 	}
@@ -178,13 +178,13 @@ func New(dev *model.Dev) (*Syncthing, error) {
 		binPath:          fullPath,
 		Client:           NewAPIClient(),
 		FileWatcherDelay: DefaultFileWatcherDelay,
-		GUIAddress:       fmt.Sprintf("localhost:%d", guiPort),
+		GUIAddress:       fmt.Sprintf("%s:%d", dev.Interface, guiPort),
 		Home:             config.GetDeploymentHome(dev.Namespace, dev.Name),
 		LogPath:          GetLogFile(dev.Namespace, dev.Name),
-		ListenAddress:    fmt.Sprintf("localhost:%d", listenPort),
-		RemoteAddress:    fmt.Sprintf("tcp://localhost:%d", remotePort),
+		ListenAddress:    fmt.Sprintf("%s:%d", dev.Interface, listenPort),
+		RemoteAddress:    fmt.Sprintf("tcp://%s:%d", dev.Interface, remotePort),
 		RemoteDeviceID:   DefaultRemoteDeviceID,
-		RemoteGUIAddress: fmt.Sprintf("localhost:%d", remoteGUIPort),
+		RemoteGUIAddress: fmt.Sprintf("%s:%d", dev.Interface, remoteGUIPort),
 		LocalGUIPort:     guiPort,
 		LocalPort:        listenPort,
 		RemoteGUIPort:    remoteGUIPort,