# Resource Tagging ## List tagged resources `resource_tagging.list(ResourceTaggingListParams**kwargs) -> SyncCursorPaginationAfter[ResourceTaggingListResponse]` **get** `/accounts/{account_id}/tags/resources` Lists all tagged resources for an account. ### Parameters - `account_id: str` Identifier. - `cursor: Optional[str]` Cursor for pagination. - `tag: Optional[SequenceNotStr[str]]` Filter resources by tag criteria. This parameter can be repeated multiple times, with AND logic between parameters. Supported syntax: - **Key-only**: `tag=` - Resource must have the tag key (e.g., `tag=production`) - **Key-value**: `tag==` - Resource must have the tag with specific value (e.g., `tag=env=prod`) - **Multiple values (OR)**: `tag==,` - Resource must have tag with any of the values (e.g., `tag=env=prod,staging`) - **Negate key-only**: `tag=!` - Resource must not have the tag key (e.g., `tag=!archived`) - **Negate key-value**: `tag=!=` - Resource must not have the tag with specific value (e.g., `tag=region!=us-west-1`) Multiple tag parameters are combined with AND logic. - `type: Optional[List[Literal["access_application", "access_application_policy", "access_group", 24 more]]]` Filter by resource type. Can be repeated to filter by multiple types (OR logic). Example: ?type=zone&type=worker - `"access_application"` - `"access_application_policy"` - `"access_group"` - `"account"` - `"ai_gateway"` - `"alerting_policy"` - `"alerting_webhook"` - `"api_gateway_operation"` - `"cloudflared_tunnel"` - `"custom_certificate"` - `"custom_hostname"` - `"d1_database"` - `"dns_record"` - `"durable_object_namespace"` - `"gateway_list"` - `"gateway_rule"` - `"image"` - `"kv_namespace"` - `"managed_client_certificate"` - `"queue"` - `"r2_bucket"` - `"resource_share"` - `"stream_live_input"` - `"stream_video"` - `"worker"` - `"worker_version"` - `"zone"` ### Returns - `ResourceTaggingListResponse` Response for access_application resources - `class ResourceTaggingTaggedResourceObjectAccessApplication: …` Response for access_application resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_application"]` - `"access_application"` - `class ResourceTaggingTaggedResourceObjectAccessApplicationPolicy: …` Response for access_application_policy resources - `id: str` Identifies the unique resource. - `access_application_id: str` Access application ID is required only for access_application_policy resources - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_application_policy"]` - `"access_application_policy"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectAccessGroup: …` Response for access_group resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_group"]` - `"access_group"` - `class ResourceTaggingTaggedResourceObjectAccount: …` Response for account resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["account"]` - `"account"` - `class ResourceTaggingTaggedResourceObjectAIGateway: …` Response for ai_gateway resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["ai_gateway"]` - `"ai_gateway"` - `class ResourceTaggingTaggedResourceObjectAlertingPolicy: …` Response for alerting_policy resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["alerting_policy"]` - `"alerting_policy"` - `class ResourceTaggingTaggedResourceObjectAlertingWebhook: …` Response for alerting_webhook resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["alerting_webhook"]` - `"alerting_webhook"` - `class ResourceTaggingTaggedResourceObjectAPIGatewayOperation: …` Response for api_gateway_operation resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["api_gateway_operation"]` - `"api_gateway_operation"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectCloudflaredTunnel: …` Response for cloudflared_tunnel resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["cloudflared_tunnel"]` - `"cloudflared_tunnel"` - `class ResourceTaggingTaggedResourceObjectCustomCertificate: …` Response for custom_certificate resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["custom_certificate"]` - `"custom_certificate"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectCustomHostname: …` Response for custom_hostname resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["custom_hostname"]` - `"custom_hostname"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectD1Database: …` Response for d1_database resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["d1_database"]` - `"d1_database"` - `class ResourceTaggingTaggedResourceObjectDNSRecord: …` Response for dns_record resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["dns_record"]` - `"dns_record"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectDurableObjectNamespace: …` Response for durable_object_namespace resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["durable_object_namespace"]` - `"durable_object_namespace"` - `class ResourceTaggingTaggedResourceObjectGatewayList: …` Response for gateway_list resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["gateway_list"]` - `"gateway_list"` - `class ResourceTaggingTaggedResourceObjectGatewayRule: …` Response for gateway_rule resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["gateway_rule"]` - `"gateway_rule"` - `class ResourceTaggingTaggedResourceObjectImage: …` Response for image resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["image"]` - `"image"` - `class ResourceTaggingTaggedResourceObjectKVNamespace: …` Response for kv_namespace resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["kv_namespace"]` - `"kv_namespace"` - `class ResourceTaggingTaggedResourceObjectManagedClientCertificate: …` Response for managed_client_certificate resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["managed_client_certificate"]` - `"managed_client_certificate"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectQueue: …` Response for queue resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["queue"]` - `"queue"` - `class ResourceTaggingTaggedResourceObjectR2Bucket: …` Response for r2_bucket resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["r2_bucket"]` - `"r2_bucket"` - `class ResourceTaggingTaggedResourceObjectResourceShare: …` Response for resource_share resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["resource_share"]` - `"resource_share"` - `class ResourceTaggingTaggedResourceObjectStreamLiveInput: …` Response for stream_live_input resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["stream_live_input"]` - `"stream_live_input"` - `class ResourceTaggingTaggedResourceObjectStreamVideo: …` Response for stream_video resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["stream_video"]` - `"stream_video"` - `class ResourceTaggingTaggedResourceObjectWorker: …` Response for worker resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["worker"]` - `"worker"` - `class ResourceTaggingTaggedResourceObjectWorkerVersion: …` Response for worker_version resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["worker_version"]` - `"worker_version"` - `worker_id: str` Worker ID is required only for worker_version resources - `class ResourceTaggingTaggedResourceObjectZone: …` Response for zone resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["zone"]` - `"zone"` - `zone_id: str` Zone ID is required only for zone-level resources ### Example ```python import os from cloudflare import Cloudflare client = Cloudflare( api_email=os.environ.get("CLOUDFLARE_EMAIL"), # This is the default and can be omitted api_key=os.environ.get("CLOUDFLARE_API_KEY"), # This is the default and can be omitted ) page = client.resource_tagging.list( account_id="023e105f4ecef8ad9ca31a8372d0c353", ) page = page.result[0] print(page) ``` #### Response ```json { "errors": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "messages": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "success": true, "result": [ { "id": "023e105f4ecef8ad9ca31a8372d0c353", "etag": "v1:RBNvo1WzZ4oRRq0W9-hkng", "name": "my-worker-script", "tags": { "environment": "production", "team": "engineering" }, "type": "access_application" } ], "result_info": { "count": 20, "cursor": "eyJhY2NvdW50X2lkIjoxMjM0NTY3ODkwfQ" } } ``` ## Domain Types ### Resource Tagging List Response - `ResourceTaggingListResponse` Response for access_application resources - `class ResourceTaggingTaggedResourceObjectAccessApplication: …` Response for access_application resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_application"]` - `"access_application"` - `class ResourceTaggingTaggedResourceObjectAccessApplicationPolicy: …` Response for access_application_policy resources - `id: str` Identifies the unique resource. - `access_application_id: str` Access application ID is required only for access_application_policy resources - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_application_policy"]` - `"access_application_policy"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectAccessGroup: …` Response for access_group resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_group"]` - `"access_group"` - `class ResourceTaggingTaggedResourceObjectAccount: …` Response for account resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["account"]` - `"account"` - `class ResourceTaggingTaggedResourceObjectAIGateway: …` Response for ai_gateway resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["ai_gateway"]` - `"ai_gateway"` - `class ResourceTaggingTaggedResourceObjectAlertingPolicy: …` Response for alerting_policy resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["alerting_policy"]` - `"alerting_policy"` - `class ResourceTaggingTaggedResourceObjectAlertingWebhook: …` Response for alerting_webhook resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["alerting_webhook"]` - `"alerting_webhook"` - `class ResourceTaggingTaggedResourceObjectAPIGatewayOperation: …` Response for api_gateway_operation resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["api_gateway_operation"]` - `"api_gateway_operation"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectCloudflaredTunnel: …` Response for cloudflared_tunnel resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["cloudflared_tunnel"]` - `"cloudflared_tunnel"` - `class ResourceTaggingTaggedResourceObjectCustomCertificate: …` Response for custom_certificate resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["custom_certificate"]` - `"custom_certificate"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectCustomHostname: …` Response for custom_hostname resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["custom_hostname"]` - `"custom_hostname"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectD1Database: …` Response for d1_database resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["d1_database"]` - `"d1_database"` - `class ResourceTaggingTaggedResourceObjectDNSRecord: …` Response for dns_record resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["dns_record"]` - `"dns_record"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectDurableObjectNamespace: …` Response for durable_object_namespace resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["durable_object_namespace"]` - `"durable_object_namespace"` - `class ResourceTaggingTaggedResourceObjectGatewayList: …` Response for gateway_list resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["gateway_list"]` - `"gateway_list"` - `class ResourceTaggingTaggedResourceObjectGatewayRule: …` Response for gateway_rule resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["gateway_rule"]` - `"gateway_rule"` - `class ResourceTaggingTaggedResourceObjectImage: …` Response for image resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["image"]` - `"image"` - `class ResourceTaggingTaggedResourceObjectKVNamespace: …` Response for kv_namespace resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["kv_namespace"]` - `"kv_namespace"` - `class ResourceTaggingTaggedResourceObjectManagedClientCertificate: …` Response for managed_client_certificate resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["managed_client_certificate"]` - `"managed_client_certificate"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectQueue: …` Response for queue resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["queue"]` - `"queue"` - `class ResourceTaggingTaggedResourceObjectR2Bucket: …` Response for r2_bucket resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["r2_bucket"]` - `"r2_bucket"` - `class ResourceTaggingTaggedResourceObjectResourceShare: …` Response for resource_share resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["resource_share"]` - `"resource_share"` - `class ResourceTaggingTaggedResourceObjectStreamLiveInput: …` Response for stream_live_input resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["stream_live_input"]` - `"stream_live_input"` - `class ResourceTaggingTaggedResourceObjectStreamVideo: …` Response for stream_video resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["stream_video"]` - `"stream_video"` - `class ResourceTaggingTaggedResourceObjectWorker: …` Response for worker resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["worker"]` - `"worker"` - `class ResourceTaggingTaggedResourceObjectWorkerVersion: …` Response for worker_version resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["worker_version"]` - `"worker_version"` - `worker_id: str` Worker ID is required only for worker_version resources - `class ResourceTaggingTaggedResourceObjectZone: …` Response for zone resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["zone"]` - `"zone"` - `zone_id: str` Zone ID is required only for zone-level resources # Account Tags ## Get tags for an account-level resource `resource_tagging.account_tags.get(AccountTagGetParams**kwargs) -> AccountTagGetResponse` **get** `/accounts/{account_id}/tags` Retrieves tags for a specific account-level resource. ### Parameters - `account_id: str` Identifier. - `resource_id: str` The ID of the resource to retrieve tags for. - `resource_type: Literal["access_application", "access_group", "account", 17 more]` The type of the resource. - `"access_application"` - `"access_group"` - `"account"` - `"ai_gateway"` - `"alerting_policy"` - `"alerting_webhook"` - `"cloudflared_tunnel"` - `"d1_database"` - `"durable_object_namespace"` - `"gateway_list"` - `"gateway_rule"` - `"image"` - `"kv_namespace"` - `"queue"` - `"r2_bucket"` - `"resource_share"` - `"stream_live_input"` - `"stream_video"` - `"worker"` - `"worker_version"` - `worker_id: Optional[str]` Worker identifier. Required for worker_version resources. ### Returns - `AccountTagGetResponse` Response for access_application resources - `class ResourceTaggingTaggedResourceObjectAccessApplication: …` Response for access_application resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_application"]` - `"access_application"` - `class ResourceTaggingTaggedResourceObjectAccessApplicationPolicy: …` Response for access_application_policy resources - `id: str` Identifies the unique resource. - `access_application_id: str` Access application ID is required only for access_application_policy resources - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_application_policy"]` - `"access_application_policy"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectAccessGroup: …` Response for access_group resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_group"]` - `"access_group"` - `class ResourceTaggingTaggedResourceObjectAccount: …` Response for account resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["account"]` - `"account"` - `class ResourceTaggingTaggedResourceObjectAIGateway: …` Response for ai_gateway resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["ai_gateway"]` - `"ai_gateway"` - `class ResourceTaggingTaggedResourceObjectAlertingPolicy: …` Response for alerting_policy resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["alerting_policy"]` - `"alerting_policy"` - `class ResourceTaggingTaggedResourceObjectAlertingWebhook: …` Response for alerting_webhook resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["alerting_webhook"]` - `"alerting_webhook"` - `class ResourceTaggingTaggedResourceObjectAPIGatewayOperation: …` Response for api_gateway_operation resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["api_gateway_operation"]` - `"api_gateway_operation"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectCloudflaredTunnel: …` Response for cloudflared_tunnel resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["cloudflared_tunnel"]` - `"cloudflared_tunnel"` - `class ResourceTaggingTaggedResourceObjectCustomCertificate: …` Response for custom_certificate resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["custom_certificate"]` - `"custom_certificate"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectCustomHostname: …` Response for custom_hostname resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["custom_hostname"]` - `"custom_hostname"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectD1Database: …` Response for d1_database resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["d1_database"]` - `"d1_database"` - `class ResourceTaggingTaggedResourceObjectDNSRecord: …` Response for dns_record resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["dns_record"]` - `"dns_record"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectDurableObjectNamespace: …` Response for durable_object_namespace resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["durable_object_namespace"]` - `"durable_object_namespace"` - `class ResourceTaggingTaggedResourceObjectGatewayList: …` Response for gateway_list resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["gateway_list"]` - `"gateway_list"` - `class ResourceTaggingTaggedResourceObjectGatewayRule: …` Response for gateway_rule resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["gateway_rule"]` - `"gateway_rule"` - `class ResourceTaggingTaggedResourceObjectImage: …` Response for image resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["image"]` - `"image"` - `class ResourceTaggingTaggedResourceObjectKVNamespace: …` Response for kv_namespace resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["kv_namespace"]` - `"kv_namespace"` - `class ResourceTaggingTaggedResourceObjectManagedClientCertificate: …` Response for managed_client_certificate resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["managed_client_certificate"]` - `"managed_client_certificate"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectQueue: …` Response for queue resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["queue"]` - `"queue"` - `class ResourceTaggingTaggedResourceObjectR2Bucket: …` Response for r2_bucket resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["r2_bucket"]` - `"r2_bucket"` - `class ResourceTaggingTaggedResourceObjectResourceShare: …` Response for resource_share resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["resource_share"]` - `"resource_share"` - `class ResourceTaggingTaggedResourceObjectStreamLiveInput: …` Response for stream_live_input resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["stream_live_input"]` - `"stream_live_input"` - `class ResourceTaggingTaggedResourceObjectStreamVideo: …` Response for stream_video resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["stream_video"]` - `"stream_video"` - `class ResourceTaggingTaggedResourceObjectWorker: …` Response for worker resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["worker"]` - `"worker"` - `class ResourceTaggingTaggedResourceObjectWorkerVersion: …` Response for worker_version resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["worker_version"]` - `"worker_version"` - `worker_id: str` Worker ID is required only for worker_version resources - `class ResourceTaggingTaggedResourceObjectZone: …` Response for zone resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["zone"]` - `"zone"` - `zone_id: str` Zone ID is required only for zone-level resources ### Example ```python import os from cloudflare import Cloudflare client = Cloudflare( api_email=os.environ.get("CLOUDFLARE_EMAIL"), # This is the default and can be omitted api_key=os.environ.get("CLOUDFLARE_API_KEY"), # This is the default and can be omitted ) account_tag = client.resource_tagging.account_tags.get( account_id="023e105f4ecef8ad9ca31a8372d0c353", resource_id="023e105f4ecef8ad9ca31a8372d0c353", resource_type="worker", ) print(account_tag) ``` #### Response ```json { "errors": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "messages": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "success": true, "result": { "id": "023e105f4ecef8ad9ca31a8372d0c353", "etag": "v1:RBNvo1WzZ4oRRq0W9-hkng", "name": "my-worker-script", "tags": { "environment": "production", "team": "engineering" }, "type": "access_application" } } ``` ## Set tags for an account-level resource `resource_tagging.account_tags.update(AccountTagUpdateParams**kwargs) -> AccountTagUpdateResponse` **put** `/accounts/{account_id}/tags` Creates or updates tags for a specific account-level resource. ### Parameters - `account_id: str` Identifier. - `resource_id: str` Identifies the unique resource. - `resource_type: Literal["access_application", "access_group", "account", 17 more]` Enum for base account-level resource types (those with no extra required fields). - `"access_application"` - `"access_group"` - `"account"` - `"ai_gateway"` - `"alerting_policy"` - `"alerting_webhook"` - `"cloudflared_tunnel"` - `"d1_database"` - `"durable_object_namespace"` - `"gateway_list"` - `"gateway_rule"` - `"image"` - `"kv_namespace"` - `"queue"` - `"r2_bucket"` - `"resource_share"` - `"stream_live_input"` - `"stream_video"` - `"worker"` - `"worker_version"` - `worker_id: str` Worker ID is required only for worker_version resources - `tags: Optional[Dict[str, str]]` Contains key-value pairs of tags. - `if_match: Optional[str]` ### Returns - `AccountTagUpdateResponse` Response for access_application resources - `class ResourceTaggingTaggedResourceObjectAccessApplication: …` Response for access_application resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_application"]` - `"access_application"` - `class ResourceTaggingTaggedResourceObjectAccessApplicationPolicy: …` Response for access_application_policy resources - `id: str` Identifies the unique resource. - `access_application_id: str` Access application ID is required only for access_application_policy resources - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_application_policy"]` - `"access_application_policy"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectAccessGroup: …` Response for access_group resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_group"]` - `"access_group"` - `class ResourceTaggingTaggedResourceObjectAccount: …` Response for account resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["account"]` - `"account"` - `class ResourceTaggingTaggedResourceObjectAIGateway: …` Response for ai_gateway resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["ai_gateway"]` - `"ai_gateway"` - `class ResourceTaggingTaggedResourceObjectAlertingPolicy: …` Response for alerting_policy resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["alerting_policy"]` - `"alerting_policy"` - `class ResourceTaggingTaggedResourceObjectAlertingWebhook: …` Response for alerting_webhook resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["alerting_webhook"]` - `"alerting_webhook"` - `class ResourceTaggingTaggedResourceObjectAPIGatewayOperation: …` Response for api_gateway_operation resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["api_gateway_operation"]` - `"api_gateway_operation"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectCloudflaredTunnel: …` Response for cloudflared_tunnel resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["cloudflared_tunnel"]` - `"cloudflared_tunnel"` - `class ResourceTaggingTaggedResourceObjectCustomCertificate: …` Response for custom_certificate resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["custom_certificate"]` - `"custom_certificate"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectCustomHostname: …` Response for custom_hostname resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["custom_hostname"]` - `"custom_hostname"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectD1Database: …` Response for d1_database resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["d1_database"]` - `"d1_database"` - `class ResourceTaggingTaggedResourceObjectDNSRecord: …` Response for dns_record resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["dns_record"]` - `"dns_record"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectDurableObjectNamespace: …` Response for durable_object_namespace resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["durable_object_namespace"]` - `"durable_object_namespace"` - `class ResourceTaggingTaggedResourceObjectGatewayList: …` Response for gateway_list resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["gateway_list"]` - `"gateway_list"` - `class ResourceTaggingTaggedResourceObjectGatewayRule: …` Response for gateway_rule resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["gateway_rule"]` - `"gateway_rule"` - `class ResourceTaggingTaggedResourceObjectImage: …` Response for image resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["image"]` - `"image"` - `class ResourceTaggingTaggedResourceObjectKVNamespace: …` Response for kv_namespace resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["kv_namespace"]` - `"kv_namespace"` - `class ResourceTaggingTaggedResourceObjectManagedClientCertificate: …` Response for managed_client_certificate resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["managed_client_certificate"]` - `"managed_client_certificate"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectQueue: …` Response for queue resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["queue"]` - `"queue"` - `class ResourceTaggingTaggedResourceObjectR2Bucket: …` Response for r2_bucket resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["r2_bucket"]` - `"r2_bucket"` - `class ResourceTaggingTaggedResourceObjectResourceShare: …` Response for resource_share resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["resource_share"]` - `"resource_share"` - `class ResourceTaggingTaggedResourceObjectStreamLiveInput: …` Response for stream_live_input resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["stream_live_input"]` - `"stream_live_input"` - `class ResourceTaggingTaggedResourceObjectStreamVideo: …` Response for stream_video resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["stream_video"]` - `"stream_video"` - `class ResourceTaggingTaggedResourceObjectWorker: …` Response for worker resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["worker"]` - `"worker"` - `class ResourceTaggingTaggedResourceObjectWorkerVersion: …` Response for worker_version resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["worker_version"]` - `"worker_version"` - `worker_id: str` Worker ID is required only for worker_version resources - `class ResourceTaggingTaggedResourceObjectZone: …` Response for zone resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["zone"]` - `"zone"` - `zone_id: str` Zone ID is required only for zone-level resources ### Example ```python import os from cloudflare import Cloudflare client = Cloudflare( api_email=os.environ.get("CLOUDFLARE_EMAIL"), # This is the default and can be omitted api_key=os.environ.get("CLOUDFLARE_API_KEY"), # This is the default and can be omitted ) account_tag = client.resource_tagging.account_tags.update( account_id="023e105f4ecef8ad9ca31a8372d0c353", resource_id="023e105f4ecef8ad9ca31a8372d0c353", resource_type="worker", worker_id="3f72a691-44b3-4c11-8642-c18a88ddaa5e", ) print(account_tag) ``` #### Response ```json { "errors": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "messages": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "success": true, "result": { "id": "023e105f4ecef8ad9ca31a8372d0c353", "etag": "v1:RBNvo1WzZ4oRRq0W9-hkng", "name": "my-worker-script", "tags": { "environment": "production", "team": "engineering" }, "type": "access_application" } } ``` ## Delete tags from an account-level resource `resource_tagging.account_tags.delete(AccountTagDeleteParams**kwargs)` **delete** `/accounts/{account_id}/tags` Removes all tags from a specific account-level resource. ### Parameters - `account_id: str` Identifier. - `if_match: Optional[str]` ### Example ```python import os from cloudflare import Cloudflare client = Cloudflare( api_email=os.environ.get("CLOUDFLARE_EMAIL"), # This is the default and can be omitted api_key=os.environ.get("CLOUDFLARE_API_KEY"), # This is the default and can be omitted ) client.resource_tagging.account_tags.delete( account_id="023e105f4ecef8ad9ca31a8372d0c353", ) ``` ## Domain Types ### Account Tag Get Response - `AccountTagGetResponse` Response for access_application resources - `class ResourceTaggingTaggedResourceObjectAccessApplication: …` Response for access_application resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_application"]` - `"access_application"` - `class ResourceTaggingTaggedResourceObjectAccessApplicationPolicy: …` Response for access_application_policy resources - `id: str` Identifies the unique resource. - `access_application_id: str` Access application ID is required only for access_application_policy resources - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_application_policy"]` - `"access_application_policy"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectAccessGroup: …` Response for access_group resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_group"]` - `"access_group"` - `class ResourceTaggingTaggedResourceObjectAccount: …` Response for account resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["account"]` - `"account"` - `class ResourceTaggingTaggedResourceObjectAIGateway: …` Response for ai_gateway resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["ai_gateway"]` - `"ai_gateway"` - `class ResourceTaggingTaggedResourceObjectAlertingPolicy: …` Response for alerting_policy resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["alerting_policy"]` - `"alerting_policy"` - `class ResourceTaggingTaggedResourceObjectAlertingWebhook: …` Response for alerting_webhook resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["alerting_webhook"]` - `"alerting_webhook"` - `class ResourceTaggingTaggedResourceObjectAPIGatewayOperation: …` Response for api_gateway_operation resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["api_gateway_operation"]` - `"api_gateway_operation"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectCloudflaredTunnel: …` Response for cloudflared_tunnel resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["cloudflared_tunnel"]` - `"cloudflared_tunnel"` - `class ResourceTaggingTaggedResourceObjectCustomCertificate: …` Response for custom_certificate resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["custom_certificate"]` - `"custom_certificate"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectCustomHostname: …` Response for custom_hostname resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["custom_hostname"]` - `"custom_hostname"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectD1Database: …` Response for d1_database resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["d1_database"]` - `"d1_database"` - `class ResourceTaggingTaggedResourceObjectDNSRecord: …` Response for dns_record resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["dns_record"]` - `"dns_record"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectDurableObjectNamespace: …` Response for durable_object_namespace resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["durable_object_namespace"]` - `"durable_object_namespace"` - `class ResourceTaggingTaggedResourceObjectGatewayList: …` Response for gateway_list resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["gateway_list"]` - `"gateway_list"` - `class ResourceTaggingTaggedResourceObjectGatewayRule: …` Response for gateway_rule resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["gateway_rule"]` - `"gateway_rule"` - `class ResourceTaggingTaggedResourceObjectImage: …` Response for image resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["image"]` - `"image"` - `class ResourceTaggingTaggedResourceObjectKVNamespace: …` Response for kv_namespace resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["kv_namespace"]` - `"kv_namespace"` - `class ResourceTaggingTaggedResourceObjectManagedClientCertificate: …` Response for managed_client_certificate resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["managed_client_certificate"]` - `"managed_client_certificate"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectQueue: …` Response for queue resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["queue"]` - `"queue"` - `class ResourceTaggingTaggedResourceObjectR2Bucket: …` Response for r2_bucket resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["r2_bucket"]` - `"r2_bucket"` - `class ResourceTaggingTaggedResourceObjectResourceShare: …` Response for resource_share resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["resource_share"]` - `"resource_share"` - `class ResourceTaggingTaggedResourceObjectStreamLiveInput: …` Response for stream_live_input resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["stream_live_input"]` - `"stream_live_input"` - `class ResourceTaggingTaggedResourceObjectStreamVideo: …` Response for stream_video resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["stream_video"]` - `"stream_video"` - `class ResourceTaggingTaggedResourceObjectWorker: …` Response for worker resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["worker"]` - `"worker"` - `class ResourceTaggingTaggedResourceObjectWorkerVersion: …` Response for worker_version resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["worker_version"]` - `"worker_version"` - `worker_id: str` Worker ID is required only for worker_version resources - `class ResourceTaggingTaggedResourceObjectZone: …` Response for zone resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["zone"]` - `"zone"` - `zone_id: str` Zone ID is required only for zone-level resources ### Account Tag Update Response - `AccountTagUpdateResponse` Response for access_application resources - `class ResourceTaggingTaggedResourceObjectAccessApplication: …` Response for access_application resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_application"]` - `"access_application"` - `class ResourceTaggingTaggedResourceObjectAccessApplicationPolicy: …` Response for access_application_policy resources - `id: str` Identifies the unique resource. - `access_application_id: str` Access application ID is required only for access_application_policy resources - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_application_policy"]` - `"access_application_policy"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectAccessGroup: …` Response for access_group resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_group"]` - `"access_group"` - `class ResourceTaggingTaggedResourceObjectAccount: …` Response for account resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["account"]` - `"account"` - `class ResourceTaggingTaggedResourceObjectAIGateway: …` Response for ai_gateway resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["ai_gateway"]` - `"ai_gateway"` - `class ResourceTaggingTaggedResourceObjectAlertingPolicy: …` Response for alerting_policy resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["alerting_policy"]` - `"alerting_policy"` - `class ResourceTaggingTaggedResourceObjectAlertingWebhook: …` Response for alerting_webhook resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["alerting_webhook"]` - `"alerting_webhook"` - `class ResourceTaggingTaggedResourceObjectAPIGatewayOperation: …` Response for api_gateway_operation resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["api_gateway_operation"]` - `"api_gateway_operation"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectCloudflaredTunnel: …` Response for cloudflared_tunnel resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["cloudflared_tunnel"]` - `"cloudflared_tunnel"` - `class ResourceTaggingTaggedResourceObjectCustomCertificate: …` Response for custom_certificate resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["custom_certificate"]` - `"custom_certificate"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectCustomHostname: …` Response for custom_hostname resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["custom_hostname"]` - `"custom_hostname"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectD1Database: …` Response for d1_database resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["d1_database"]` - `"d1_database"` - `class ResourceTaggingTaggedResourceObjectDNSRecord: …` Response for dns_record resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["dns_record"]` - `"dns_record"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectDurableObjectNamespace: …` Response for durable_object_namespace resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["durable_object_namespace"]` - `"durable_object_namespace"` - `class ResourceTaggingTaggedResourceObjectGatewayList: …` Response for gateway_list resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["gateway_list"]` - `"gateway_list"` - `class ResourceTaggingTaggedResourceObjectGatewayRule: …` Response for gateway_rule resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["gateway_rule"]` - `"gateway_rule"` - `class ResourceTaggingTaggedResourceObjectImage: …` Response for image resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["image"]` - `"image"` - `class ResourceTaggingTaggedResourceObjectKVNamespace: …` Response for kv_namespace resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["kv_namespace"]` - `"kv_namespace"` - `class ResourceTaggingTaggedResourceObjectManagedClientCertificate: …` Response for managed_client_certificate resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["managed_client_certificate"]` - `"managed_client_certificate"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectQueue: …` Response for queue resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["queue"]` - `"queue"` - `class ResourceTaggingTaggedResourceObjectR2Bucket: …` Response for r2_bucket resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["r2_bucket"]` - `"r2_bucket"` - `class ResourceTaggingTaggedResourceObjectResourceShare: …` Response for resource_share resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["resource_share"]` - `"resource_share"` - `class ResourceTaggingTaggedResourceObjectStreamLiveInput: …` Response for stream_live_input resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["stream_live_input"]` - `"stream_live_input"` - `class ResourceTaggingTaggedResourceObjectStreamVideo: …` Response for stream_video resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["stream_video"]` - `"stream_video"` - `class ResourceTaggingTaggedResourceObjectWorker: …` Response for worker resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["worker"]` - `"worker"` - `class ResourceTaggingTaggedResourceObjectWorkerVersion: …` Response for worker_version resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["worker_version"]` - `"worker_version"` - `worker_id: str` Worker ID is required only for worker_version resources - `class ResourceTaggingTaggedResourceObjectZone: …` Response for zone resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["zone"]` - `"zone"` - `zone_id: str` Zone ID is required only for zone-level resources # Zone Tags ## Get tags for a zone-level resource `resource_tagging.zone_tags.get(ZoneTagGetParams**kwargs) -> ZoneTagGetResponse` **get** `/zones/{zone_id}/tags` Retrieves tags for a specific zone-level resource. ### Parameters - `zone_id: str` Zone ID is required only for zone-level resources - `resource_id: str` The ID of the resource to retrieve tags for. - `resource_type: Literal["access_application_policy", "api_gateway_operation", "custom_certificate", 4 more]` The type of the resource. - `"access_application_policy"` - `"api_gateway_operation"` - `"custom_certificate"` - `"custom_hostname"` - `"dns_record"` - `"managed_client_certificate"` - `"zone"` - `access_application_id: Optional[str]` Access application ID identifier. Required for access_application_policy resources. ### Returns - `ZoneTagGetResponse` Response for access_application resources - `class ResourceTaggingTaggedResourceObjectAccessApplication: …` Response for access_application resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_application"]` - `"access_application"` - `class ResourceTaggingTaggedResourceObjectAccessApplicationPolicy: …` Response for access_application_policy resources - `id: str` Identifies the unique resource. - `access_application_id: str` Access application ID is required only for access_application_policy resources - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_application_policy"]` - `"access_application_policy"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectAccessGroup: …` Response for access_group resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_group"]` - `"access_group"` - `class ResourceTaggingTaggedResourceObjectAccount: …` Response for account resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["account"]` - `"account"` - `class ResourceTaggingTaggedResourceObjectAIGateway: …` Response for ai_gateway resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["ai_gateway"]` - `"ai_gateway"` - `class ResourceTaggingTaggedResourceObjectAlertingPolicy: …` Response for alerting_policy resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["alerting_policy"]` - `"alerting_policy"` - `class ResourceTaggingTaggedResourceObjectAlertingWebhook: …` Response for alerting_webhook resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["alerting_webhook"]` - `"alerting_webhook"` - `class ResourceTaggingTaggedResourceObjectAPIGatewayOperation: …` Response for api_gateway_operation resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["api_gateway_operation"]` - `"api_gateway_operation"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectCloudflaredTunnel: …` Response for cloudflared_tunnel resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["cloudflared_tunnel"]` - `"cloudflared_tunnel"` - `class ResourceTaggingTaggedResourceObjectCustomCertificate: …` Response for custom_certificate resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["custom_certificate"]` - `"custom_certificate"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectCustomHostname: …` Response for custom_hostname resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["custom_hostname"]` - `"custom_hostname"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectD1Database: …` Response for d1_database resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["d1_database"]` - `"d1_database"` - `class ResourceTaggingTaggedResourceObjectDNSRecord: …` Response for dns_record resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["dns_record"]` - `"dns_record"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectDurableObjectNamespace: …` Response for durable_object_namespace resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["durable_object_namespace"]` - `"durable_object_namespace"` - `class ResourceTaggingTaggedResourceObjectGatewayList: …` Response for gateway_list resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["gateway_list"]` - `"gateway_list"` - `class ResourceTaggingTaggedResourceObjectGatewayRule: …` Response for gateway_rule resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["gateway_rule"]` - `"gateway_rule"` - `class ResourceTaggingTaggedResourceObjectImage: …` Response for image resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["image"]` - `"image"` - `class ResourceTaggingTaggedResourceObjectKVNamespace: …` Response for kv_namespace resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["kv_namespace"]` - `"kv_namespace"` - `class ResourceTaggingTaggedResourceObjectManagedClientCertificate: …` Response for managed_client_certificate resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["managed_client_certificate"]` - `"managed_client_certificate"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectQueue: …` Response for queue resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["queue"]` - `"queue"` - `class ResourceTaggingTaggedResourceObjectR2Bucket: …` Response for r2_bucket resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["r2_bucket"]` - `"r2_bucket"` - `class ResourceTaggingTaggedResourceObjectResourceShare: …` Response for resource_share resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["resource_share"]` - `"resource_share"` - `class ResourceTaggingTaggedResourceObjectStreamLiveInput: …` Response for stream_live_input resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["stream_live_input"]` - `"stream_live_input"` - `class ResourceTaggingTaggedResourceObjectStreamVideo: …` Response for stream_video resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["stream_video"]` - `"stream_video"` - `class ResourceTaggingTaggedResourceObjectWorker: …` Response for worker resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["worker"]` - `"worker"` - `class ResourceTaggingTaggedResourceObjectWorkerVersion: …` Response for worker_version resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["worker_version"]` - `"worker_version"` - `worker_id: str` Worker ID is required only for worker_version resources - `class ResourceTaggingTaggedResourceObjectZone: …` Response for zone resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["zone"]` - `"zone"` - `zone_id: str` Zone ID is required only for zone-level resources ### Example ```python import os from cloudflare import Cloudflare client = Cloudflare( api_email=os.environ.get("CLOUDFLARE_EMAIL"), # This is the default and can be omitted api_key=os.environ.get("CLOUDFLARE_API_KEY"), # This is the default and can be omitted ) zone_tag = client.resource_tagging.zone_tags.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", resource_id="023e105f4ecef8ad9ca31a8372d0c353", resource_type="zone", ) print(zone_tag) ``` #### Response ```json { "errors": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "messages": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "success": true, "result": { "id": "023e105f4ecef8ad9ca31a8372d0c353", "etag": "v1:RBNvo1WzZ4oRRq0W9-hkng", "name": "my-worker-script", "tags": { "environment": "production", "team": "engineering" }, "type": "access_application" } } ``` ## Set tags for a zone-level resource `resource_tagging.zone_tags.update(ZoneTagUpdateParams**kwargs) -> ZoneTagUpdateResponse` **put** `/zones/{zone_id}/tags` Creates or updates tags for a specific zone-level resource. Replaces all existing tags for the resource. ### Parameters - `zone_id: str` Zone ID is required only for zone-level resources - `resource_id: str` Identifies the unique resource. - `resource_type: Literal["api_gateway_operation", "custom_certificate", "custom_hostname", 3 more]` Enum for base zone-level resource types (those with no extra required fields). - `"api_gateway_operation"` - `"custom_certificate"` - `"custom_hostname"` - `"dns_record"` - `"managed_client_certificate"` - `"zone"` - `tags: Optional[Dict[str, str]]` Contains key-value pairs of tags. - `if_match: Optional[str]` ### Returns - `ZoneTagUpdateResponse` Response for access_application resources - `class ResourceTaggingTaggedResourceObjectAccessApplication: …` Response for access_application resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_application"]` - `"access_application"` - `class ResourceTaggingTaggedResourceObjectAccessApplicationPolicy: …` Response for access_application_policy resources - `id: str` Identifies the unique resource. - `access_application_id: str` Access application ID is required only for access_application_policy resources - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_application_policy"]` - `"access_application_policy"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectAccessGroup: …` Response for access_group resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_group"]` - `"access_group"` - `class ResourceTaggingTaggedResourceObjectAccount: …` Response for account resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["account"]` - `"account"` - `class ResourceTaggingTaggedResourceObjectAIGateway: …` Response for ai_gateway resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["ai_gateway"]` - `"ai_gateway"` - `class ResourceTaggingTaggedResourceObjectAlertingPolicy: …` Response for alerting_policy resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["alerting_policy"]` - `"alerting_policy"` - `class ResourceTaggingTaggedResourceObjectAlertingWebhook: …` Response for alerting_webhook resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["alerting_webhook"]` - `"alerting_webhook"` - `class ResourceTaggingTaggedResourceObjectAPIGatewayOperation: …` Response for api_gateway_operation resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["api_gateway_operation"]` - `"api_gateway_operation"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectCloudflaredTunnel: …` Response for cloudflared_tunnel resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["cloudflared_tunnel"]` - `"cloudflared_tunnel"` - `class ResourceTaggingTaggedResourceObjectCustomCertificate: …` Response for custom_certificate resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["custom_certificate"]` - `"custom_certificate"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectCustomHostname: …` Response for custom_hostname resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["custom_hostname"]` - `"custom_hostname"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectD1Database: …` Response for d1_database resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["d1_database"]` - `"d1_database"` - `class ResourceTaggingTaggedResourceObjectDNSRecord: …` Response for dns_record resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["dns_record"]` - `"dns_record"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectDurableObjectNamespace: …` Response for durable_object_namespace resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["durable_object_namespace"]` - `"durable_object_namespace"` - `class ResourceTaggingTaggedResourceObjectGatewayList: …` Response for gateway_list resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["gateway_list"]` - `"gateway_list"` - `class ResourceTaggingTaggedResourceObjectGatewayRule: …` Response for gateway_rule resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["gateway_rule"]` - `"gateway_rule"` - `class ResourceTaggingTaggedResourceObjectImage: …` Response for image resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["image"]` - `"image"` - `class ResourceTaggingTaggedResourceObjectKVNamespace: …` Response for kv_namespace resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["kv_namespace"]` - `"kv_namespace"` - `class ResourceTaggingTaggedResourceObjectManagedClientCertificate: …` Response for managed_client_certificate resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["managed_client_certificate"]` - `"managed_client_certificate"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectQueue: …` Response for queue resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["queue"]` - `"queue"` - `class ResourceTaggingTaggedResourceObjectR2Bucket: …` Response for r2_bucket resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["r2_bucket"]` - `"r2_bucket"` - `class ResourceTaggingTaggedResourceObjectResourceShare: …` Response for resource_share resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["resource_share"]` - `"resource_share"` - `class ResourceTaggingTaggedResourceObjectStreamLiveInput: …` Response for stream_live_input resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["stream_live_input"]` - `"stream_live_input"` - `class ResourceTaggingTaggedResourceObjectStreamVideo: …` Response for stream_video resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["stream_video"]` - `"stream_video"` - `class ResourceTaggingTaggedResourceObjectWorker: …` Response for worker resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["worker"]` - `"worker"` - `class ResourceTaggingTaggedResourceObjectWorkerVersion: …` Response for worker_version resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["worker_version"]` - `"worker_version"` - `worker_id: str` Worker ID is required only for worker_version resources - `class ResourceTaggingTaggedResourceObjectZone: …` Response for zone resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["zone"]` - `"zone"` - `zone_id: str` Zone ID is required only for zone-level resources ### Example ```python import os from cloudflare import Cloudflare client = Cloudflare( api_email=os.environ.get("CLOUDFLARE_EMAIL"), # This is the default and can be omitted api_key=os.environ.get("CLOUDFLARE_API_KEY"), # This is the default and can be omitted ) zone_tag = client.resource_tagging.zone_tags.update( zone_id="023e105f4ecef8ad9ca31a8372d0c353", resource_id="023e105f4ecef8ad9ca31a8372d0c353", resource_type="zone", ) print(zone_tag) ``` #### Response ```json { "errors": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "messages": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "success": true, "result": { "id": "023e105f4ecef8ad9ca31a8372d0c353", "etag": "v1:RBNvo1WzZ4oRRq0W9-hkng", "name": "my-worker-script", "tags": { "environment": "production", "team": "engineering" }, "type": "access_application" } } ``` ## Delete tags from a zone-level resource `resource_tagging.zone_tags.delete(ZoneTagDeleteParams**kwargs)` **delete** `/zones/{zone_id}/tags` Removes all tags from a specific zone-level resource. ### Parameters - `zone_id: str` Zone ID is required only for zone-level resources - `if_match: Optional[str]` ### Example ```python import os from cloudflare import Cloudflare client = Cloudflare( api_email=os.environ.get("CLOUDFLARE_EMAIL"), # This is the default and can be omitted api_key=os.environ.get("CLOUDFLARE_API_KEY"), # This is the default and can be omitted ) client.resource_tagging.zone_tags.delete( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) ``` ## Domain Types ### Zone Tag Get Response - `ZoneTagGetResponse` Response for access_application resources - `class ResourceTaggingTaggedResourceObjectAccessApplication: …` Response for access_application resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_application"]` - `"access_application"` - `class ResourceTaggingTaggedResourceObjectAccessApplicationPolicy: …` Response for access_application_policy resources - `id: str` Identifies the unique resource. - `access_application_id: str` Access application ID is required only for access_application_policy resources - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_application_policy"]` - `"access_application_policy"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectAccessGroup: …` Response for access_group resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_group"]` - `"access_group"` - `class ResourceTaggingTaggedResourceObjectAccount: …` Response for account resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["account"]` - `"account"` - `class ResourceTaggingTaggedResourceObjectAIGateway: …` Response for ai_gateway resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["ai_gateway"]` - `"ai_gateway"` - `class ResourceTaggingTaggedResourceObjectAlertingPolicy: …` Response for alerting_policy resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["alerting_policy"]` - `"alerting_policy"` - `class ResourceTaggingTaggedResourceObjectAlertingWebhook: …` Response for alerting_webhook resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["alerting_webhook"]` - `"alerting_webhook"` - `class ResourceTaggingTaggedResourceObjectAPIGatewayOperation: …` Response for api_gateway_operation resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["api_gateway_operation"]` - `"api_gateway_operation"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectCloudflaredTunnel: …` Response for cloudflared_tunnel resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["cloudflared_tunnel"]` - `"cloudflared_tunnel"` - `class ResourceTaggingTaggedResourceObjectCustomCertificate: …` Response for custom_certificate resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["custom_certificate"]` - `"custom_certificate"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectCustomHostname: …` Response for custom_hostname resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["custom_hostname"]` - `"custom_hostname"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectD1Database: …` Response for d1_database resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["d1_database"]` - `"d1_database"` - `class ResourceTaggingTaggedResourceObjectDNSRecord: …` Response for dns_record resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["dns_record"]` - `"dns_record"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectDurableObjectNamespace: …` Response for durable_object_namespace resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["durable_object_namespace"]` - `"durable_object_namespace"` - `class ResourceTaggingTaggedResourceObjectGatewayList: …` Response for gateway_list resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["gateway_list"]` - `"gateway_list"` - `class ResourceTaggingTaggedResourceObjectGatewayRule: …` Response for gateway_rule resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["gateway_rule"]` - `"gateway_rule"` - `class ResourceTaggingTaggedResourceObjectImage: …` Response for image resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["image"]` - `"image"` - `class ResourceTaggingTaggedResourceObjectKVNamespace: …` Response for kv_namespace resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["kv_namespace"]` - `"kv_namespace"` - `class ResourceTaggingTaggedResourceObjectManagedClientCertificate: …` Response for managed_client_certificate resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["managed_client_certificate"]` - `"managed_client_certificate"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectQueue: …` Response for queue resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["queue"]` - `"queue"` - `class ResourceTaggingTaggedResourceObjectR2Bucket: …` Response for r2_bucket resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["r2_bucket"]` - `"r2_bucket"` - `class ResourceTaggingTaggedResourceObjectResourceShare: …` Response for resource_share resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["resource_share"]` - `"resource_share"` - `class ResourceTaggingTaggedResourceObjectStreamLiveInput: …` Response for stream_live_input resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["stream_live_input"]` - `"stream_live_input"` - `class ResourceTaggingTaggedResourceObjectStreamVideo: …` Response for stream_video resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["stream_video"]` - `"stream_video"` - `class ResourceTaggingTaggedResourceObjectWorker: …` Response for worker resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["worker"]` - `"worker"` - `class ResourceTaggingTaggedResourceObjectWorkerVersion: …` Response for worker_version resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["worker_version"]` - `"worker_version"` - `worker_id: str` Worker ID is required only for worker_version resources - `class ResourceTaggingTaggedResourceObjectZone: …` Response for zone resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["zone"]` - `"zone"` - `zone_id: str` Zone ID is required only for zone-level resources ### Zone Tag Update Response - `ZoneTagUpdateResponse` Response for access_application resources - `class ResourceTaggingTaggedResourceObjectAccessApplication: …` Response for access_application resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_application"]` - `"access_application"` - `class ResourceTaggingTaggedResourceObjectAccessApplicationPolicy: …` Response for access_application_policy resources - `id: str` Identifies the unique resource. - `access_application_id: str` Access application ID is required only for access_application_policy resources - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_application_policy"]` - `"access_application_policy"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectAccessGroup: …` Response for access_group resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["access_group"]` - `"access_group"` - `class ResourceTaggingTaggedResourceObjectAccount: …` Response for account resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["account"]` - `"account"` - `class ResourceTaggingTaggedResourceObjectAIGateway: …` Response for ai_gateway resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["ai_gateway"]` - `"ai_gateway"` - `class ResourceTaggingTaggedResourceObjectAlertingPolicy: …` Response for alerting_policy resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["alerting_policy"]` - `"alerting_policy"` - `class ResourceTaggingTaggedResourceObjectAlertingWebhook: …` Response for alerting_webhook resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["alerting_webhook"]` - `"alerting_webhook"` - `class ResourceTaggingTaggedResourceObjectAPIGatewayOperation: …` Response for api_gateway_operation resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["api_gateway_operation"]` - `"api_gateway_operation"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectCloudflaredTunnel: …` Response for cloudflared_tunnel resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["cloudflared_tunnel"]` - `"cloudflared_tunnel"` - `class ResourceTaggingTaggedResourceObjectCustomCertificate: …` Response for custom_certificate resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["custom_certificate"]` - `"custom_certificate"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectCustomHostname: …` Response for custom_hostname resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["custom_hostname"]` - `"custom_hostname"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectD1Database: …` Response for d1_database resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["d1_database"]` - `"d1_database"` - `class ResourceTaggingTaggedResourceObjectDNSRecord: …` Response for dns_record resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["dns_record"]` - `"dns_record"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectDurableObjectNamespace: …` Response for durable_object_namespace resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["durable_object_namespace"]` - `"durable_object_namespace"` - `class ResourceTaggingTaggedResourceObjectGatewayList: …` Response for gateway_list resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["gateway_list"]` - `"gateway_list"` - `class ResourceTaggingTaggedResourceObjectGatewayRule: …` Response for gateway_rule resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["gateway_rule"]` - `"gateway_rule"` - `class ResourceTaggingTaggedResourceObjectImage: …` Response for image resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["image"]` - `"image"` - `class ResourceTaggingTaggedResourceObjectKVNamespace: …` Response for kv_namespace resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["kv_namespace"]` - `"kv_namespace"` - `class ResourceTaggingTaggedResourceObjectManagedClientCertificate: …` Response for managed_client_certificate resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["managed_client_certificate"]` - `"managed_client_certificate"` - `zone_id: str` Zone ID is required only for zone-level resources - `class ResourceTaggingTaggedResourceObjectQueue: …` Response for queue resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["queue"]` - `"queue"` - `class ResourceTaggingTaggedResourceObjectR2Bucket: …` Response for r2_bucket resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["r2_bucket"]` - `"r2_bucket"` - `class ResourceTaggingTaggedResourceObjectResourceShare: …` Response for resource_share resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["resource_share"]` - `"resource_share"` - `class ResourceTaggingTaggedResourceObjectStreamLiveInput: …` Response for stream_live_input resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["stream_live_input"]` - `"stream_live_input"` - `class ResourceTaggingTaggedResourceObjectStreamVideo: …` Response for stream_video resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["stream_video"]` - `"stream_video"` - `class ResourceTaggingTaggedResourceObjectWorker: …` Response for worker resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["worker"]` - `"worker"` - `class ResourceTaggingTaggedResourceObjectWorkerVersion: …` Response for worker_version resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["worker_version"]` - `"worker_version"` - `worker_id: str` Worker ID is required only for worker_version resources - `class ResourceTaggingTaggedResourceObjectZone: …` Response for zone resources - `id: str` Identifies the unique resource. - `etag: str` ETag identifier for optimistic concurrency control. Formatted as "v1:" where the hash is the base64url-encoded SHA-256 (truncated to 128 bits) of the tags map canonicalized using RFC 8785 (JSON Canonicalization Scheme). Clients should treat ETags as opaque strings and pass them back via the If-Match header on write operations. - `name: str` Human-readable name of the resource. - `tags: Dict[str, str]` Contains key-value pairs of tags. - `type: Literal["zone"]` - `"zone"` - `zone_id: str` Zone ID is required only for zone-level resources # Keys ## List tag keys `resource_tagging.keys.list(KeyListParams**kwargs) -> SyncCursorPaginationAfter[KeyListResponse]` **get** `/accounts/{account_id}/tags/keys` Lists all distinct tag keys used across resources in an account. ### Parameters - `account_id: str` Identifier. - `cursor: Optional[str]` Cursor for pagination. ### Returns - `str` ### Example ```python import os from cloudflare import Cloudflare client = Cloudflare( api_email=os.environ.get("CLOUDFLARE_EMAIL"), # This is the default and can be omitted api_key=os.environ.get("CLOUDFLARE_API_KEY"), # This is the default and can be omitted ) page = client.resource_tagging.keys.list( account_id="023e105f4ecef8ad9ca31a8372d0c353", ) page = page.result[0] print(page) ``` #### Response ```json { "errors": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "messages": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "success": true, "result": [ "environment", "team", "region" ], "result_info": { "count": 20, "cursor": "eyJhY2NvdW50X2lkIjoxMjM0NTY3ODkwfQ" } } ``` ## Domain Types ### Key List Response - `str` # Values ## List tag values `resource_tagging.values.list(strtag_key, ValueListParams**kwargs) -> SyncCursorPaginationAfter[ValueListResponse]` **get** `/accounts/{account_id}/tags/values/{tag_key}` Lists all distinct values for a given tag key, optionally filtered by resource type. ### Parameters - `account_id: str` Identifier. - `tag_key: str` - `cursor: Optional[str]` Cursor for pagination. - `type: Optional[Literal["access_application", "access_application_policy", "access_group", 24 more]]` Filter by resource type. - `"access_application"` - `"access_application_policy"` - `"access_group"` - `"account"` - `"ai_gateway"` - `"alerting_policy"` - `"alerting_webhook"` - `"api_gateway_operation"` - `"cloudflared_tunnel"` - `"custom_certificate"` - `"custom_hostname"` - `"d1_database"` - `"dns_record"` - `"durable_object_namespace"` - `"gateway_list"` - `"gateway_rule"` - `"image"` - `"kv_namespace"` - `"managed_client_certificate"` - `"queue"` - `"r2_bucket"` - `"resource_share"` - `"stream_live_input"` - `"stream_video"` - `"worker"` - `"worker_version"` - `"zone"` ### Returns - `str` ### Example ```python import os from cloudflare import Cloudflare client = Cloudflare( api_email=os.environ.get("CLOUDFLARE_EMAIL"), # This is the default and can be omitted api_key=os.environ.get("CLOUDFLARE_API_KEY"), # This is the default and can be omitted ) page = client.resource_tagging.values.list( tag_key="environment", account_id="023e105f4ecef8ad9ca31a8372d0c353", ) page = page.result[0] print(page) ``` #### Response ```json { "errors": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "messages": [ { "code": 1000, "message": "message", "documentation_url": "documentation_url", "source": { "pointer": "pointer" } } ], "success": true, "result": [ "production", "staging" ], "result_info": { "count": 20, "cursor": "eyJhY2NvdW50X2lkIjoxMjM0NTY3ODkwfQ" } } ``` ## Domain Types ### Value List Response - `str`