diff --git a/helper_test.go b/helper_test.go
index 6dbdf9f95..aad4be294 100644
--- a/helper_test.go
+++ b/helper_test.go
@@ -773,7 +773,7 @@ func createPrivateRegistryProvider(t *testing.T, client *Client, org *Organizati
 	prv.Organization = org
 
 	return prv, func() {
-		id := RegistryProviderID {
+		id := RegistryProviderID{
 			OrganizationName: org.Name,
 			RegistryName:     prv.RegistryName,
 			Namespace:        prv.Namespace,
@@ -816,7 +816,7 @@ func createPublicRegistryProvider(t *testing.T, client *Client, org *Organizatio
 	prv.Organization = org
 
 	return prv, func() {
-		id := RegistryProviderID {
+		id := RegistryProviderID{
 			OrganizationName: org.Name,
 			RegistryName:     prv.RegistryName,
 			Namespace:        prv.Namespace,
@@ -843,7 +843,7 @@ func createRegistryProviderPlatform(t *testing.T, client *Client, provider *Regi
 		provider, providerCleanup = createPrivateRegistryProvider(t, client, nil)
 	}
 
-	providerID := RegistryProviderID {
+	providerID := RegistryProviderID{
 		OrganizationName: provider.Organization.Name,
 		RegistryName:     provider.RegistryName,
 		Namespace:        provider.Namespace,
@@ -854,18 +854,18 @@ func createRegistryProviderPlatform(t *testing.T, client *Client, provider *Regi
 		version, versionCleanup = createRegistryProviderVersion(t, client, provider)
 	}
 
-	versionID := RegistryProviderVersionID {
+	versionID := RegistryProviderVersionID{
 		RegistryProviderID: providerID,
-		Version: version.ID,
+		Version:            version.Version,
 	}
 
 	ctx := context.Background()
 
 	options := RegistryProviderPlatformCreateOptions{
-		OS: "fooos",
-		Arch: "arch",
-		Shasum: "shasum",
-		Filename: "filename",
+		OS:       randomString(t),
+		Arch:     randomString(t),
+		Shasum:   genSha(t, "secret", "data"),
+		Filename: randomString(t),
 	}
 
 	rpp, err := client.RegistryProviderPlatforms.Create(ctx, versionID, options)
@@ -874,13 +874,14 @@ func createRegistryProviderPlatform(t *testing.T, client *Client, provider *Regi
 		t.Fatal(err)
 	}
 
-//	rpp.RegistryProviderVersion = version
+	// TODO - do I need this?
+	//	rpp.RegistryProviderVersion = version
 
 	return rpp, func() {
-		platformID := RegistryProviderPlatformID {
+		platformID := RegistryProviderPlatformID{
 			RegistryProviderVersionID: versionID,
-			OS: rpp.OS,
-			Arch: rpp.Arch,
+			OS:                        rpp.OS,
+			Arch:                      rpp.Arch,
 		}
 
 		if err := client.RegistryProviderPlatforms.Delete(ctx, platformID); err != nil {
@@ -905,7 +906,7 @@ func createRegistryProviderVersion(t *testing.T, client *Client, provider *Regis
 		provider, providerCleanup = createPrivateRegistryProvider(t, client, nil)
 	}
 
-	providerID := RegistryProviderID {
+	providerID := RegistryProviderID{
 		OrganizationName: provider.Organization.Name,
 		RegistryName:     provider.RegistryName,
 		Namespace:        provider.Namespace,
@@ -915,8 +916,9 @@ func createRegistryProviderVersion(t *testing.T, client *Client, provider *Regis
 	ctx := context.Background()
 
 	options := RegistryProviderVersionCreateOptions{
-		Version: randomSemver(t),
-		KeyID:   randomString(t),
+		Version:   randomSemver(t),
+		KeyID:     randomString(t),
+		Protocols: []string{"4.0", "5.0", "6.0"},
 	}
 
 	prvv, err := client.RegistryProviderVersions.Create(ctx, providerID, options)
@@ -928,7 +930,7 @@ func createRegistryProviderVersion(t *testing.T, client *Client, provider *Regis
 	prvv.RegistryProvider = provider
 
 	return prvv, func() {
-		id := RegistryProviderVersionID {
+		id := RegistryProviderVersionID{
 			Version:            options.Version,
 			RegistryProviderID: providerID,
 		}
diff --git a/registry_provider_platform.go b/registry_provider_platform.go
index a270bd0d4..23918c586 100644
--- a/registry_provider_platform.go
+++ b/registry_provider_platform.go
@@ -112,8 +112,10 @@ func (r *registryProviderPlatforms) List(ctx context.Context, versionID Registry
 	if err := versionID.valid(); err != nil {
 		return nil, err
 	}
-	if err := options.valid(); err != nil {
-		return nil, err
+	if options != nil {
+		if err := options.valid(); err != nil {
+			return nil, err
+		}
 	}
 
 	// GET /organizations/:organization_name/registry-providers/:registry_name/:namespace/:name/versions/:version/platforms
diff --git a/registry_provider_platform_integration_test.go b/registry_provider_platform_integration_test.go
index 9d8914fe4..15fa1e12f 100644
--- a/registry_provider_platform_integration_test.go
+++ b/registry_provider_platform_integration_test.go
@@ -49,7 +49,7 @@ func TestRegistryProviderPlatformsCreate(t *testing.T) {
 		assert.Equal(t, options.Filename, rpp.Filename)
 
 		t.Run("relationships are properly decoded", func(t *testing.T) {
-			assert.Equal(t, provider.ID, rpp.RegistryProviderVersion.ID)
+			assert.Equal(t, version.ID, rpp.RegistryProviderVersion.ID)
 		})
 
 		t.Run("attributes are properly decoded", func(t *testing.T) {
@@ -175,21 +175,21 @@ func TestRegistryProviderPlatformsDelete(t *testing.T) {
 	version, versionCleanup := createRegistryProviderVersion(t, client, provider)
 	defer versionCleanup()
 
-	providerID := RegistryProviderID{
-		OrganizationName: provider.Organization.Name,
-		RegistryName:     provider.RegistryName,
-		Namespace:        provider.Namespace,
-		Name:             provider.Name,
+	versionID := RegistryProviderVersionID{
+		RegistryProviderID: RegistryProviderID{
+			OrganizationName: provider.Organization.Name,
+			RegistryName:     provider.RegistryName,
+			Namespace:        provider.Namespace,
+			Name:             provider.Name,
+		},
+		Version: version.Version,
 	}
 
 	t.Run("with a valid version", func(t *testing.T) {
 		platform, _ := createRegistryProviderPlatform(t, client, provider, version)
 
 		platformID := RegistryProviderPlatformID{
-			RegistryProviderVersionID: RegistryProviderVersionID{
-				RegistryProviderID: providerID,
-				Version:            version.Version,
-			},
+			RegistryProviderVersionID: versionID,
 			OS:   platform.OS,
 			Arch: platform.Arch,
 		}
@@ -200,10 +200,7 @@ func TestRegistryProviderPlatformsDelete(t *testing.T) {
 
 	t.Run("with a non-existant version", func(t *testing.T) {
 		platformID := RegistryProviderPlatformID{
-			RegistryProviderVersionID: RegistryProviderVersionID{
-				RegistryProviderID: providerID,
-				Version:            version.Version,
-			},
+			RegistryProviderVersionID: versionID,
 			OS:   "nope",
 			Arch: "no",
 		}
@@ -213,6 +210,66 @@ func TestRegistryProviderPlatformsDelete(t *testing.T) {
 	})
 }
 
+func TestRegistryProviderPlatformsRead(t *testing.T) {
+	client := testClient(t)
+	ctx := context.Background()
+
+	provider, providerCleanup := createPrivateRegistryProvider(t, client, nil)
+	defer providerCleanup()
+
+	version, versionCleanup := createRegistryProviderVersion(t, client, provider)
+	defer versionCleanup()
+
+	versionID := RegistryProviderVersionID{
+		RegistryProviderID: RegistryProviderID{
+			OrganizationName: provider.Organization.Name,
+			Namespace:        provider.Namespace,
+			Name:             provider.Name,
+			RegistryName:     provider.RegistryName,
+		},
+		Version: version.Version,
+	}
+
+	platform, platformCleanup := createRegistryProviderPlatform(t, client, provider, version)
+	defer platformCleanup()
+
+	t.Run("with valid platform", func(t *testing.T) {
+		platformID := RegistryProviderPlatformID{
+			RegistryProviderVersionID: versionID,
+			OS:                        platform.OS,
+			Arch:                      platform.Arch,
+		}
+
+		readPlatform, err := client.RegistryProviderPlatforms.Read(ctx, platformID)
+		assert.NoError(t, err)
+		assert.Equal(t, platformID.RegistryProviderVersionID.Version, readPlatform.RegistryProviderVersion.Version)
+		assert.Equal(t, platformID.OS, readPlatform.OS)
+		assert.Equal(t, platformID.Arch, readPlatform.Arch)
+	})
+
+	t.Run("with non-existant os", func(t *testing.T) {
+		platformID := RegistryProviderPlatformID{
+			RegistryProviderVersionID: versionID,
+			OS:                        "DoesNotExist",
+			Arch:                      platform.Arch,
+		}
+
+		_, err := client.RegistryProviderPlatforms.Read(ctx, platformID)
+		assert.Error(t, err)
+	})
+
+	t.Run("with non-existant arch", func(t *testing.T) {
+		platformID := RegistryProviderPlatformID{
+			RegistryProviderVersionID: versionID,
+			OS:                        platform.OS,
+			Arch:                      "DoesNotExist",
+		}
+
+		_, err := client.RegistryProviderPlatforms.Read(ctx, platformID)
+		assert.Error(t, err)
+	})
+}
+
 func TestRegistryProviderPlatformsList(t *testing.T) {
 	client := testClient(t)
 	ctx := context.Background()
@@ -322,62 +379,3 @@ func TestRegistryProviderPlatformsList(t *testing.T) {
 	})
 }
 
-func TestRegistryProviderPlatformsRead(t *testing.T) {
-	client := testClient(t)
-	ctx := context.Background()
-
-	provider, providerCleanup := createPrivateRegistryProvider(t, client, nil)
-	defer providerCleanup()
-
-	version, versionCleanup := createRegistryProviderVersion(t, client, provider)
-	defer versionCleanup()
-
-	versionID := RegistryProviderVersionID{
-		RegistryProviderID: RegistryProviderID{
-			OrganizationName: provider.Organization.Name,
-			Namespace:        provider.Namespace,
-			Name:             provider.Name,
-			RegistryName:     provider.RegistryName,
-		},
-		Version: version.ID,
-	}
-
-	platform, platformCleanup := createRegistryProviderPlatform(t, client, provider, version)
-	defer platformCleanup()
-
-	t.Run("with valid platform", func(t *testing.T) {
-		platformID := RegistryProviderPlatformID{
-			RegistryProviderVersionID: versionID,
-			OS:                        platform.OS,
-			Arch:                      platform.Arch,
-		}
-
-		readPlatform, err := client.RegistryProviderPlatforms.Read(ctx, platformID)
-		assert.NoError(t, err)
-		assert.Equal(t, platformID.RegistryProviderVersionID.Version, readPlatform.RegistryProviderVersion.Version)
-		assert.Equal(t, platformID.OS, readPlatform.OS)
-		assert.Equal(t, platformID.Arch, readPlatform.Arch)
-	})
-
-	t.Run("with non-existant os", func(t *testing.T) {
-		platformID := RegistryProviderPlatformID{
-			RegistryProviderVersionID: versionID,
-			OS:                        "DoesNotExist",
-			Arch:                      platform.Arch,
-		}
-
-		_, err := client.RegistryProviderPlatforms.Read(ctx, platformID)
-		assert.Error(t, err)
-	})
-
-	t.Run("with non-existant arch", func(t *testing.T) {
-		platformID := RegistryProviderPlatformID{
-			RegistryProviderVersionID: versionID,
-			OS:                        platform.OS,
-			Arch:                      "DoesNotExist",
-		}
-
-		_, err := client.RegistryProviderPlatforms.Read(ctx, platformID)
-		assert.Error(t, err)
-	})
-}