diff --git a/cmd/svcat/broker/describe_cmd.go b/cmd/svcat/broker/describe_cmd.go
index 6b57092ae51..fe964b72357 100644
--- a/cmd/svcat/broker/describe_cmd.go
+++ b/cmd/svcat/broker/describe_cmd.go
@@ -18,20 +18,30 @@ package broker
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/kubernetes-incubator/service-catalog/cmd/svcat/command"
 	"github.com/kubernetes-incubator/service-catalog/cmd/svcat/output"
+	servicecatalog "github.com/kubernetes-incubator/service-catalog/pkg/svcat/service-catalog"
 	"github.com/spf13/cobra"
 )
 
-type describeCmd struct {
+// DescribeCmd contains the info needed to describe a broker in detail
+type DescribeCmd struct {
 	*command.Context
-	name string
+	*command.Namespaced
+	*command.Scoped
+
+	Name string
 }
 
 // NewDescribeCmd builds a "svcat describe broker" command
 func NewDescribeCmd(cxt *command.Context) *cobra.Command {
-	describeCmd := &describeCmd{Context: cxt}
+	describeCmd := &DescribeCmd{
+		Context:    cxt,
+		Namespaced: command.NewNamespaced(cxt),
+		Scoped:     command.NewScoped(),
+	}
 	cmd := &cobra.Command{
 		Use:     "broker NAME",
 		Aliases: []string{"brokers", "brk"},
@@ -42,28 +52,39 @@ func NewDescribeCmd(cxt *command.Context) *cobra.Command {
 		PreRunE: command.PreRunE(describeCmd),
 		RunE:    command.RunE(describeCmd),
 	}
+	describeCmd.AddNamespaceFlags(cmd.Flags(), false)
+	describeCmd.AddScopedFlags(cmd.Flags(), true)
 	return cmd
 }
 
-func (c *describeCmd) Validate(args []string) error {
+// Validate checks that the required arguments have been provided
+func (c *DescribeCmd) Validate(args []string) error {
 	if len(args) == 0 {
 		return fmt.Errorf("a broker name is required")
 	}
-	c.name = args[0]
+	c.Name = args[0]
 
 	return nil
 }
 
-func (c *describeCmd) Run() error {
-	return c.Describe()
-}
-
-func (c *describeCmd) Describe() error {
-	broker, err := c.App.RetrieveBroker(c.name)
+// Run retrieves the broker(s) with the requested name, interprets
+// possible errors if we need to ask the user for more info, and displays
+// the found broker to the user
+func (c *DescribeCmd) Run() error {
+	if c.Namespace == "" {
+		c.Namespace = c.App.CurrentNamespace
+	}
+	scopeOpts := servicecatalog.ScopeOptions{
+		Scope:     c.Scope,
+		Namespace: c.Namespace,
+	}
+	broker, err := c.App.RetrieveBrokerByID(c.Name, scopeOpts)
 	if err != nil {
+		if strings.Contains(err.Error(), servicecatalog.MultipleBrokersFoundError) {
+			return fmt.Errorf(err.Error() + ", please specify a scope with --scope")
+		}
 		return err
 	}
-
 	output.WriteBrokerDetails(c.Output, broker)
 	return nil
 }
diff --git a/cmd/svcat/broker/describe_cmd_test.go b/cmd/svcat/broker/describe_cmd_test.go
index a0fb0d2751e..9bf2e092048 100644
--- a/cmd/svcat/broker/describe_cmd_test.go
+++ b/cmd/svcat/broker/describe_cmd_test.go
@@ -14,89 +14,217 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package broker
+package broker_test
 
 import (
 	"bytes"
-	"strings"
-	"testing"
+	"fmt"
 
+	. "github.com/kubernetes-incubator/service-catalog/cmd/svcat/broker"
+	"github.com/kubernetes-incubator/service-catalog/cmd/svcat/command"
 	"github.com/kubernetes-incubator/service-catalog/cmd/svcat/test"
 	"github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1"
-	svcatfake "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/fake"
 	"github.com/kubernetes-incubator/service-catalog/pkg/svcat"
+	servicecatalog "github.com/kubernetes-incubator/service-catalog/pkg/svcat/service-catalog"
+	"github.com/kubernetes-incubator/service-catalog/pkg/svcat/service-catalog/service-catalogfakes"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"github.com/spf13/pflag"
 	"k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	k8sfake "k8s.io/client-go/kubernetes/fake"
-
-	_ "github.com/kubernetes-incubator/service-catalog/internal/test"
 )
 
-func TestDescribeCommand(t *testing.T) {
-	const namespace = "default"
-	testcases := []struct {
-		name          string
-		fakeBrokers   []string
-		brokerName    string
-		expectedError string
-		wantError     bool
-	}{
-		{
-			name:          "describe non existing broker",
-			fakeBrokers:   []string{},
-			brokerName:    "mybroker",
-			expectedError: "unable to get broker 'mybroker'",
-			wantError:     true,
-		},
-		{
-			name:        "describe existing broker",
-			fakeBrokers: []string{"mybroker"},
-			brokerName:  "mybroker",
-			wantError:   false,
-		},
-	}
-
-	for _, tc := range testcases {
-		t.Run(tc.name, func(t *testing.T) {
-
-			// Setup fake data for the app
-			k8sClient := k8sfake.NewSimpleClientset()
-			var fakes []runtime.Object
-			for _, name := range tc.fakeBrokers {
-				fakes = append(fakes, &v1beta1.ClusterServiceBroker{
-					ObjectMeta: v1.ObjectMeta{
-						Name: name,
+var _ = Describe("Describe Command", func() {
+	Describe("NewDescribeCmd", func() {
+		It("Builds and returns a cobra command with the correct flags", func() {
+			cxt := &command.Context{}
+			cmd := NewDescribeCmd(cxt)
+			Expect(*cmd).NotTo(BeNil())
+			Expect(cmd.Use).To(Equal("broker NAME"))
+			Expect(cmd.Short).To(ContainSubstring("Show details of a specific broker"))
+			Expect(cmd.Example).To(ContainSubstring("svcat describe broker asb"))
+			Expect(len(cmd.Aliases)).To(Equal(2))
+		})
+	})
+
+	Describe("Validate", func() {
+		It("succeeds if a broker name is provided", func() {
+			cmd := DescribeCmd{}
+			err := cmd.Validate([]string{"bananabroker"})
+			Expect(err).NotTo(HaveOccurred())
+		})
+		It("errors if a broker name is not provided", func() {
+			cmd := DescribeCmd{}
+			err := cmd.Validate([]string{})
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("a broker name is required"))
+		})
+	})
+	Describe("Run", func() {
+		var (
+			brokerName               string
+			brokerToReturn           *v1beta1.ClusterServiceBroker
+			brokerURL                string
+			namespace                string
+			namespacedBrokerToReturn *v1beta1.ServiceBroker
+		)
+		BeforeEach(func() {
+			brokerName = "foobarbroker"
+			brokerURL = "www.foobar.com"
+			namespace = "banana-namespace"
+
+			brokerToReturn = &v1beta1.ClusterServiceBroker{
+				ObjectMeta: v1.ObjectMeta{
+					Name: brokerName,
+				},
+				Spec: v1beta1.ClusterServiceBrokerSpec{
+					CommonServiceBrokerSpec: v1beta1.CommonServiceBrokerSpec{
+						URL:                 brokerURL,
+						CatalogRestrictions: &v1beta1.CatalogRestrictions{},
+					},
+				},
+			}
+			namespacedBrokerToReturn = &v1beta1.ServiceBroker{
+				ObjectMeta: v1.ObjectMeta{
+					Name:      brokerName,
+					Namespace: namespace,
+				},
+				Spec: v1beta1.ServiceBrokerSpec{
+					CommonServiceBrokerSpec: v1beta1.CommonServiceBrokerSpec{
+						URL:                 brokerURL,
+						CatalogRestrictions: &v1beta1.CatalogRestrictions{},
 					},
-					Spec: v1beta1.ClusterServiceBrokerSpec{},
-				})
+				},
 			}
+		})
+		It("Calls the pkg/svcat libs RetrieveBrokerByID method with the passed in variables and prints output to the user", func() {
+			outputBuffer := &bytes.Buffer{}
 
-			svcatClient := svcatfake.NewSimpleClientset(fakes...)
-			fakeApp, _ := svcat.NewApp(k8sClient, svcatClient, namespace)
-			output := &bytes.Buffer{}
-			cxt := svcattest.NewContext(output, fakeApp)
+			fakeApp, _ := svcat.NewApp(nil, nil, namespace)
+			fakeSDK := new(servicecatalogfakes.FakeSvcatClient)
+			fakeSDK.RetrieveBrokerByIDReturns(brokerToReturn, nil)
+			fakeApp.SvcatClient = fakeSDK
+			cxt := svcattest.NewContext(outputBuffer, fakeApp)
+			cmd := DescribeCmd{
+				Context:    cxt,
+				Namespaced: command.NewNamespaced(cxt),
+				Name:       brokerName,
+				Scoped:     command.NewScoped(),
+			}
+			cmd.Namespaced.ApplyNamespaceFlags(&pflag.FlagSet{})
+			cmd.Scope = servicecatalog.AllScope
+			err := cmd.Run()
 
-			// Initialize the command arguments
-			cmd := &describeCmd{
-				Context: cxt,
+			Expect(err).NotTo(HaveOccurred())
+			Expect(fakeSDK.RetrieveBrokerByIDCallCount()).To(Equal(1))
+			returnedName, returnedScopeOpts := fakeSDK.RetrieveBrokerByIDArgsForCall(0)
+			Expect(returnedName).To(Equal(brokerName))
+			scopeOpts := servicecatalog.ScopeOptions{
+				Scope:     servicecatalog.AllScope,
+				Namespace: namespace,
 			}
-			cmd.name = tc.brokerName
+			Expect(returnedScopeOpts).To(Equal(scopeOpts))
 
+			output := outputBuffer.String()
+			Expect(output).To(ContainSubstring(brokerName))
+			Expect(output).To(ContainSubstring(brokerURL))
+			Expect(output).To(ContainSubstring("clusterservicebroker"))
+		})
+		It("prints out a namespaced broker when it only finds a namespace broker", func() {
+			outputBuffer := &bytes.Buffer{}
+
+			fakeApp, _ := svcat.NewApp(nil, nil, namespace)
+			fakeSDK := new(servicecatalogfakes.FakeSvcatClient)
+			fakeSDK.RetrieveBrokerByIDReturns(namespacedBrokerToReturn, nil)
+			fakeApp.SvcatClient = fakeSDK
+			cxt := svcattest.NewContext(outputBuffer, fakeApp)
+			cmd := DescribeCmd{
+				Context:    cxt,
+				Namespaced: command.NewNamespaced(cxt),
+				Name:       brokerName,
+				Scoped:     command.NewScoped(),
+			}
+			cmd.Namespaced.ApplyNamespaceFlags(&pflag.FlagSet{})
+			cmd.Scope = servicecatalog.AllScope
 			err := cmd.Run()
 
-			if tc.wantError {
-				if err == nil {
-					t.Errorf("expected a non-zero exit code, but the command succeeded")
-				}
+			Expect(err).NotTo(HaveOccurred())
+			Expect(fakeSDK.RetrieveBrokerByIDCallCount()).To(Equal(1))
+			returnedName, returnedScopeOpts := fakeSDK.RetrieveBrokerByIDArgsForCall(0)
+			Expect(returnedName).To(Equal(brokerName))
+			scopeOpts := servicecatalog.ScopeOptions{
+				Scope:     servicecatalog.AllScope,
+				Namespace: namespace,
+			}
+			Expect(returnedScopeOpts).To(Equal(scopeOpts))
+
+			output := outputBuffer.String()
+			Expect(output).To(ContainSubstring(brokerName))
+			Expect(output).To(ContainSubstring(brokerURL))
+			Expect(output).To(ContainSubstring(" servicebroker"))
+		})
+		It("bubbles up errors", func() {
+			outputBuffer := &bytes.Buffer{}
+			errMsg := "incompatible potato"
+			errToReturn := fmt.Errorf(errMsg)
+
+			fakeApp, _ := svcat.NewApp(nil, nil, namespace)
+			fakeSDK := new(servicecatalogfakes.FakeSvcatClient)
+			fakeSDK.RetrieveBrokerByIDReturns(nil, errToReturn)
+			fakeApp.SvcatClient = fakeSDK
+			cxt := svcattest.NewContext(outputBuffer, fakeApp)
+			cmd := DescribeCmd{
+				Context:    cxt,
+				Namespaced: command.NewNamespaced(cxt),
+				Name:       brokerName,
+				Scoped:     command.NewScoped(),
+			}
+			cmd.Namespaced.ApplyNamespaceFlags(&pflag.FlagSet{})
+			cmd.Scope = servicecatalog.AllScope
+			err := cmd.Run()
+
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring(errMsg))
 
-				errorOutput := err.Error()
-				if !strings.Contains(errorOutput, tc.expectedError) {
-					t.Errorf("Unexpected output:\n\nExpected:\n%q\n\nActual:\n%q\n", tc.expectedError, errorOutput)
-				}
+			Expect(fakeSDK.RetrieveBrokerByIDCallCount()).To(Equal(1))
+			returnedName, returnedScopeOpts := fakeSDK.RetrieveBrokerByIDArgsForCall(0)
+			Expect(returnedName).To(Equal(brokerName))
+			scopeOpts := servicecatalog.ScopeOptions{
+				Scope:     servicecatalog.AllScope,
+				Namespace: namespace,
 			}
-			if !tc.wantError && err != nil {
-				t.Errorf("expected the command to succeed but it failed with %q", err)
+			Expect(returnedScopeOpts).To(Equal(scopeOpts))
+		})
+		It("prompts the user for more input when it gets a MultipleBrokersFound error", func() {
+			outputBuffer := &bytes.Buffer{}
+			errToReturn := fmt.Errorf(servicecatalog.MultipleBrokersFoundError + " for '" + brokerName + "'")
+
+			fakeApp, _ := svcat.NewApp(nil, nil, namespace)
+			fakeSDK := new(servicecatalogfakes.FakeSvcatClient)
+			fakeSDK.RetrieveBrokerByIDReturns(nil, errToReturn)
+			fakeApp.SvcatClient = fakeSDK
+			cxt := svcattest.NewContext(outputBuffer, fakeApp)
+			cmd := DescribeCmd{
+				Context:    cxt,
+				Namespaced: command.NewNamespaced(cxt),
+				Name:       brokerName,
+				Scoped:     command.NewScoped(),
+			}
+			cmd.Namespaced.ApplyNamespaceFlags(&pflag.FlagSet{})
+			cmd.Scope = servicecatalog.AllScope
+			err := cmd.Run()
+
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring(servicecatalog.MultipleBrokersFoundError))
+			Expect(err.Error()).To(ContainSubstring("specify a scope with --scope"))
+
+			Expect(fakeSDK.RetrieveBrokerByIDCallCount()).To(Equal(1))
+			returnedName, returnedScopeOpts := fakeSDK.RetrieveBrokerByIDArgsForCall(0)
+			Expect(returnedName).To(Equal(brokerName))
+			scopeOpts := servicecatalog.ScopeOptions{
+				Scope:     servicecatalog.AllScope,
+				Namespace: namespace,
 			}
+			Expect(returnedScopeOpts).To(Equal(scopeOpts))
 		})
-	}
-}
+	})
+})
diff --git a/cmd/svcat/broker/get_cmd.go b/cmd/svcat/broker/get_cmd.go
index b2e6060f225..da2bbaa912c 100644
--- a/cmd/svcat/broker/get_cmd.go
+++ b/cmd/svcat/broker/get_cmd.go
@@ -17,22 +17,27 @@ limitations under the License.
 package broker
 
 import (
+	"fmt"
+	"strings"
+
 	"github.com/kubernetes-incubator/service-catalog/cmd/svcat/command"
 	"github.com/kubernetes-incubator/service-catalog/cmd/svcat/output"
 	"github.com/kubernetes-incubator/service-catalog/pkg/svcat/service-catalog"
 	"github.com/spf13/cobra"
 )
 
-type getCmd struct {
+// GetCmd contains the information needed to get a broker or list of brokers
+type GetCmd struct {
 	*command.Namespaced
 	*command.Formatted
 	*command.Scoped
-	name string
+
+	Name string
 }
 
 // NewGetCmd builds a "svcat get brokers" command
 func NewGetCmd(cxt *command.Context) *cobra.Command {
-	getCmd := &getCmd{
+	getCmd := &GetCmd{
 		Namespaced: command.NewNamespaced(cxt),
 		Formatted:  command.NewFormatted(),
 		Scoped:     command.NewScoped(),
@@ -56,23 +61,26 @@ func NewGetCmd(cxt *command.Context) *cobra.Command {
 	return cmd
 }
 
-func (c *getCmd) Validate(args []string) error {
+// Validate checks that the required arguments have been provided
+func (c *GetCmd) Validate(args []string) error {
 	if len(args) > 0 {
-		c.name = args[0]
+		c.Name = args[0]
 	}
 
 	return nil
 }
 
-func (c *getCmd) Run() error {
-	if c.name == "" {
+// Run determines if we're getting all brokers or a single broker,
+// then queries the backend to get that information
+func (c *GetCmd) Run() error {
+	if c.Name == "" {
 		return c.getAll()
 	}
 
 	return c.get()
 }
 
-func (c *getCmd) getAll() error {
+func (c *GetCmd) getAll() error {
 	opts := servicecatalog.ScopeOptions{
 		Namespace: c.Namespace,
 		Scope:     c.Scope,
@@ -86,12 +94,18 @@ func (c *getCmd) getAll() error {
 	return nil
 }
 
-func (c *getCmd) get() error {
-	broker, err := c.App.RetrieveBroker(c.name)
+func (c *GetCmd) get() error {
+	scopeOpts := servicecatalog.ScopeOptions{
+		Scope:     c.Scope,
+		Namespace: c.Namespace,
+	}
+	broker, err := c.App.RetrieveBrokerByID(c.Name, scopeOpts)
 	if err != nil {
+		if strings.Contains(err.Error(), servicecatalog.MultipleBrokersFoundError) {
+			return fmt.Errorf(err.Error() + ", please specify a scope with --scope")
+		}
 		return err
 	}
-
-	output.WriteBroker(c.Output, c.OutputFormat, *broker)
+	output.WriteBroker(c.Output, c.OutputFormat, broker)
 	return nil
 }
diff --git a/cmd/svcat/broker/get_cmd_test.go b/cmd/svcat/broker/get_cmd_test.go
index ce9954697bd..a6caaaf8335 100644
--- a/cmd/svcat/broker/get_cmd_test.go
+++ b/cmd/svcat/broker/get_cmd_test.go
@@ -14,11 +14,13 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package broker
+package broker_test
 
 import (
 	"bytes"
+	"fmt"
 
+	. "github.com/kubernetes-incubator/service-catalog/cmd/svcat/broker"
 	"github.com/kubernetes-incubator/service-catalog/cmd/svcat/command"
 	"github.com/kubernetes-incubator/service-catalog/cmd/svcat/test"
 	"github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1"
@@ -47,15 +49,15 @@ var _ = Describe("Get Broker Command", func() {
 	})
 	Describe("Validate", func() {
 		It("allows broker name arg to be empty", func() {
-			cmd := &getCmd{}
+			cmd := &GetCmd{}
 			err := cmd.Validate([]string{})
 			Expect(err).To(BeNil())
 		})
 		It("optionally parses the broker name argument", func() {
-			cmd := &getCmd{}
+			cmd := &GetCmd{}
 			err := cmd.Validate([]string{"minibroker"})
 			Expect(err).To(BeNil())
-			Expect(cmd.name).To(Equal("minibroker"))
+			Expect(cmd.Name).To(Equal("minibroker"))
 		})
 	})
 	Describe("Run", func() {
@@ -68,7 +70,7 @@ var _ = Describe("Get Broker Command", func() {
 				[]servicecatalog.Broker{&v1beta1.ServiceBroker{ObjectMeta: v1.ObjectMeta{Name: "minibroker", Namespace: "default"}}},
 				nil)
 			fakeApp.SvcatClient = fakeSDK
-			cmd := getCmd{
+			cmd := GetCmd{
 				Namespaced: &command.Namespaced{Context: svcattest.NewContext(outputBuffer, fakeApp)},
 				Scoped:     command.NewScoped(),
 				Formatted:  command.NewFormatted(),
@@ -100,7 +102,7 @@ var _ = Describe("Get Broker Command", func() {
 				},
 				nil)
 			fakeApp.SvcatClient = fakeSDK
-			cmd := getCmd{
+			cmd := GetCmd{
 				Namespaced: &command.Namespaced{Context: svcattest.NewContext(outputBuffer, fakeApp)},
 				Scoped:     command.NewScoped(),
 				Formatted:  command.NewFormatted(),
@@ -133,7 +135,7 @@ var _ = Describe("Get Broker Command", func() {
 				},
 				nil)
 			fakeApp.SvcatClient = fakeSDK
-			cmd := getCmd{
+			cmd := GetCmd{
 				Namespaced: &command.Namespaced{Context: svcattest.NewContext(outputBuffer, fakeApp)},
 				Scoped:     command.NewScoped(),
 				Formatted:  command.NewFormatted(),
@@ -154,5 +156,91 @@ var _ = Describe("Get Broker Command", func() {
 			Expect(output).To(ContainSubstring("global-broker"))
 			Expect(output).To(ContainSubstring("minibroker"))
 		})
+		Context("getting a single broker", func() {
+			var (
+				brokerName string
+				brokerURL  string
+				csb        *v1beta1.ClusterServiceBroker
+				namespace  string
+			)
+			BeforeEach(func() {
+				brokerName = "global-broker"
+				brokerURL = "www.foobar.com"
+				namespace = "default"
+				csb = &v1beta1.ClusterServiceBroker{
+					ObjectMeta: v1.ObjectMeta{
+						Name: brokerName,
+					},
+					Spec: v1beta1.ClusterServiceBrokerSpec{
+						CommonServiceBrokerSpec: v1beta1.CommonServiceBrokerSpec{
+							URL:                 brokerURL,
+							CatalogRestrictions: &v1beta1.CatalogRestrictions{},
+						},
+					},
+				}
+			})
+			It("Calls the pkg/svcat libs RetrieveBrokerByID when getting a single broker", func() {
+				outputBuffer := &bytes.Buffer{}
+
+				fakeApp, _ := svcat.NewApp(nil, nil, "default")
+				fakeSDK := new(servicecatalogfakes.FakeSvcatClient)
+				fakeSDK.RetrieveBrokerByIDReturns(csb, nil)
+				fakeApp.SvcatClient = fakeSDK
+				cmd := GetCmd{
+					Namespaced: &command.Namespaced{Context: svcattest.NewContext(outputBuffer, fakeApp)},
+					Scoped:     command.NewScoped(),
+					Formatted:  command.NewFormatted(),
+				}
+				cmd.Namespace = "default"
+				cmd.Scope = servicecatalog.AllScope
+				cmd.Name = brokerName
+				err := cmd.Run()
+
+				Expect(err).NotTo(HaveOccurred())
+				Expect(fakeSDK.RetrieveBrokerByIDCallCount()).To(Equal(1))
+				returnedName, returnedScopeOpts := fakeSDK.RetrieveBrokerByIDArgsForCall(0)
+				Expect(returnedName).To(Equal(brokerName))
+				scopeOpts := servicecatalog.ScopeOptions{
+					Scope:     servicecatalog.AllScope,
+					Namespace: namespace,
+				}
+				Expect(returnedScopeOpts).To(Equal(scopeOpts))
+
+				output := outputBuffer.String()
+				Expect(output).To(ContainSubstring(brokerName))
+				Expect(output).To(ContainSubstring(brokerURL))
+			})
+			It("prompts the user for more input when it finds multiple brokers", func() {
+				outputBuffer := &bytes.Buffer{}
+
+				fakeApp, _ := svcat.NewApp(nil, nil, "default")
+				fakeSDK := new(servicecatalogfakes.FakeSvcatClient)
+				fakeSDK.RetrieveBrokerByIDReturns(nil, fmt.Errorf(servicecatalog.MultipleBrokersFoundError+" for broker '"+brokerName+"'"))
+				fakeApp.SvcatClient = fakeSDK
+				cmd := GetCmd{
+					Namespaced: &command.Namespaced{Context: svcattest.NewContext(outputBuffer, fakeApp)},
+					Scoped:     command.NewScoped(),
+					Formatted:  command.NewFormatted(),
+				}
+				cmd.Namespace = "default"
+				cmd.Scope = servicecatalog.AllScope
+				cmd.Name = brokerName
+				err := cmd.Run()
+
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring(servicecatalog.MultipleBrokersFoundError))
+				Expect(err.Error()).To(ContainSubstring("specify a scope with --scope"))
+
+				Expect(fakeSDK.RetrieveBrokerByIDCallCount()).To(Equal(1))
+				returnedName, returnedScopeOpts := fakeSDK.RetrieveBrokerByIDArgsForCall(0)
+				Expect(returnedName).To(Equal(brokerName))
+				scopeOpts := servicecatalog.ScopeOptions{
+					Scope:     servicecatalog.AllScope,
+					Namespace: namespace,
+				}
+				Expect(returnedScopeOpts).To(Equal(scopeOpts))
+
+			})
+		})
 	})
 })
diff --git a/cmd/svcat/output/broker.go b/cmd/svcat/output/broker.go
index ee1eeb768a3..3f447378864 100644
--- a/cmd/svcat/output/broker.go
+++ b/cmd/svcat/output/broker.go
@@ -72,14 +72,14 @@ func WriteBrokerList(w io.Writer, outputFormat string, brokers ...servicecatalog
 }
 
 // WriteBroker prints a broker in the specified output format.
-func WriteBroker(w io.Writer, outputFormat string, broker v1beta1.ClusterServiceBroker) {
+func WriteBroker(w io.Writer, outputFormat string, broker servicecatalog.Broker) {
 	switch outputFormat {
 	case FormatJSON:
 		writeJSON(w, broker)
 	case FormatYAML:
 		writeYAML(w, broker, 0)
 	case FormatTable:
-		writeBrokerListTable(w, []servicecatalog.Broker{&broker})
+		writeBrokerListTable(w, []servicecatalog.Broker{broker})
 	}
 }
 
@@ -87,11 +87,21 @@ func WriteBroker(w io.Writer, outputFormat string, broker v1beta1.ClusterService
 func WriteBrokerDetails(w io.Writer, broker servicecatalog.Broker) {
 	t := NewDetailsTable(w)
 
-	t.AppendBulk([][]string{
-		{"Name:", broker.GetName()},
-		{"URL:", broker.GetURL()},
-		{"Status:", getBrokerStatusFull(broker.GetStatus())},
-	})
-
+	if broker.GetNamespace() == "" {
+		t.AppendBulk([][]string{
+			{"Name:", broker.GetName()},
+			{"Type:", "clusterservicebroker"},
+			{"URL:", broker.GetURL()},
+			{"Status:", getBrokerStatusFull(broker.GetStatus())},
+		})
+	} else {
+		t.AppendBulk([][]string{
+			{"Name:", broker.GetName()},
+			{"Type:", "servicebroker"},
+			{"Namespace:", broker.GetNamespace()},
+			{"URL:", broker.GetURL()},
+			{"Status:", getBrokerStatusFull(broker.GetStatus())},
+		})
+	}
 	t.Render()
 }
diff --git a/cmd/svcat/svcat_test.go b/cmd/svcat/svcat_test.go
index 23ac841aa18..4622875fd99 100644
--- a/cmd/svcat/svcat_test.go
+++ b/cmd/svcat/svcat_test.go
@@ -187,10 +187,10 @@ func TestCommandOutput(t *testing.T) {
 		{name: "list all brokers", cmd: "get brokers", golden: "output/get-brokers.txt"},
 		{name: "list all brokers (json)", cmd: "get brokers -o json", golden: "output/get-brokers.json"},
 		{name: "list all brokers (yaml)", cmd: "get brokers -o yaml", golden: "output/get-brokers.yaml"},
-		{name: "get broker", cmd: "get broker ups-broker", golden: "output/get-broker.txt"},
-		{name: "get broker (json)", cmd: "get broker ups-broker -o json", golden: "output/get-broker.json"},
-		{name: "get broker (yaml)", cmd: "get broker ups-broker -o yaml", golden: "output/get-broker.yaml"},
-		{name: "describe broker", cmd: "describe broker ups-broker", golden: "output/describe-broker.txt"},
+		{name: "get broker (cluster)", cmd: "get broker ups-broker --scope cluster", golden: "output/get-broker.txt"},
+		{name: "get broker (cluster)(json)", cmd: "get broker ups-broker --scope cluster -o json", golden: "output/get-broker.json"},
+		{name: "get broker (cluster)(yaml)", cmd: "get broker ups-broker --scope cluster -o yaml", golden: "output/get-broker.yaml"},
+		{name: "describe broker (cluster)", cmd: "describe broker ups-broker --scope cluster", golden: "output/describe-broker.txt"},
 		{name: "register broker", cmd: "register ups-broker --url http://upsbroker.com", golden: "output/register-broker.txt"},
 		{name: "deregister broker", cmd: "deregister ups-broker", golden: "output/deregister-broker.txt"},
 
diff --git a/cmd/svcat/testdata/output/completion-bash.txt b/cmd/svcat/testdata/output/completion-bash.txt
index 5996cfc72e9..1d9aa751db3 100644
--- a/cmd/svcat/testdata/output/completion-bash.txt
+++ b/cmd/svcat/testdata/output/completion-bash.txt
@@ -464,6 +464,11 @@ _svcat_describe_broker()
     flags_with_completion=()
     flags_completion=()
 
+    flags+=("--namespace=")
+    two_word_flags+=("-n")
+    local_nonpersistent_flags+=("--namespace=")
+    flags+=("--scope=")
+    local_nonpersistent_flags+=("--scope=")
     flags+=("--context=")
     flags+=("--kubeconfig=")
     flags+=("--logtostderr")
diff --git a/cmd/svcat/testdata/output/completion-zsh.txt b/cmd/svcat/testdata/output/completion-zsh.txt
index f62dd796da7..cd2bfd93fb4 100644
--- a/cmd/svcat/testdata/output/completion-zsh.txt
+++ b/cmd/svcat/testdata/output/completion-zsh.txt
@@ -598,6 +598,11 @@ _svcat_describe_broker()
     flags_with_completion=()
     flags_completion=()
 
+    flags+=("--namespace=")
+    two_word_flags+=("-n")
+    local_nonpersistent_flags+=("--namespace=")
+    flags+=("--scope=")
+    local_nonpersistent_flags+=("--scope=")
     flags+=("--context=")
     flags+=("--kubeconfig=")
     flags+=("--logtostderr")
diff --git a/cmd/svcat/testdata/output/describe-broker.txt b/cmd/svcat/testdata/output/describe-broker.txt
index 7be5c471a17..6c539cec223 100644
--- a/cmd/svcat/testdata/output/describe-broker.txt
+++ b/cmd/svcat/testdata/output/describe-broker.txt
@@ -1,3 +1,4 @@
   Name:     ups-broker                                                                                
+  Type:     clusterservicebroker                                                                      
   URL:      http://ups-broker-ups-broker.ups-broker.svc.cluster.local                                 
   Status:   Ready - Successfully fetched catalog entries from broker @ 2018-01-11 20:53:31 +0000 UTC  
diff --git a/cmd/svcat/testdata/output/register-broker.txt b/cmd/svcat/testdata/output/register-broker.txt
index fa914125da4..60879a8c1e1 100644
--- a/cmd/svcat/testdata/output/register-broker.txt
+++ b/cmd/svcat/testdata/output/register-broker.txt
@@ -1,3 +1,4 @@
   Name:     ups-broker            
+  Type:     clusterservicebroker  
   URL:      http://upsbroker.com  
   Status:                         
diff --git a/cmd/svcat/testdata/plugin.yaml b/cmd/svcat/testdata/plugin.yaml
index cdfca7917b5..3bbf95db33e 100644
--- a/cmd/svcat/testdata/plugin.yaml
+++ b/cmd/svcat/testdata/plugin.yaml
@@ -126,6 +126,9 @@ tree:
     use: binding NAME
   - command: ./svcat describe broker
     example: '  svcat describe broker asb'
+    flags:
+    - desc: 'Limit the command to a particular scope: cluster, namespace or all'
+      name: scope
     name: broker
     shortDesc: Show details of a specific broker
     use: broker NAME
diff --git a/pkg/svcat/service-catalog/broker.go b/pkg/svcat/service-catalog/broker.go
index 533b60e196b..4acf59183a7 100644
--- a/pkg/svcat/service-catalog/broker.go
+++ b/pkg/svcat/service-catalog/broker.go
@@ -29,6 +29,10 @@ import (
 	"k8s.io/apimachinery/pkg/util/wait"
 )
 
+// MultipleBrokersFoundError is the error returned when we find a clusterservicebroker
+// and a servicebroker with the same name
+const MultipleBrokersFoundError = "Too many brokers found"
+
 // Broker provides a unifying layer of cluster and namespace scoped broker resources.
 type Broker interface {
 
@@ -99,8 +103,7 @@ func (sdk *SDK) RetrieveBrokers(opts ScopeOptions) ([]Broker, error) {
 	return brokers, nil
 }
 
-// RetrieveBroker gets a broker by its name.
-func (sdk *SDK) RetrieveBroker(name string) (*v1beta1.ClusterServiceBroker, error) {
+func (sdk *SDK) retrieveBroker(name string) (*v1beta1.ClusterServiceBroker, error) {
 	broker, err := sdk.ServiceCatalog().ClusterServiceBrokers().Get(name, v1.GetOptions{})
 	if err != nil {
 		return nil, errors.Wrapf(err, "unable to get broker '%s'", name)
@@ -109,8 +112,49 @@ func (sdk *SDK) RetrieveBroker(name string) (*v1beta1.ClusterServiceBroker, erro
 	return broker, nil
 }
 
-// RetrieveNamespacedBroker gets a broker by its name & namespace.
-func (sdk *SDK) RetrieveNamespacedBroker(namespace string, name string) (*v1beta1.ServiceBroker, error) {
+// RetrieveBrokerByID gets a broker by its k8s name
+func (sdk *SDK) RetrieveBrokerByID(kubeName string, opts ScopeOptions) (Broker, error) {
+	var csb *v1beta1.ClusterServiceBroker
+	var sb *v1beta1.ServiceBroker
+	var err error
+	if opts.Scope.Matches(ClusterScope) {
+		csb, err = sdk.ServiceCatalog().ClusterServiceBrokers().Get(kubeName, v1.GetOptions{})
+		if apierrors.IsNotFound(err) {
+			csb = nil
+		}
+		if err != nil && !apierrors.IsNotFound(err) {
+			return nil, fmt.Errorf("unable to search clusterservicebrokers by k8s name (%s)", err)
+		}
+	}
+
+	if opts.Scope.Matches(NamespaceScope) {
+		sb, err = sdk.ServiceCatalog().ServiceBrokers(opts.Namespace).Get(kubeName, v1.GetOptions{})
+		if err != nil {
+			if apierrors.IsNotFound(err) {
+				sb = nil
+			}
+			if err != nil && !apierrors.IsNotFound(err) {
+				return nil, fmt.Errorf("unable to search servicebrokers k8s by name (%s)", err)
+			}
+		}
+	}
+
+	switch {
+	case csb != nil && sb != nil:
+		return nil, fmt.Errorf(MultipleBrokersFoundError+" for '%s'", kubeName)
+	case csb == nil && sb == nil:
+		return nil, fmt.Errorf("no matching broker found for k8s name '%s'", kubeName)
+	case csb != nil && sb == nil:
+		return csb, nil
+	case csb == nil && sb != nil:
+		return sb, nil
+	default:
+		return nil, fmt.Errorf("this error shouldn't be happening")
+	}
+}
+
+// retrieveNamespacedBroker gets a broker by its name & namespace.
+func (sdk *SDK) retrieveNamespacedBroker(namespace string, name string) (*v1beta1.ServiceBroker, error) {
 	broker, err := sdk.ServiceCatalog().ServiceBrokers(namespace).Get(name, v1.GetOptions{})
 	if err != nil {
 		return nil, fmt.Errorf("unable to get broker '%s' (%s)", name, err)
@@ -222,11 +266,9 @@ func (sdk *SDK) Sync(name string, scopeOpts ScopeOptions, retries int) error {
 	var err error
 
 	for j := 0; j < retries && !success; j++ {
-
 		if scopeOpts.Scope.Matches(NamespaceScope) {
-			var broker *v1beta1.ServiceBroker
 			namespace := scopeOpts.Namespace
-			broker, err = sdk.RetrieveNamespacedBroker(namespace, name)
+			broker, err := sdk.retrieveNamespacedBroker(namespace, name)
 			if err == nil {
 				broker.Spec.RelistRequests = broker.Spec.RelistRequests + 1
 
@@ -242,7 +284,7 @@ func (sdk *SDK) Sync(name string, scopeOpts ScopeOptions, retries int) error {
 
 		if scopeOpts.Scope.Matches(ClusterScope) {
 			var broker *v1beta1.ClusterServiceBroker
-			broker, err = sdk.RetrieveBroker(name)
+			broker, err = sdk.retrieveBroker(name)
 			if err == nil {
 				broker.Spec.RelistRequests = broker.Spec.RelistRequests + 1
 
@@ -276,7 +318,7 @@ func (sdk *SDK) WaitForBroker(name string, interval time.Duration, timeout *time
 	}
 	err = wait.PollImmediate(interval, *timeout,
 		func() (bool, error) {
-			broker, err = sdk.RetrieveBroker(name)
+			broker, err = sdk.retrieveBroker(name)
 			if err != nil {
 				if apierrors.IsNotFound(errors.Cause(err)) {
 					err = nil
diff --git a/pkg/svcat/service-catalog/broker_test.go b/pkg/svcat/service-catalog/broker_test.go
index c2a3107955a..3a9ac2a51ea 100644
--- a/pkg/svcat/service-catalog/broker_test.go
+++ b/pkg/svcat/service-catalog/broker_test.go
@@ -21,8 +21,10 @@ import (
 	"fmt"
 	"time"
 
+	apisservicecatalog "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog"
 	"github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1"
 	"github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/fake"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/testing"
@@ -220,27 +222,164 @@ var _ = Describe("Broker", func() {
 			Expect(actions[1].Matches("list", "servicebrokers")).To(BeTrue())
 		})
 	})
-	Describe("RetrieveBroker", func() {
-		It("Calls the generated v1beta1 List method with the passed in broker", func() {
-			broker, err := sdk.RetrieveBroker(csb.Name)
+	Describe("RetrieveBrokerByID", func() {
+		It("Calls the generated v1beta1 Get methods with the passed in broker name", func() {
+			brokerName := csb.Name
+			realClient := &fake.Clientset{}
+			realClient.AddReactor("get", "clusterservicebrokers", func(action testing.Action) (bool, runtime.Object, error) {
+				return true, csb, nil
+			})
+			realClient.AddReactor("get", "servicebrokers", func(action testing.Action) (bool, runtime.Object, error) {
+				return true, nil, nil
+			})
+			sdk = &SDK{
+				ServiceCatalogClient: realClient,
+			}
 
+			broker, err := sdk.RetrieveBrokerByID(brokerName, ScopeOptions{Scope: AllScope})
 			Expect(err).NotTo(HaveOccurred())
-			Expect(broker).To(Equal(csb))
-			actions := svcCatClient.Actions()
+			Expect(broker.GetName()).To(Equal(brokerName))
+
+			actions := realClient.Actions()
+			Expect(len(actions)).To(Equal(2))
 			Expect(actions[0].Matches("get", "clusterservicebrokers")).To(BeTrue())
-			Expect(actions[0].(testing.GetActionImpl).Name).To(Equal(csb.Name))
+			Expect(actions[0].(testing.GetActionImpl).Name).To(Equal(brokerName))
+			Expect(actions[1].Matches("get", "servicebrokers")).To(BeTrue())
+			Expect(actions[1].(testing.GetActionImpl).Name).To(Equal(brokerName))
+		})
+		It("Calls only the generated v1beta1 Get method for clusterservicebrokers when called with cluster scope", func() {
+			brokerName := csb.Name
+			realClient := &fake.Clientset{}
+			realClient.AddReactor("get", "clusterservicebrokers", func(action testing.Action) (bool, runtime.Object, error) {
+				return true, csb, nil
+			})
+			sdk = &SDK{
+				ServiceCatalogClient: realClient,
+			}
+
+			broker, err := sdk.RetrieveBrokerByID(brokerName, ScopeOptions{Scope: ClusterScope})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(broker.GetName()).To(Equal(brokerName))
+
+			actions := realClient.Actions()
+			Expect(len(actions)).To(Equal(1))
+			Expect(actions[0].Matches("get", "clusterservicebrokers")).To(BeTrue())
+			Expect(actions[0].(testing.GetActionImpl).Name).To(Equal(brokerName))
+		})
+		It("Calls only the generated v1beta1 Get method for servicebrokers when called with namespace scope", func() {
+			brokerName := sb.Name
+			realClient := &fake.Clientset{}
+			realClient.AddReactor("get", "servicebrokers", func(action testing.Action) (bool, runtime.Object, error) {
+				return true, sb, nil
+			})
+			sdk = &SDK{
+				ServiceCatalogClient: realClient,
+			}
+
+			broker, err := sdk.RetrieveBrokerByID(brokerName, ScopeOptions{Scope: NamespaceScope})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(broker.GetName()).To(Equal(brokerName))
+
+			actions := realClient.Actions()
+			Expect(len(actions)).To(Equal(1))
+			Expect(actions[0].Matches("get", "servicebrokers")).To(BeTrue())
+			Expect(actions[0].(testing.GetActionImpl).Name).To(Equal(brokerName))
 		})
 		It("Bubbles up errors", func() {
-			brokerName := "banana"
+			brokerName := csb.Name
+			errorMsg := "banana error"
+			realClient := &fake.Clientset{}
+			realClient.AddReactor("get", "clusterservicebrokers", func(action testing.Action) (bool, runtime.Object, error) {
+				return true, nil, fmt.Errorf(errorMsg)
+			})
+			sdk = &SDK{
+				ServiceCatalogClient: realClient,
+			}
+
+			broker, err := sdk.RetrieveBrokerByID(brokerName, ScopeOptions{Scope: AllScope})
+			Expect(broker).To(BeNil())
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).Should(ContainSubstring(errorMsg))
 
-			broker, err := sdk.RetrieveBroker(brokerName)
+			actions := realClient.Actions()
+			Expect(len(actions)).To(Equal(1))
+			Expect(actions[0].Matches("get", "clusterservicebrokers")).To(BeTrue())
+			Expect(actions[0].(testing.GetActionImpl).Name).To(Equal(brokerName))
+		})
+		It("doesn't short-circuit on not found errors", func() {
+			brokerName := "not-a-real-broker"
+			realClient := &fake.Clientset{}
+			realClient.AddReactor("get", "clusterservicebrokers", func(action testing.Action) (bool, runtime.Object, error) {
+				return true, nil, apierrors.NewNotFound(v1beta1.Resource("clusterservicebroker"), brokerName)
+			})
+			realClient.AddReactor("get", "servicebrokers", func(action testing.Action) (bool, runtime.Object, error) {
+				return true, nil, apierrors.NewNotFound(v1beta1.Resource("servicebroker"), brokerName)
+			})
+			sdk = &SDK{
+				ServiceCatalogClient: realClient,
+			}
 
+			broker, err := sdk.RetrieveBrokerByID(brokerName, ScopeOptions{Scope: AllScope})
 			Expect(broker).To(BeNil())
 			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).Should(ContainSubstring("not found"))
-			actions := svcCatClient.Actions()
+			Expect(err.Error()).Should(ContainSubstring("no matching broker"))
+
+			actions := realClient.Actions()
+			Expect(len(actions)).To(Equal(2))
+			Expect(actions[0].Matches("get", "clusterservicebrokers")).To(BeTrue())
+			Expect(actions[0].(testing.GetActionImpl).Name).To(Equal(brokerName))
+			Expect(actions[1].Matches("get", "servicebrokers")).To(BeTrue())
+			Expect(actions[1].(testing.GetActionImpl).Name).To(Equal(brokerName))
+		})
+		It("Errors when it finds both a clusteservicebroker and a servicebroker", func() {
+			brokerName := csb.Name
+			realClient := &fake.Clientset{}
+			realClient.AddReactor("get", "clusterservicebrokers", func(action testing.Action) (bool, runtime.Object, error) {
+				return true, csb, nil
+			})
+			realClient.AddReactor("get", "servicebrokers", func(action testing.Action) (bool, runtime.Object, error) {
+				return true, sb, nil
+			})
+			sdk = &SDK{
+				ServiceCatalogClient: realClient,
+			}
+
+			broker, err := sdk.RetrieveBrokerByID(brokerName, ScopeOptions{Scope: AllScope})
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring(MultipleBrokersFoundError))
+			Expect(broker).To(BeNil())
+
+			actions := realClient.Actions()
+			Expect(len(actions)).To(Equal(2))
+			Expect(actions[0].Matches("get", "clusterservicebrokers")).To(BeTrue())
+			Expect(actions[0].(testing.GetActionImpl).Name).To(Equal(brokerName))
+			Expect(actions[1].Matches("get", "servicebrokers")).To(BeTrue())
+			Expect(actions[1].(testing.GetActionImpl).Name).To(Equal(brokerName))
+		})
+		It("Errors when it finds no brokers", func() {
+			brokerName := csb.Name
+			realClient := &fake.Clientset{}
+			realClient.AddReactor("get", "clusterservicebrokers", func(action testing.Action) (bool, runtime.Object, error) {
+				return true, &v1beta1.ClusterServiceBroker{}, apierrors.NewNotFound(apisservicecatalog.Resource("clusterservicebroker"), brokerName)
+			})
+			realClient.AddReactor("get", "servicebrokers", func(action testing.Action) (bool, runtime.Object, error) {
+				return true, &v1beta1.ServiceBroker{}, apierrors.NewNotFound(apisservicecatalog.Resource("servicebroker"), brokerName)
+			})
+			sdk = &SDK{
+				ServiceCatalogClient: realClient,
+			}
+
+			broker, err := sdk.RetrieveBrokerByID(brokerName, ScopeOptions{Scope: AllScope})
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("no matching broker"))
+			Expect(broker).To(BeNil())
+
+			actions := realClient.Actions()
+			Expect(len(actions)).To(Equal(2))
 			Expect(actions[0].Matches("get", "clusterservicebrokers")).To(BeTrue())
 			Expect(actions[0].(testing.GetActionImpl).Name).To(Equal(brokerName))
+			Expect(actions[1].Matches("get", "servicebrokers")).To(BeTrue())
+			Expect(actions[1].(testing.GetActionImpl).Name).To(Equal(brokerName))
 		})
 	})
 	Describe("RetrieveBrokerByClass", func() {
diff --git a/pkg/svcat/service-catalog/sdk.go b/pkg/svcat/service-catalog/sdk.go
index d7e825049c7..b3b47c2350f 100644
--- a/pkg/svcat/service-catalog/sdk.go
+++ b/pkg/svcat/service-catalog/sdk.go
@@ -46,7 +46,7 @@ type SvcatClient interface {
 
 	Deregister(string, *ScopeOptions) error
 	RetrieveBrokers(opts ScopeOptions) ([]Broker, error)
-	RetrieveBroker(string) (*apiv1beta1.ClusterServiceBroker, error)
+	RetrieveBrokerByID(string, ScopeOptions) (Broker, error)
 	RetrieveBrokerByClass(*apiv1beta1.ClusterServiceClass) (*apiv1beta1.ClusterServiceBroker, error)
 	Register(string, string, *RegisterOptions, *ScopeOptions) (Broker, error)
 	Sync(string, ScopeOptions, int) error
diff --git a/pkg/svcat/service-catalog/service-catalogfakes/fake_svcat_client.go b/pkg/svcat/service-catalog/service-catalogfakes/fake_svcat_client.go
index 8dcc5652609..637d85104a6 100644
--- a/pkg/svcat/service-catalog/service-catalogfakes/fake_svcat_client.go
+++ b/pkg/svcat/service-catalog/service-catalogfakes/fake_svcat_client.go
@@ -1,5 +1,5 @@
 /*
-Copyright 2018 The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -209,17 +209,18 @@ type FakeSvcatClient struct {
 		result1 []servicecatalog.Broker
 		result2 error
 	}
-	RetrieveBrokerStub        func(string) (*apiv1beta1.ClusterServiceBroker, error)
-	retrieveBrokerMutex       sync.RWMutex
-	retrieveBrokerArgsForCall []struct {
+	RetrieveBrokerByIDStub        func(string, servicecatalog.ScopeOptions) (servicecatalog.Broker, error)
+	retrieveBrokerByIDMutex       sync.RWMutex
+	retrieveBrokerByIDArgsForCall []struct {
 		arg1 string
+		arg2 servicecatalog.ScopeOptions
 	}
-	retrieveBrokerReturns struct {
-		result1 *apiv1beta1.ClusterServiceBroker
+	retrieveBrokerByIDReturns struct {
+		result1 servicecatalog.Broker
 		result2 error
 	}
-	retrieveBrokerReturnsOnCall map[int]struct {
-		result1 *apiv1beta1.ClusterServiceBroker
+	retrieveBrokerByIDReturnsOnCall map[int]struct {
+		result1 servicecatalog.Broker
 		result2 error
 	}
 	RetrieveBrokerByClassStub        func(*apiv1beta1.ClusterServiceClass) (*apiv1beta1.ClusterServiceBroker, error)
@@ -1305,53 +1306,54 @@ func (fake *FakeSvcatClient) RetrieveBrokersReturnsOnCall(i int, result1 []servi
 	}{result1, result2}
 }
 
-func (fake *FakeSvcatClient) RetrieveBroker(arg1 string) (*apiv1beta1.ClusterServiceBroker, error) {
-	fake.retrieveBrokerMutex.Lock()
-	ret, specificReturn := fake.retrieveBrokerReturnsOnCall[len(fake.retrieveBrokerArgsForCall)]
-	fake.retrieveBrokerArgsForCall = append(fake.retrieveBrokerArgsForCall, struct {
+func (fake *FakeSvcatClient) RetrieveBrokerByID(arg1 string, arg2 servicecatalog.ScopeOptions) (servicecatalog.Broker, error) {
+	fake.retrieveBrokerByIDMutex.Lock()
+	ret, specificReturn := fake.retrieveBrokerByIDReturnsOnCall[len(fake.retrieveBrokerByIDArgsForCall)]
+	fake.retrieveBrokerByIDArgsForCall = append(fake.retrieveBrokerByIDArgsForCall, struct {
 		arg1 string
-	}{arg1})
-	fake.recordInvocation("RetrieveBroker", []interface{}{arg1})
-	fake.retrieveBrokerMutex.Unlock()
-	if fake.RetrieveBrokerStub != nil {
-		return fake.RetrieveBrokerStub(arg1)
+		arg2 servicecatalog.ScopeOptions
+	}{arg1, arg2})
+	fake.recordInvocation("RetrieveBrokerByID", []interface{}{arg1, arg2})
+	fake.retrieveBrokerByIDMutex.Unlock()
+	if fake.RetrieveBrokerByIDStub != nil {
+		return fake.RetrieveBrokerByIDStub(arg1, arg2)
 	}
 	if specificReturn {
 		return ret.result1, ret.result2
 	}
-	return fake.retrieveBrokerReturns.result1, fake.retrieveBrokerReturns.result2
+	return fake.retrieveBrokerByIDReturns.result1, fake.retrieveBrokerByIDReturns.result2
 }
 
-func (fake *FakeSvcatClient) RetrieveBrokerCallCount() int {
-	fake.retrieveBrokerMutex.RLock()
-	defer fake.retrieveBrokerMutex.RUnlock()
-	return len(fake.retrieveBrokerArgsForCall)
+func (fake *FakeSvcatClient) RetrieveBrokerByIDCallCount() int {
+	fake.retrieveBrokerByIDMutex.RLock()
+	defer fake.retrieveBrokerByIDMutex.RUnlock()
+	return len(fake.retrieveBrokerByIDArgsForCall)
 }
 
-func (fake *FakeSvcatClient) RetrieveBrokerArgsForCall(i int) string {
-	fake.retrieveBrokerMutex.RLock()
-	defer fake.retrieveBrokerMutex.RUnlock()
-	return fake.retrieveBrokerArgsForCall[i].arg1
+func (fake *FakeSvcatClient) RetrieveBrokerByIDArgsForCall(i int) (string, servicecatalog.ScopeOptions) {
+	fake.retrieveBrokerByIDMutex.RLock()
+	defer fake.retrieveBrokerByIDMutex.RUnlock()
+	return fake.retrieveBrokerByIDArgsForCall[i].arg1, fake.retrieveBrokerByIDArgsForCall[i].arg2
 }
 
-func (fake *FakeSvcatClient) RetrieveBrokerReturns(result1 *apiv1beta1.ClusterServiceBroker, result2 error) {
-	fake.RetrieveBrokerStub = nil
-	fake.retrieveBrokerReturns = struct {
-		result1 *apiv1beta1.ClusterServiceBroker
+func (fake *FakeSvcatClient) RetrieveBrokerByIDReturns(result1 servicecatalog.Broker, result2 error) {
+	fake.RetrieveBrokerByIDStub = nil
+	fake.retrieveBrokerByIDReturns = struct {
+		result1 servicecatalog.Broker
 		result2 error
 	}{result1, result2}
 }
 
-func (fake *FakeSvcatClient) RetrieveBrokerReturnsOnCall(i int, result1 *apiv1beta1.ClusterServiceBroker, result2 error) {
-	fake.RetrieveBrokerStub = nil
-	if fake.retrieveBrokerReturnsOnCall == nil {
-		fake.retrieveBrokerReturnsOnCall = make(map[int]struct {
-			result1 *apiv1beta1.ClusterServiceBroker
+func (fake *FakeSvcatClient) RetrieveBrokerByIDReturnsOnCall(i int, result1 servicecatalog.Broker, result2 error) {
+	fake.RetrieveBrokerByIDStub = nil
+	if fake.retrieveBrokerByIDReturnsOnCall == nil {
+		fake.retrieveBrokerByIDReturnsOnCall = make(map[int]struct {
+			result1 servicecatalog.Broker
 			result2 error
 		})
 	}
-	fake.retrieveBrokerReturnsOnCall[i] = struct {
-		result1 *apiv1beta1.ClusterServiceBroker
+	fake.retrieveBrokerByIDReturnsOnCall[i] = struct {
+		result1 servicecatalog.Broker
 		result2 error
 	}{result1, result2}
 }
@@ -2880,8 +2882,8 @@ func (fake *FakeSvcatClient) Invocations() map[string][][]interface{} {
 	defer fake.deregisterMutex.RUnlock()
 	fake.retrieveBrokersMutex.RLock()
 	defer fake.retrieveBrokersMutex.RUnlock()
-	fake.retrieveBrokerMutex.RLock()
-	defer fake.retrieveBrokerMutex.RUnlock()
+	fake.retrieveBrokerByIDMutex.RLock()
+	defer fake.retrieveBrokerByIDMutex.RUnlock()
 	fake.retrieveBrokerByClassMutex.RLock()
 	defer fake.retrieveBrokerByClassMutex.RUnlock()
 	fake.registerMutex.RLock()