diff --git a/js/app/store/slices/contentMetadataSlice.ts b/js/app/store/slices/contentMetadataSlice.ts
index 91fbbe1f0..f0dbf54e9 100644
--- a/js/app/store/slices/contentMetadataSlice.ts
+++ b/js/app/store/slices/contentMetadataSlice.ts
@@ -14,7 +14,7 @@ export interface ContentMetadataSlice {
   // actions
   createContentMetadata: (params: {
     contentWarnings?: string[];
-    distributionPolicy?: { deleteAfter?: number };
+    distributionPolicy?: { deleteAfter?: number; allowAiTraining?: boolean };
     contentRights?: {
       creator?: string;
       copyrightNotice?: string;
@@ -27,7 +27,7 @@ export interface ContentMetadataSlice {
     rkey?: string;
     livestreamRef?: { uri: string; cid: string };
     contentWarnings?: string[];
-    distributionPolicy?: { deleteAfter?: number };
+    distributionPolicy?: { deleteAfter?: number; allowAiTraining?: boolean };
     contentRights?: {
       creator?: string;
       copyrightNotice?: string;
@@ -80,7 +80,10 @@ export const createContentMetadataSlice: StateCreator<
         ...(contentWarnings.length > 0 && {
           contentWarnings: { warnings: contentWarnings },
         }),
-        ...(distributionPolicy.deleteAfter && { distributionPolicy }),
+        ...((distributionPolicy.deleteAfter ||
+          distributionPolicy.allowAiTraining !== undefined) && {
+          distributionPolicy,
+        }),
         ...(contentRights &&
           Object.keys(contentRights).length > 0 && {
             contentRights,
@@ -142,7 +145,10 @@ export const createContentMetadataSlice: StateCreator<
         ...(contentWarnings.length > 0 && {
           contentWarnings: { warnings: contentWarnings },
         }),
-        ...(distributionPolicy.deleteAfter && { distributionPolicy }),
+        ...((distributionPolicy.deleteAfter ||
+          distributionPolicy.allowAiTraining !== undefined) && {
+          distributionPolicy,
+        }),
         ...(contentRights &&
           Object.keys(contentRights).length > 0 && {
             contentRights,
diff --git a/js/components/src/components/content-metadata/content-metadata-form.tsx b/js/components/src/components/content-metadata/content-metadata-form.tsx
index a21ec8156..f4d19a24e 100644
--- a/js/components/src/components/content-metadata/content-metadata-form.tsx
+++ b/js/components/src/components/content-metadata/content-metadata-form.tsx
@@ -198,14 +198,19 @@ export const ContentMetadataForm = forwardRef<any, ContentMetadataFormProps>(
       ({
         deleteAfter,
         allowedBroadcasters,
+        allowAiTraining,
       }: {
         deleteAfter?: string;
         allowedBroadcasters?: string;
+        allowAiTraining?: boolean;
       }) => {
         let newDistributionPolicy: place.stream.metadata.distributionPolicy.Main =
           {
             ...distributionPolicy,
           };
+        if (typeof allowAiTraining === "boolean") {
+          newDistributionPolicy.allowAiTraining = allowAiTraining;
+        }
         if (typeof deleteAfter === "string") {
           let duration = parseInt(deleteAfter, 10);
           if (isNaN(duration)) {
@@ -304,7 +309,10 @@ export const ContentMetadataForm = forwardRef<any, ContentMetadataFormProps>(
           metadata.contentRights = filteredRights;
         }
 
+        // AI training is opt-in: absent an explicit choice, save the record
+        // with training disallowed.
         metadata.distributionPolicy = {
+          allowAiTraining: false,
           ...distributionPolicy,
         };
 
@@ -336,6 +344,7 @@ export const ContentMetadataForm = forwardRef<any, ContentMetadataFormProps>(
     }, [
       contentWarnings,
       contentRights,
+      distributionPolicy,
       selectedLicense,
       customLicenseText,
       hasMetadata,
@@ -760,6 +769,24 @@ export const ContentMetadataForm = forwardRef<any, ContentMetadataFormProps>(
                   </View>
                 )}
 
+                <Tooltip
+                  content="Off by default: every segment you stream is marked as not available for generative AI training unless you turn this on."
+                  position="top"
+                >
+                  <Checkbox
+                    checked={distributionPolicy.allowAiTraining === true}
+                    onCheckedChange={(checked) =>
+                      handleDistributionPolicyChange({
+                        allowAiTraining: checked,
+                      })
+                    }
+                    label={
+                      "Allow your content to be used for generative AI training"
+                    }
+                    style={[{ fontSize: 12 }]}
+                  />
+                </Tooltip>
+
                 <Tooltip
                   content="Anyone may archive your content indefinitely."
                   position="top"
diff --git a/js/docs/src/content/docs/lex-reference/metadata/place-stream-metadata-distributionpolicy.md b/js/docs/src/content/docs/lex-reference/metadata/place-stream-metadata-distributionpolicy.md
index 753fae2fb..908471d64 100644
--- a/js/docs/src/content/docs/lex-reference/metadata/place-stream-metadata-distributionpolicy.md
+++ b/js/docs/src/content/docs/lex-reference/metadata/place-stream-metadata-distributionpolicy.md
@@ -17,10 +17,11 @@ Distribution and rebroadcast policy.
 
 **Properties:**
 
-| Name                  | Type              | Req'd | Description                                                                                                                                              | Constraints |
-| --------------------- | ----------------- | ----- | -------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
-| `deleteAfter`         | `integer`         | ❌    | Duration in seconds after which segments should be deleted. Each segment will expire N seconds after its creation time. -1 to allow indefinite archival. |             |
-| `allowedBroadcasters` | Array of `string` | ❌    | List of did:webs of the broadcasters you want to allow to distribute your content. "\*" allows anyone. Starting a line with a "!" bans that broadcaster. |             |
+| Name                  | Type              | Req'd | Description                                                                                                                                                                                         | Constraints |
+| --------------------- | ----------------- | ----- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
+| `deleteAfter`         | `integer`         | ❌    | Duration in seconds after which segments should be deleted. Each segment will expire N seconds after its creation time. -1 to allow indefinite archival.                                            |             |
+| `allowedBroadcasters` | Array of `string` | ❌    | List of did:webs of the broadcasters you want to allow to distribute your content. "\*" allows anyone. Starting a line with a "!" bans that broadcaster.                                            |             |
+| `allowAiTraining`     | `boolean`         | ❌    | Whether this content may be used as training data for generative AI models. Absent means undeclared; Streamplace treats undeclared as false and stamps an explicit value into every minted segment. |             |
 
 ---
 
@@ -45,6 +46,10 @@ Distribution and rebroadcast policy.
           "items": {
             "type": "string"
           }
+        },
+        "allowAiTraining": {
+          "type": "boolean",
+          "description": "Whether this content may be used as training data for generative AI models. Absent means undeclared; Streamplace treats undeclared as false and stamps an explicit value into every minted segment."
         }
       }
     }
diff --git a/lexicons/place/stream/metadata/distributionPolicy.json b/lexicons/place/stream/metadata/distributionPolicy.json
index e2d347aa5..eec3c1e47 100644
--- a/lexicons/place/stream/metadata/distributionPolicy.json
+++ b/lexicons/place/stream/metadata/distributionPolicy.json
@@ -16,6 +16,10 @@
           "items": {
             "type": "string"
           }
+        },
+        "allowAiTraining": {
+          "type": "boolean",
+          "description": "Whether this content may be used as training data for generative AI models. Absent means undeclared; Streamplace treats undeclared as false and stamps an explicit value into every minted segment."
         }
       }
     }
diff --git a/pkg/localdb/segment.go b/pkg/localdb/segment.go
index 29f1cf505..2e137ae55 100644
--- a/pkg/localdb/segment.go
+++ b/pkg/localdb/segment.go
@@ -86,6 +86,7 @@ func (c ContentRights) Value() (driver.Value, error) {
 // DistributionPolicy represents distribution policy information
 type DistributionPolicy struct {
 	DeleteAfterSeconds *int64 `json:"deleteAfterSeconds,omitempty"`
+	AllowAiTraining    *bool  `json:"allowAiTraining,omitempty"`
 }
 
 // Scan scan value into DistributionPolicy, implements sql.Scanner interface
@@ -184,9 +185,10 @@ func (s *Segment) ToStreamplaceSegment() (*placestream.Segment, error) {
 	}
 
 	var distributionPolicy *placestream.MetadataDistributionPolicy
-	if s.DistributionPolicy != nil && s.DistributionPolicy.DeleteAfterSeconds != nil {
+	if s.DistributionPolicy != nil && (s.DistributionPolicy.DeleteAfterSeconds != nil || s.DistributionPolicy.AllowAiTraining != nil) {
 		distributionPolicy = &placestream.MetadataDistributionPolicy{
-			DeleteAfter: s.DistributionPolicy.DeleteAfterSeconds,
+			DeleteAfter:     s.DistributionPolicy.DeleteAfterSeconds,
+			AllowAiTraining: s.DistributionPolicy.AllowAiTraining,
 		}
 	}
 
diff --git a/pkg/media/distribution_policy_test.go b/pkg/media/distribution_policy_test.go
new file mode 100644
index 000000000..f1efefc53
--- /dev/null
+++ b/pkg/media/distribution_policy_test.go
@@ -0,0 +1,77 @@
+package media
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"stream.place/streamplace/pkg/aqtime"
+	c2patypes "stream.place/streamplace/pkg/c2patypes"
+	"stream.place/streamplace/pkg/localdb"
+)
+
+func manifestWithDistributionPolicy(policy map[string]any) *c2patypes.Manifest {
+	return &c2patypes.Manifest{
+		Assertions: []c2patypes.ManifestAssertion{
+			{
+				Label: "place.stream.metadata.configuration",
+				Data: map[string]any{
+					"distributionPolicy": policy,
+				},
+			},
+		},
+	}
+}
+
+// extractDistributionPolicy carries allowAiTraining out of the manifest, alone
+// or alongside deleteAfter, and stays nil when neither is declared.
+func TestExtractDistributionPolicyAllowAiTraining(t *testing.T) {
+	now := aqtime.FromTime(time.Now())
+
+	policy := extractDistributionPolicy(manifestWithDistributionPolicy(map[string]any{
+		"allowAiTraining": false,
+	}), now)
+	require.NotNil(t, policy)
+	require.NotNil(t, policy.AllowAiTraining)
+	require.False(t, *policy.AllowAiTraining)
+	require.Nil(t, policy.DeleteAfterSeconds)
+
+	policy = extractDistributionPolicy(manifestWithDistributionPolicy(map[string]any{
+		"allowAiTraining": true,
+		"deleteAfter":     300,
+	}), now)
+	require.NotNil(t, policy)
+	require.NotNil(t, policy.AllowAiTraining)
+	require.True(t, *policy.AllowAiTraining)
+	require.NotNil(t, policy.DeleteAfterSeconds)
+	require.Equal(t, int64(300), *policy.DeleteAfterSeconds)
+
+	policy = extractDistributionPolicy(manifestWithDistributionPolicy(map[string]any{
+		"allowedBroadcasters": []string{"*"},
+	}), now)
+	require.Nil(t, policy, "a policy with neither deleteAfter nor allowAiTraining stays nil")
+}
+
+// The minted place.stream.segment record carries allowAiTraining even when
+// deleteAfter is unset.
+func TestSegmentRecordCarriesAllowAiTraining(t *testing.T) {
+	notAllowed := false
+	seg := &localdb.Segment{
+		ID:            "test-segment",
+		RepoDID:       "did:example:streamer",
+		SigningKeyDID: "did:key:test",
+		MediaData: &localdb.SegmentMediaData{
+			Video: []*localdb.SegmentMediadataVideo{{Width: 1920, Height: 1080, FPSNum: 30, FPSDen: 1}},
+			Audio: []*localdb.SegmentMediadataAudio{{Rate: 48000, Channels: 2}},
+		},
+		DistributionPolicy: &localdb.DistributionPolicy{
+			AllowAiTraining: &notAllowed,
+		},
+	}
+	record, err := seg.ToStreamplaceSegment()
+	require.NoError(t, err)
+	require.NotNil(t, record.DistributionPolicy)
+	require.NotNil(t, record.DistributionPolicy.AllowAiTraining)
+	require.False(t, *record.DistributionPolicy.AllowAiTraining)
+	require.Nil(t, record.DistributionPolicy.DeleteAfter)
+}
diff --git a/pkg/media/manifest_builder.go b/pkg/media/manifest_builder.go
index 86d737f6a..266626591 100644
--- a/pkg/media/manifest_builder.go
+++ b/pkg/media/manifest_builder.go
@@ -133,6 +133,7 @@ func (mb *ManifestBuilder) BuildManifest(ctx context.Context, streamerName strin
 	}
 
 	// Add database metadata if available
+	var streamplaceMetadata placestream.MetadataConfiguration
 	if mb.model != nil {
 		metadata, err := mb.model.GetMetadataConfiguration(ctx, streamerName)
 		if err != nil {
@@ -140,26 +141,40 @@ func (mb *ManifestBuilder) BuildManifest(ctx context.Context, streamerName strin
 			return nil, fmt.Errorf("failed to retrieve metadata: %w", err)
 		} else if metadata != nil {
 			log.Debug(ctx, "ManifestBuilder: found metadata configuration", "did", streamerName, "metadata", metadata)
-			streamplaceMetadata, err := metadata.ToStreamplaceMetadataConfiguration()
+			converted, err := metadata.ToStreamplaceMetadataConfiguration()
 			if err != nil {
 				log.Warn(ctx, "ManifestBuilder: failed to convert metadata, using defaults", "error", err, "did", streamerName)
 			} else {
-				log.Debug(ctx, "ManifestBuilder: enhancing manifest with metadata", "did", streamerName, "contentWarnings", streamplaceMetadata.ContentWarnings, "contentRights", streamplaceMetadata.ContentRights)
+				log.Debug(ctx, "ManifestBuilder: enhancing manifest with metadata", "did", streamerName, "contentWarnings", converted.ContentWarnings, "contentRights", converted.ContentRights)
+				streamplaceMetadata = converted
 				mani = mb.enhanceManifestWithMetadata(mani, &streamplaceMetadata, start)
-				metadataObj, err := toObj(streamplaceMetadata)
-				if err != nil {
-					return nil, fmt.Errorf("failed to marshal metadata: %w", err)
-				}
-				mani["assertions"] = append(mani["assertions"].([]obj), obj{
-					"label": "place.stream.metadata.configuration",
-					"data":  metadataObj,
-				})
 			}
 		} else {
 			log.Debug(ctx, "ManifestBuilder: no metadata configuration found for streamer", "did", streamerName)
 		}
 	}
 
+	// Generative AI training is opt-in: unless the streamer has explicitly
+	// allowed it, every minted segment carries an explicit "not allowed".
+	if streamplaceMetadata.DistributionPolicy == nil {
+		streamplaceMetadata.DistributionPolicy = &placestream.MetadataDistributionPolicy{}
+	}
+	if streamplaceMetadata.DistributionPolicy.AllowAiTraining == nil {
+		notAllowed := false
+		streamplaceMetadata.DistributionPolicy.AllowAiTraining = &notAllowed
+	}
+	metadataObj, err := toObj(streamplaceMetadata)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal metadata: %w", err)
+	}
+	mani["assertions"] = append(mani["assertions"].([]obj),
+		obj{
+			"label": "place.stream.metadata.configuration",
+			"data":  metadataObj,
+		},
+		trainingMiningAssertion(*streamplaceMetadata.DistributionPolicy.AllowAiTraining),
+	)
+
 	// Update the manifest title with the retrieved livestream title
 	mani["assertions"].([]obj)[1]["data"].(obj)["dc:title"] = livestreamTitle
 
@@ -181,6 +196,24 @@ func (mb *ManifestBuilder) BuildManifest(ctx context.Context, streamerName strin
 	return manifestBs, nil
 }
 
+// trainingMiningAssertion builds the CAWG training and data mining assertion
+// (https://cawg.io/training-and-data-mining/1.1/), the standard machine-readable
+// way to declare whether content may be used to train generative AI models.
+func trainingMiningAssertion(allowAiTraining bool) obj {
+	use := "notAllowed"
+	if allowAiTraining {
+		use = "allowed"
+	}
+	return obj{
+		"label": "cawg.training-mining",
+		"data": obj{
+			"entries": obj{
+				"cawg.ai_generative_training": obj{"use": use},
+			},
+		},
+	}
+}
+
 // getLicenseCodeMap returns a map of internal license codes to their corresponding URLs
 func getLicenseCodeMap() map[string]string {
 	return map[string]string{
diff --git a/pkg/media/manifest_builder_test.go b/pkg/media/manifest_builder_test.go
new file mode 100644
index 000000000..b423eb14e
--- /dev/null
+++ b/pkg/media/manifest_builder_test.go
@@ -0,0 +1,117 @@
+package media
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"stream.place/streamplace/pkg/config"
+	"stream.place/streamplace/pkg/model"
+	"stream.place/streamplace/pkg/placestream"
+)
+
+// manifestModelStub satisfies model.Model for ManifestBuilder tests; only the
+// two methods BuildManifest calls are implemented.
+type manifestModelStub struct {
+	model.Model
+	metadata *model.MetadataConfiguration
+}
+
+func (m *manifestModelStub) GetLatestLivestreamForRepo(repoDID string) (*model.Livestream, error) {
+	return nil, nil
+}
+
+func (m *manifestModelStub) GetMetadataConfiguration(ctx context.Context, repoDID string) (*model.MetadataConfiguration, error) {
+	return m.metadata, nil
+}
+
+func metadataConfigurationRow(t *testing.T, cfg *placestream.MetadataConfiguration) *model.MetadataConfiguration {
+	var buf bytes.Buffer
+	require.NoError(t, cfg.MarshalCBOR(&buf))
+	bs := buf.Bytes()
+	return &model.MetadataConfiguration{
+		RepoDID: "did:example:streamer",
+		Record:  &bs,
+	}
+}
+
+func buildManifestAssertions(t *testing.T, metadata *model.MetadataConfiguration) map[string]map[string]any {
+	mb := NewManifestBuilder(&manifestModelStub{metadata: metadata}, &config.CLI{})
+	manifestBs, err := mb.BuildManifest(context.Background(), "did:example:streamer", 1700000000000)
+	require.NoError(t, err)
+
+	var mani struct {
+		Assertions []struct {
+			Label string         `json:"label"`
+			Data  map[string]any `json:"data"`
+		} `json:"assertions"`
+	}
+	require.NoError(t, json.Unmarshal(manifestBs, &mani))
+
+	out := map[string]map[string]any{}
+	for _, a := range mani.Assertions {
+		out[a.Label] = a.Data
+	}
+	return out
+}
+
+func aiTrainingUse(t *testing.T, assertions map[string]map[string]any) string {
+	data, ok := assertions["cawg.training-mining"]
+	require.True(t, ok, "manifest must carry the cawg.training-mining assertion")
+	entries, ok := data["entries"].(map[string]any)
+	require.True(t, ok)
+	entry, ok := entries["cawg.ai_generative_training"].(map[string]any)
+	require.True(t, ok)
+	use, ok := entry["use"].(string)
+	require.True(t, ok)
+	return use
+}
+
+func allowAiTrainingField(t *testing.T, assertions map[string]map[string]any) any {
+	data, ok := assertions["place.stream.metadata.configuration"]
+	require.True(t, ok, "manifest must carry the metadata configuration assertion")
+	policy, ok := data["distributionPolicy"].(map[string]any)
+	require.True(t, ok, "metadata configuration must carry a distributionPolicy")
+	return policy["allowAiTraining"]
+}
+
+// A streamer with no metadata configuration at all still gets an explicit
+// "AI training not allowed" stamped into every minted segment.
+func TestBuildManifestAiTrainingDefaultDeny(t *testing.T) {
+	assertions := buildManifestAssertions(t, nil)
+	require.Equal(t, "notAllowed", aiTrainingUse(t, assertions))
+	require.Equal(t, false, allowAiTrainingField(t, assertions))
+}
+
+// A metadata configuration that never mentions AI training also defaults to
+// "not allowed" — the preference is opt-in.
+func TestBuildManifestAiTrainingUndeclaredDeny(t *testing.T) {
+	deleteAfter := int64(300)
+	row := metadataConfigurationRow(t, &placestream.MetadataConfiguration{
+		DistributionPolicy: &placestream.MetadataDistributionPolicy{
+			DeleteAfter: &deleteAfter,
+		},
+	})
+	assertions := buildManifestAssertions(t, row)
+	require.Equal(t, "notAllowed", aiTrainingUse(t, assertions))
+	require.Equal(t, false, allowAiTrainingField(t, assertions))
+
+	// the rest of the distribution policy survives the stamping
+	policy := assertions["place.stream.metadata.configuration"]["distributionPolicy"].(map[string]any)
+	require.Equal(t, float64(300), policy["deleteAfter"])
+}
+
+// An explicit opt-in is honored.
+func TestBuildManifestAiTrainingExplicitAllow(t *testing.T) {
+	allow := true
+	row := metadataConfigurationRow(t, &placestream.MetadataConfiguration{
+		DistributionPolicy: &placestream.MetadataDistributionPolicy{
+			AllowAiTraining: &allow,
+		},
+	})
+	assertions := buildManifestAssertions(t, row)
+	require.Equal(t, "allowed", aiTrainingUse(t, assertions))
+	require.Equal(t, true, allowAiTrainingField(t, assertions))
+}
diff --git a/pkg/media/media.go b/pkg/media/media.go
index 6f3563537..8893f0b10 100644
--- a/pkg/media/media.go
+++ b/pkg/media/media.go
@@ -427,16 +427,21 @@ func extractDistributionPolicy(mani *c2patypes.Manifest, segmentStart aqtime.AQT
 		return nil
 	}
 
-	if metadataConfig.DistributionPolicy.DeleteAfter == nil {
-		return nil
+	policy := &localdb.DistributionPolicy{
+		AllowAiTraining: metadataConfig.DistributionPolicy.AllowAiTraining,
 	}
 
-	// deleteAfter contains an offset in seconds from creation time
-	deleteAfterSeconds := *metadataConfig.DistributionPolicy.DeleteAfter
+	if metadataConfig.DistributionPolicy.DeleteAfter != nil {
+		// deleteAfter contains an offset in seconds from creation time
+		deleteAfterSeconds := *metadataConfig.DistributionPolicy.DeleteAfter
+		policy.DeleteAfterSeconds = &deleteAfterSeconds
+	}
 
-	return &localdb.DistributionPolicy{
-		DeleteAfterSeconds: &deleteAfterSeconds,
+	if policy.DeleteAfterSeconds == nil && policy.AllowAiTraining == nil {
+		return nil
 	}
+
+	return policy
 }
 
 // extractMetadataConfiguration extracts the place.stream.metadata.configuration from the C2PA manifest
diff --git a/pkg/placestream/metadatadistributionpolicy.go b/pkg/placestream/metadatadistributionpolicy.go
index 626e0b6fc..4598ab67a 100644
--- a/pkg/placestream/metadatadistributionpolicy.go
+++ b/pkg/placestream/metadatadistributionpolicy.go
@@ -19,6 +19,8 @@ func init() {
 // Distribution and rebroadcast policy.
 type MetadataDistributionPolicy struct {
 	LexiconTypeID string `json:"$type,omitempty"`
+	// allowAiTraining: Whether this content may be used as training data for generative AI models. Absent means undeclared; Streamplace treats undeclared as false and stamps an explicit value into every minted segment.
+	AllowAiTraining *bool `json:"allowAiTraining,omitempty"`
 	// allowedBroadcasters: List of did:webs of the broadcasters you want to allow to distribute your content. "*" allows anyone. Starting a line with a "!" bans that broadcaster.
 	AllowedBroadcasters []string `json:"allowedBroadcasters,omitempty"`
 	// deleteAfter: Duration in seconds after which segments should be deleted. Each segment will expire N seconds after its creation time. -1 to allow indefinite archival.