Shared Types

from cloudflare.types import (
    ASN,
    AuditLog,
    CertificateCA,
    CertificateRequestType,
    CloudflareTunnel,
    ErrorData,
    Identifier,
    LoadBalancerPreview,
    Member,
    PaginationInfo,
    Permission,
    PermissionGrant,
    RatePlan,
    ResponseInfo,
    Result,
    Role,
    SortDirection,
    Subscription,
    SubscriptionComponent,
    SubscriptionZone,
    Token,
    TokenConditionCIDRList,
    TokenPolicy,
    TokenValue,
)

Accounts

Types:

from cloudflare.types.accounts import Account, AccountDeleteResponse

Methods:

client.accounts.create(**params) -> Optional[Account]
client.accounts.update(*, account_id, **params) -> Optional[Account]
client.accounts.list(**params) -> SyncV4PagePaginationArray[Account]
client.accounts.delete(*, account_id) -> Optional[AccountDeleteResponse]
client.accounts.get(*, account_id) -> Optional[Account]

Members

Types:

from cloudflare.types.accounts import Status, MemberDeleteResponse

Methods:

client.accounts.members.create(*, account_id, **params) -> Optional[Member]
client.accounts.members.update(member_id, *, account_id, **params) -> Optional[Member]
client.accounts.members.list(*, account_id, **params) -> SyncV4PagePaginationArray[Member]
client.accounts.members.delete(member_id, *, account_id) -> Optional[MemberDeleteResponse]
client.accounts.members.get(member_id, *, account_id) -> Optional[Member]

Roles

Methods:

client.accounts.roles.list(*, account_id, **params) -> SyncV4PagePaginationArray[Role]
client.accounts.roles.get(role_id, *, account_id) -> Optional[Role]

Subscriptions

Types:

from cloudflare.types.accounts import (
    SubscriptionCreateResponse,
    SubscriptionUpdateResponse,
    SubscriptionDeleteResponse,
)

Methods:

client.accounts.subscriptions.create(*, account_id, **params) -> SubscriptionCreateResponse
client.accounts.subscriptions.update(subscription_identifier, *, account_id, **params) -> SubscriptionUpdateResponse
client.accounts.subscriptions.delete(subscription_identifier, *, account_id) -> SubscriptionDeleteResponse
client.accounts.subscriptions.get(*, account_id) -> SyncSinglePage[Subscription]

Tokens

Types:

from cloudflare.types.accounts import TokenCreateResponse, TokenDeleteResponse, TokenVerifyResponse

Methods:

client.accounts.tokens.create(*, account_id, **params) -> Optional[TokenCreateResponse]
client.accounts.tokens.update(token_id, *, account_id, **params) -> Optional[Token]
client.accounts.tokens.list(*, account_id, **params) -> SyncV4PagePaginationArray[Token]
client.accounts.tokens.delete(token_id, *, account_id) -> Optional[TokenDeleteResponse]
client.accounts.tokens.get(token_id, *, account_id) -> Optional[Token]
client.accounts.tokens.verify(*, account_id) -> Optional[TokenVerifyResponse]

PermissionGroups

Types:

from cloudflare.types.accounts.tokens import PermissionGroupListResponse, PermissionGroupGetResponse

Methods:

client.accounts.tokens.permission_groups.list(*, account_id) -> SyncSinglePage[PermissionGroupListResponse]
client.accounts.tokens.permission_groups.get(*, account_id) -> SyncSinglePage[PermissionGroupGetResponse]

Value

Methods:

client.accounts.tokens.value.update(token_id, *, account_id, **params) -> str

Logs

Audit

Types:

from cloudflare.types.accounts.logs import AuditListResponse

Methods:

client.accounts.logs.audit.list(*, account_id, **params) -> SyncCursorLimitPagination[AuditListResponse]

OriginCACertificates

Types:

from cloudflare.types.origin_ca_certificates import (
    OriginCACertificate,
    OriginCACertificateDeleteResponse,
)

Methods:

client.origin_ca_certificates.create(**params) -> Optional[OriginCACertificate]
client.origin_ca_certificates.list(**params) -> SyncSinglePage[OriginCACertificate]
client.origin_ca_certificates.delete(certificate_id) -> Optional[OriginCACertificateDeleteResponse]
client.origin_ca_certificates.get(certificate_id) -> Optional[OriginCACertificate]

IPs

Types:

from cloudflare.types.ips import IPs, JDCloudIPs, IPListResponse

Methods:

client.ips.list(**params) -> Optional[IPListResponse]

Memberships

Types:

from cloudflare.types.memberships import (
    Membership,
    MembershipUpdateResponse,
    MembershipDeleteResponse,
    MembershipGetResponse,
)

Methods:

client.memberships.update(membership_id, **params) -> Optional[MembershipUpdateResponse]
client.memberships.list(**params) -> SyncV4PagePaginationArray[Membership]
client.memberships.delete(membership_id) -> Optional[MembershipDeleteResponse]
client.memberships.get(membership_id) -> Optional[MembershipGetResponse]

User

Types:

from cloudflare.types.user import UserEditResponse, UserGetResponse

Methods:

client.user.edit(**params) -> object
client.user.get() -> object

AuditLogs

Methods:

client.user.audit_logs.list(**params) -> SyncV4PagePaginationArray[AuditLog]

Billing

History

Types:

from cloudflare.types.user.billing import BillingHistory

Methods:

client.user.billing.history.list(**params) -> SyncV4PagePaginationArray[BillingHistory]

Profile

Types:

from cloudflare.types.user.billing import ProfileGetResponse

Methods:

client.user.billing.profile.get() -> ProfileGetResponse

Invites

Types:

from cloudflare.types.user import Invite

Methods:

client.user.invites.list() -> SyncSinglePage[Invite]
client.user.invites.edit(invite_id, **params) -> Optional[Invite]
client.user.invites.get(invite_id) -> Optional[Invite]

Organizations

Types:

from cloudflare.types.user import Organization, OrganizationDeleteResponse, OrganizationGetResponse

Methods:

client.user.organizations.list(**params) -> SyncV4PagePaginationArray[Organization]
client.user.organizations.delete(organization_id) -> OrganizationDeleteResponse
client.user.organizations.get(organization_id) -> object

Subscriptions

Types:

from cloudflare.types.user import SubscriptionUpdateResponse, SubscriptionDeleteResponse

Methods:

client.user.subscriptions.update(identifier, **params) -> SubscriptionUpdateResponse
client.user.subscriptions.delete(identifier) -> SubscriptionDeleteResponse
client.user.subscriptions.get() -> SyncSinglePage[Subscription]

Tokens

Types:

from cloudflare.types.user import TokenCreateResponse, TokenDeleteResponse, TokenVerifyResponse

Methods:

client.user.tokens.create(**params) -> Optional[TokenCreateResponse]
client.user.tokens.update(token_id, **params) -> Optional[Token]
client.user.tokens.list(**params) -> SyncV4PagePaginationArray[Token]
client.user.tokens.delete(token_id) -> Optional[TokenDeleteResponse]
client.user.tokens.get(token_id) -> Optional[Token]
client.user.tokens.verify() -> Optional[TokenVerifyResponse]

PermissionGroups

Types:

from cloudflare.types.user.tokens import PermissionGroupListResponse

Methods:

client.user.tokens.permission_groups.list() -> SyncSinglePage[PermissionGroupListResponse]

Value

Methods:

client.user.tokens.value.update(token_id, **params) -> str

Zones

Types:

from cloudflare.types.zones import Type, Zone, ZoneDeleteResponse

Methods:

client.zones.create(**params) -> Optional[Zone]
client.zones.list(**params) -> SyncV4PagePaginationArray[Zone]
client.zones.delete(*, zone_id) -> Optional[ZoneDeleteResponse]
client.zones.edit(*, zone_id, **params) -> Optional[Zone]
client.zones.get(*, zone_id) -> Optional[Zone]

ActivationCheck

Types:

from cloudflare.types.zones import ActivationCheckTriggerResponse

Methods:

client.zones.activation_check.trigger(*, zone_id) -> Optional[ActivationCheckTriggerResponse]

Settings

Types:

from cloudflare.types.zones import (
    AdvancedDDoS,
    Aegis,
    AlwaysOnline,
    AlwaysUseHTTPS,
    AutomaticHTTPSRewrites,
    AutomaticPlatformOptimization,
    Brotli,
    BrowserCacheTTL,
    BrowserCheck,
    CacheLevel,
    ChallengeTTL,
    Ciphers,
    DevelopmentMode,
    EarlyHints,
    EmailObfuscation,
    FontSettings,
    H2Prioritization,
    HotlinkProtection,
    HTTP2,
    HTTP3,
    ImageResizing,
    IPGeolocation,
    IPV6,
    MinTLSVersion,
    Mirage,
    NEL,
    OpportunisticEncryption,
    OpportunisticOnion,
    OrangeToOrange,
    OriginErrorPagePassThru,
    OriginMaxHTTPVersion,
    Polish,
    PrefetchPreload,
    ProxyReadTimeout,
    PseudoIPV4,
    ResponseBuffering,
    RocketLoader,
    SecurityHeaders,
    SecurityLevel,
    ServerSideExcludes,
    SortQueryStringForCache,
    SSL,
    SSLRecommender,
    TLS1_3,
    TLSClientAuth,
    TrueClientIPHeader,
    WAF,
    WebP,
    Websocket,
    ZeroRTT,
    SettingEditResponse,
    SettingGetResponse,
)

Methods:

client.zones.settings.edit(setting_id, *, zone_id, **params) -> Optional[SettingEditResponse]
client.zones.settings.get(setting_id, *, zone_id) -> Optional[SettingGetResponse]

CustomNameservers

Types:

from cloudflare.types.zones import CustomNameserverUpdateResponse, CustomNameserverGetResponse

Methods:

client.zones.custom_nameservers.update(*, zone_id, **params) -> SyncSinglePage[CustomNameserverUpdateResponse]
client.zones.custom_nameservers.get(*, zone_id) -> CustomNameserverGetResponse

Holds

Types:

from cloudflare.types.zones import ZoneHold

Methods:

client.zones.holds.create(*, zone_id, **params) -> ZoneHold
client.zones.holds.delete(*, zone_id, **params) -> ZoneHold
client.zones.holds.edit(*, zone_id, **params) -> ZoneHold
client.zones.holds.get(*, zone_id) -> ZoneHold

Subscriptions

Types:

from cloudflare.types.zones import (
    SubscriptionCreateResponse,
    SubscriptionUpdateResponse,
    SubscriptionGetResponse,
)

Methods:

client.zones.subscriptions.create(identifier, **params) -> SubscriptionCreateResponse
client.zones.subscriptions.update(identifier, **params) -> SubscriptionUpdateResponse
client.zones.subscriptions.get(identifier) -> SubscriptionGetResponse

Plans

Types:

from cloudflare.types.zones import AvailableRatePlan

Methods:

client.zones.plans.list(*, zone_id) -> SyncSinglePage[AvailableRatePlan]
client.zones.plans.get(plan_identifier, *, zone_id) -> AvailableRatePlan

RatePlans

Types:

from cloudflare.types.zones import RatePlanGetResponse

Methods:

client.zones.rate_plans.get(*, zone_id) -> SyncSinglePage[RatePlanGetResponse]

LoadBalancers

Types:

from cloudflare.types.load_balancers import (
    AdaptiveRouting,
    CheckRegion,
    DefaultPools,
    FilterOptions,
    Header,
    Host,
    LoadBalancer,
    LoadShedding,
    LocationStrategy,
    NotificationFilter,
    Origin,
    OriginSteering,
    RandomSteering,
    Rules,
    SessionAffinity,
    SessionAffinityAttributes,
    SteeringPolicy,
    LoadBalancerDeleteResponse,
)

Methods:

client.load_balancers.create(*, zone_id, **params) -> LoadBalancer
client.load_balancers.update(load_balancer_id, *, zone_id, **params) -> LoadBalancer
client.load_balancers.list(*, zone_id) -> SyncSinglePage[LoadBalancer]
client.load_balancers.delete(load_balancer_id, *, zone_id) -> LoadBalancerDeleteResponse
client.load_balancers.edit(load_balancer_id, *, zone_id, **params) -> LoadBalancer
client.load_balancers.get(load_balancer_id, *, zone_id) -> LoadBalancer

Monitors

Types:

from cloudflare.types.load_balancers import Monitor, MonitorDeleteResponse

Methods:

client.load_balancers.monitors.create(*, account_id, **params) -> Monitor
client.load_balancers.monitors.update(monitor_id, *, account_id, **params) -> Monitor
client.load_balancers.monitors.list(*, account_id) -> SyncSinglePage[Monitor]
client.load_balancers.monitors.delete(monitor_id, *, account_id) -> MonitorDeleteResponse
client.load_balancers.monitors.edit(monitor_id, *, account_id, **params) -> Monitor
client.load_balancers.monitors.get(monitor_id, *, account_id) -> Monitor

Previews

Types:

from cloudflare.types.load_balancers.monitors import PreviewCreateResponse

Methods:

client.load_balancers.monitors.previews.create(monitor_id, *, account_id, **params) -> PreviewCreateResponse

References

Types:

from cloudflare.types.load_balancers.monitors import ReferenceGetResponse

Methods:

client.load_balancers.monitors.references.get(monitor_id, *, account_id) -> SyncSinglePage[ReferenceGetResponse]

Pools

Types:

from cloudflare.types.load_balancers import Pool, PoolDeleteResponse

Methods:

client.load_balancers.pools.create(*, account_id, **params) -> Pool
client.load_balancers.pools.update(pool_id, *, account_id, **params) -> Pool
client.load_balancers.pools.list(*, account_id, **params) -> SyncSinglePage[Pool]
client.load_balancers.pools.delete(pool_id, *, account_id) -> PoolDeleteResponse
client.load_balancers.pools.bulk_edit(*, account_id, **params) -> SyncSinglePage[Pool]
client.load_balancers.pools.edit(pool_id, *, account_id, **params) -> Pool
client.load_balancers.pools.get(pool_id, *, account_id) -> Pool

Health

Types:

from cloudflare.types.load_balancers.pools import HealthCreateResponse, HealthGetResponse

Methods:

client.load_balancers.pools.health.create(pool_id, *, account_id, **params) -> HealthCreateResponse
client.load_balancers.pools.health.get(pool_id, *, account_id) -> HealthGetResponse

References

Types:

from cloudflare.types.load_balancers.pools import ReferenceGetResponse

Methods:

client.load_balancers.pools.references.get(pool_id, *, account_id) -> SyncSinglePage[ReferenceGetResponse]

Previews

Types:

from cloudflare.types.load_balancers import PreviewGetResponse

Methods:

client.load_balancers.previews.get(preview_id, *, account_id) -> PreviewGetResponse

Regions

Types:

from cloudflare.types.load_balancers import RegionListResponse, RegionGetResponse

Methods:

client.load_balancers.regions.list(*, account_id, **params) -> RegionListResponse
client.load_balancers.regions.get(region_id, *, account_id) -> RegionGetResponse

Searches

Types:

from cloudflare.types.load_balancers import SearchListResponse

Methods:

client.load_balancers.searches.list(*, account_id, **params) -> SyncV4PagePagination[SearchListResponse]

Cache

Types:

from cloudflare.types.cache import CachePurgeResponse

Methods:

client.cache.purge(*, zone_id, **params) -> Optional[CachePurgeResponse]

CacheReserve

Types:

from cloudflare.types.cache import (
    CacheReserve,
    CacheReserveClear,
    State,
    CacheReserveClearResponse,
    CacheReserveEditResponse,
    CacheReserveGetResponse,
    CacheReserveStatusResponse,
)

Methods:

client.cache.cache_reserve.clear(*, zone_id, **params) -> Optional[CacheReserveClearResponse]
client.cache.cache_reserve.edit(*, zone_id, **params) -> Optional[CacheReserveEditResponse]
client.cache.cache_reserve.get(*, zone_id) -> Optional[CacheReserveGetResponse]
client.cache.cache_reserve.status(*, zone_id) -> Optional[CacheReserveStatusResponse]

SmartTieredCache

Types:

from cloudflare.types.cache import (
    SmartTieredCacheDeleteResponse,
    SmartTieredCacheEditResponse,
    SmartTieredCacheGetResponse,
)

Methods:

client.cache.smart_tiered_cache.delete(*, zone_id) -> Optional[SmartTieredCacheDeleteResponse]
client.cache.smart_tiered_cache.edit(*, zone_id, **params) -> Optional[SmartTieredCacheEditResponse]
client.cache.smart_tiered_cache.get(*, zone_id) -> Optional[SmartTieredCacheGetResponse]

Variants

Types:

from cloudflare.types.cache import (
    CacheVariant,
    VariantDeleteResponse,
    VariantEditResponse,
    VariantGetResponse,
)

Methods:

client.cache.variants.delete(*, zone_id) -> Optional[VariantDeleteResponse]
client.cache.variants.edit(*, zone_id, **params) -> Optional[VariantEditResponse]
client.cache.variants.get(*, zone_id) -> Optional[VariantGetResponse]

RegionalTieredCache

Types:

from cloudflare.types.cache import (
    RegionalTieredCache,
    RegionalTieredCacheEditResponse,
    RegionalTieredCacheGetResponse,
)

Methods:

client.cache.regional_tiered_cache.edit(*, zone_id, **params) -> Optional[RegionalTieredCacheEditResponse]
client.cache.regional_tiered_cache.get(*, zone_id) -> Optional[RegionalTieredCacheGetResponse]

SSL

Analyze

Types:

from cloudflare.types.ssl import AnalyzeCreateResponse

Methods:

client.ssl.analyze.create(*, zone_id, **params) -> object

CertificatePacks

Types:

from cloudflare.types.ssl import (
    Host,
    RequestValidity,
    Status,
    ValidationMethod,
    CertificatePackCreateResponse,
    CertificatePackListResponse,
    CertificatePackDeleteResponse,
    CertificatePackEditResponse,
    CertificatePackGetResponse,
)

Methods:

client.ssl.certificate_packs.create(*, zone_id, **params) -> Optional[CertificatePackCreateResponse]
client.ssl.certificate_packs.list(*, zone_id, **params) -> SyncSinglePage[object]
client.ssl.certificate_packs.delete(certificate_pack_id, *, zone_id) -> Optional[CertificatePackDeleteResponse]
client.ssl.certificate_packs.edit(certificate_pack_id, *, zone_id, **params) -> Optional[CertificatePackEditResponse]
client.ssl.certificate_packs.get(certificate_pack_id, *, zone_id) -> object

Quota

Types:

from cloudflare.types.ssl.certificate_packs import QuotaGetResponse

Methods:

client.ssl.certificate_packs.quota.get(*, zone_id) -> Optional[QuotaGetResponse]

Recommendations

Types:

from cloudflare.types.ssl import RecommendationGetResponse

Methods:

client.ssl.recommendations.get(*, zone_id) -> Optional[RecommendationGetResponse]

Universal

Settings

Types:

from cloudflare.types.ssl.universal import UniversalSSLSettings

Methods:

client.ssl.universal.settings.edit(*, zone_id, **params) -> Optional[UniversalSSLSettings]
client.ssl.universal.settings.get(*, zone_id) -> Optional[UniversalSSLSettings]

Verification

Types:

from cloudflare.types.ssl import Verification, VerificationEditResponse, VerificationGetResponse

Methods:

client.ssl.verification.edit(certificate_pack_id, *, zone_id, **params) -> Optional[VerificationEditResponse]
client.ssl.verification.get(*, zone_id, **params) -> Optional[VerificationGetResponse]

ACM

TotalTLS

Types:

from cloudflare.types.acm import CertificateAuthority, TotalTLSCreateResponse, TotalTLSGetResponse

Methods:

client.acm.total_tls.create(*, zone_id, **params) -> Optional[TotalTLSCreateResponse]
client.acm.total_tls.get(*, zone_id) -> Optional[TotalTLSGetResponse]

Argo

SmartRouting

Types:

from cloudflare.types.argo import SmartRoutingEditResponse, SmartRoutingGetResponse

Methods:

client.argo.smart_routing.edit(*, zone_id, **params) -> SmartRoutingEditResponse
client.argo.smart_routing.get(*, zone_id) -> SmartRoutingGetResponse

TieredCaching

Types:

from cloudflare.types.argo import TieredCachingEditResponse, TieredCachingGetResponse

Methods:

client.argo.tiered_caching.edit(*, zone_id, **params) -> Optional[TieredCachingEditResponse]
client.argo.tiered_caching.get(*, zone_id) -> Optional[TieredCachingGetResponse]

CertificateAuthorities

HostnameAssociations

Types:

from cloudflare.types.certificate_authorities import (
    HostnameAssociation,
    TLSHostnameAssociation,
    HostnameAssociationUpdateResponse,
    HostnameAssociationGetResponse,
)

Methods:

client.certificate_authorities.hostname_associations.update(*, zone_id, **params) -> Optional[HostnameAssociationUpdateResponse]
client.certificate_authorities.hostname_associations.get(*, zone_id, **params) -> Optional[HostnameAssociationGetResponse]

ClientCertificates

Types:

from cloudflare.types.client_certificates import ClientCertificate

Methods:

client.client_certificates.create(*, zone_id, **params) -> Optional[ClientCertificate]
client.client_certificates.list(*, zone_id, **params) -> SyncV4PagePaginationArray[ClientCertificate]
client.client_certificates.delete(client_certificate_id, *, zone_id) -> Optional[ClientCertificate]
client.client_certificates.edit(client_certificate_id, *, zone_id) -> Optional[ClientCertificate]
client.client_certificates.get(client_certificate_id, *, zone_id) -> Optional[ClientCertificate]

CustomCertificates

Types:

from cloudflare.types.custom_certificates import (
    CustomCertificate,
    GeoRestrictions,
    Status,
    CustomCertificateDeleteResponse,
)

Methods:

client.custom_certificates.create(*, zone_id, **params) -> Optional[CustomCertificate]
client.custom_certificates.list(*, zone_id, **params) -> SyncV4PagePaginationArray[CustomCertificate]
client.custom_certificates.delete(custom_certificate_id, *, zone_id) -> Optional[CustomCertificateDeleteResponse]
client.custom_certificates.edit(custom_certificate_id, *, zone_id, **params) -> Optional[CustomCertificate]
client.custom_certificates.get(custom_certificate_id, *, zone_id) -> Optional[CustomCertificate]

Prioritize

Methods:

client.custom_certificates.prioritize.update(*, zone_id, **params) -> SyncSinglePage[CustomCertificate]

CustomHostnames

Types:

from cloudflare.types.custom_hostnames import (
    BundleMethod,
    CustomHostname,
    DCVMethod,
    DomainValidationType,
    CustomHostnameCreateResponse,
    CustomHostnameListResponse,
    CustomHostnameDeleteResponse,
    CustomHostnameEditResponse,
    CustomHostnameGetResponse,
)

Methods:

client.custom_hostnames.create(*, zone_id, **params) -> Optional[CustomHostnameCreateResponse]
client.custom_hostnames.list(*, zone_id, **params) -> SyncV4PagePaginationArray[CustomHostnameListResponse]
client.custom_hostnames.delete(custom_hostname_id, *, zone_id) -> CustomHostnameDeleteResponse
client.custom_hostnames.edit(custom_hostname_id, *, zone_id, **params) -> Optional[CustomHostnameEditResponse]
client.custom_hostnames.get(custom_hostname_id, *, zone_id) -> Optional[CustomHostnameGetResponse]

FallbackOrigin

Types:

from cloudflare.types.custom_hostnames import (
    FallbackOriginUpdateResponse,
    FallbackOriginDeleteResponse,
    FallbackOriginGetResponse,
)

Methods:

client.custom_hostnames.fallback_origin.update(*, zone_id, **params) -> Optional[FallbackOriginUpdateResponse]
client.custom_hostnames.fallback_origin.delete(*, zone_id) -> Optional[FallbackOriginDeleteResponse]
client.custom_hostnames.fallback_origin.get(*, zone_id) -> Optional[FallbackOriginGetResponse]

CertificatePack

Certificates

Types:

from cloudflare.types.custom_hostnames.certificate_pack import (
    CertificateUpdateResponse,
    CertificateDeleteResponse,
)

Methods:

client.custom_hostnames.certificate_pack.certificates.update(certificate_id, *, zone_id, custom_hostname_id, certificate_pack_id, **params) -> Optional[CertificateUpdateResponse]
client.custom_hostnames.certificate_pack.certificates.delete(certificate_id, *, zone_id, custom_hostname_id, certificate_pack_id) -> CertificateDeleteResponse

CustomNameservers

Types:

from cloudflare.types.custom_nameservers import (
    CustomNameserver,
    CustomNameserverDeleteResponse,
    CustomNameserverAvailabiltyResponse,
)

Methods:

client.custom_nameservers.create(*, account_id, **params) -> Optional[CustomNameserver]
client.custom_nameservers.delete(custom_ns_id, *, account_id) -> SyncSinglePage[CustomNameserverDeleteResponse]
client.custom_nameservers.availabilty(*, account_id) -> SyncSinglePage[CustomNameserverAvailabiltyResponse]
client.custom_nameservers.get(*, account_id) -> SyncSinglePage[CustomNameserver]

DNSFirewall

Types:

from cloudflare.types.dns_firewall import (
    AttackMitigation,
    FirewallIPs,
    UpstreamIPs,
    DNSFirewallCreateResponse,
    DNSFirewallListResponse,
    DNSFirewallDeleteResponse,
    DNSFirewallEditResponse,
    DNSFirewallGetResponse,
)

Methods:

client.dns_firewall.create(*, account_id, **params) -> Optional[DNSFirewallCreateResponse]
client.dns_firewall.list(*, account_id, **params) -> SyncV4PagePaginationArray[DNSFirewallListResponse]
client.dns_firewall.delete(dns_firewall_id, *, account_id) -> Optional[DNSFirewallDeleteResponse]
client.dns_firewall.edit(dns_firewall_id, *, account_id, **params) -> Optional[DNSFirewallEditResponse]
client.dns_firewall.get(dns_firewall_id, *, account_id) -> Optional[DNSFirewallGetResponse]

Analytics

Reports

Methods:

client.dns_firewall.analytics.reports.get(dns_firewall_id, *, account_id, **params) -> Optional[Report]

Bytimes

Methods:

client.dns_firewall.analytics.reports.bytimes.get(dns_firewall_id, *, account_id, **params) -> Optional[ByTime]

ReverseDNS

Types:

from cloudflare.types.dns_firewall import ReverseDNSEditResponse, ReverseDNSGetResponse

Methods:

client.dns_firewall.reverse_dns.edit(dns_firewall_id, *, account_id, **params) -> Optional[ReverseDNSEditResponse]
client.dns_firewall.reverse_dns.get(dns_firewall_id, *, account_id) -> Optional[ReverseDNSGetResponse]

DNS

Types:

from cloudflare.types.dns import DNSAnalyticsNominalMetric, DNSAnalyticsQuery

DNSSEC

Types:

from cloudflare.types.dns import DNSSEC, DNSSECDeleteResponse

Methods:

client.dns.dnssec.delete(*, zone_id) -> str
client.dns.dnssec.edit(*, zone_id, **params) -> Optional[DNSSEC]
client.dns.dnssec.get(*, zone_id) -> Optional[DNSSEC]

Records

Types:

from cloudflare.types.dns import (
    ARecord,
    AAAARecord,
    BatchPatch,
    BatchPut,
    CAARecord,
    CERTRecord,
    CNAMERecord,
    DNSKEYRecord,
    DSRecord,
    HTTPSRecord,
    LOCRecord,
    MXRecord,
    NAPTRRecord,
    NSRecord,
    PTRRecord,
    Record,
    RecordResponse,
    RecordTags,
    SMIMEARecord,
    SRVRecord,
    SSHFPRecord,
    SVCBRecord,
    TLSARecord,
    TTL,
    TXTRecord,
    URIRecord,
    RecordDeleteResponse,
    RecordBatchResponse,
    RecordExportResponse,
    RecordImportResponse,
    RecordScanResponse,
)

Methods:

client.dns.records.create(*, zone_id, **params) -> Optional[RecordResponse]
client.dns.records.update(dns_record_id, *, zone_id, **params) -> Optional[RecordResponse]
client.dns.records.list(*, zone_id, **params) -> SyncV4PagePaginationArray[RecordResponse]
client.dns.records.delete(dns_record_id, *, zone_id) -> Optional[RecordDeleteResponse]
client.dns.records.batch(*, zone_id, **params) -> Optional[RecordBatchResponse]
client.dns.records.edit(dns_record_id, *, zone_id, **params) -> Optional[RecordResponse]
client.dns.records.export(*, zone_id) -> str
client.dns.records.get(dns_record_id, *, zone_id) -> Optional[RecordResponse]
client.dns.records.import_(*, zone_id, **params) -> Optional[RecordImportResponse]
client.dns.records.scan(*, zone_id, **params) -> Optional[RecordScanResponse]

Settings

Types:

from cloudflare.types.dns import DNSSetting

Zone

Types:

from cloudflare.types.dns.settings import ZoneEditResponse, ZoneGetResponse

Methods:

client.dns.settings.zone.edit(*, zone_id, **params) -> Optional[ZoneEditResponse]
client.dns.settings.zone.get(*, zone_id) -> Optional[ZoneGetResponse]

Account

Types:

from cloudflare.types.dns.settings import AccountEditResponse, AccountGetResponse

Methods:

client.dns.settings.account.edit(*, account_id, **params) -> Optional[AccountEditResponse]
client.dns.settings.account.get(*, account_id) -> Optional[AccountGetResponse]

Views

Types:

from cloudflare.types.dns.settings.account import (
    ViewCreateResponse,
    ViewListResponse,
    ViewDeleteResponse,
    ViewEditResponse,
    ViewGetResponse,
)

Methods:

client.dns.settings.account.views.create(*, account_id, **params) -> Optional[ViewCreateResponse]
client.dns.settings.account.views.list(*, account_id, **params) -> SyncV4PagePaginationArray[ViewListResponse]
client.dns.settings.account.views.delete(view_id, *, account_id) -> Optional[ViewDeleteResponse]
client.dns.settings.account.views.edit(view_id, *, account_id, **params) -> Optional[ViewEditResponse]
client.dns.settings.account.views.get(view_id, *, account_id) -> Optional[ViewGetResponse]

Analytics

Reports

Types:

from cloudflare.types.dns.analytics import Report

Methods:

client.dns.analytics.reports.get(*, zone_id, **params) -> Optional[Report]

Bytimes

Types:

from cloudflare.types.dns.analytics.reports import ByTime

Methods:

client.dns.analytics.reports.bytimes.get(*, zone_id, **params) -> Optional[ByTime]

ZoneTransfers

ForceAXFR

Types:

from cloudflare.types.dns.zone_transfers import ForceAXFR

Methods:

client.dns.zone_transfers.force_axfr.create(*, zone_id, **params) -> str

Incoming

Types:

from cloudflare.types.dns.zone_transfers import (
    Incoming,
    IncomingCreateResponse,
    IncomingUpdateResponse,
    IncomingDeleteResponse,
    IncomingGetResponse,
)

Methods:

client.dns.zone_transfers.incoming.create(*, zone_id, **params) -> Optional[IncomingCreateResponse]
client.dns.zone_transfers.incoming.update(*, zone_id, **params) -> Optional[IncomingUpdateResponse]
client.dns.zone_transfers.incoming.delete(*, zone_id) -> Optional[IncomingDeleteResponse]
client.dns.zone_transfers.incoming.get(*, zone_id) -> Optional[IncomingGetResponse]

Outgoing

Types:

from cloudflare.types.dns.zone_transfers import (
    DisableTransfer,
    EnableTransfer,
    Outgoing,
    OutgoingStatus,
    OutgoingCreateResponse,
    OutgoingUpdateResponse,
    OutgoingDeleteResponse,
    OutgoingForceNotifyResponse,
    OutgoingGetResponse,
)

Methods:

client.dns.zone_transfers.outgoing.create(*, zone_id, **params) -> Optional[OutgoingCreateResponse]
client.dns.zone_transfers.outgoing.update(*, zone_id, **params) -> Optional[OutgoingUpdateResponse]
client.dns.zone_transfers.outgoing.delete(*, zone_id) -> Optional[OutgoingDeleteResponse]
client.dns.zone_transfers.outgoing.disable(*, zone_id, **params) -> str
client.dns.zone_transfers.outgoing.enable(*, zone_id, **params) -> str
client.dns.zone_transfers.outgoing.force_notify(*, zone_id, **params) -> str
client.dns.zone_transfers.outgoing.get(*, zone_id) -> Optional[OutgoingGetResponse]

Status

Methods:

client.dns.zone_transfers.outgoing.status.get(*, zone_id) -> str

ACLs

Types:

from cloudflare.types.dns.zone_transfers import ACL, ACLDeleteResponse

Methods:

client.dns.zone_transfers.acls.create(*, account_id, **params) -> Optional[ACL]
client.dns.zone_transfers.acls.update(acl_id, *, account_id, **params) -> Optional[ACL]
client.dns.zone_transfers.acls.list(*, account_id) -> SyncSinglePage[ACL]
client.dns.zone_transfers.acls.delete(acl_id, *, account_id) -> Optional[ACLDeleteResponse]
client.dns.zone_transfers.acls.get(acl_id, *, account_id) -> Optional[ACL]

Peers

Types:

from cloudflare.types.dns.zone_transfers import Peer, PeerDeleteResponse

Methods:

client.dns.zone_transfers.peers.create(*, account_id, **params) -> Optional[Peer]
client.dns.zone_transfers.peers.update(peer_id, *, account_id, **params) -> Optional[Peer]
client.dns.zone_transfers.peers.list(*, account_id) -> SyncSinglePage[Peer]
client.dns.zone_transfers.peers.delete(peer_id, *, account_id) -> Optional[PeerDeleteResponse]
client.dns.zone_transfers.peers.get(peer_id, *, account_id) -> Optional[Peer]

TSIGs

Types:

from cloudflare.types.dns.zone_transfers import TSIG, TSIGDeleteResponse

Methods:

client.dns.zone_transfers.tsigs.create(*, account_id, **params) -> Optional[TSIG]
client.dns.zone_transfers.tsigs.update(tsig_id, *, account_id, **params) -> Optional[TSIG]
client.dns.zone_transfers.tsigs.list(*, account_id) -> SyncSinglePage[TSIG]
client.dns.zone_transfers.tsigs.delete(tsig_id, *, account_id) -> Optional[TSIGDeleteResponse]
client.dns.zone_transfers.tsigs.get(tsig_id, *, account_id) -> Optional[TSIG]

EmailSecurity

Investigate

Types:

from cloudflare.types.email_security import InvestigateListResponse, InvestigateGetResponse

Methods:

client.email_security.investigate.list(*, account_id, **params) -> SyncV4PagePaginationArray[InvestigateListResponse]
client.email_security.investigate.get(postfix_id, *, account_id) -> InvestigateGetResponse

Detections

Types:

from cloudflare.types.email_security.investigate import DetectionGetResponse

Methods:

client.email_security.investigate.detections.get(postfix_id, *, account_id) -> DetectionGetResponse

Preview

Types:

from cloudflare.types.email_security.investigate import PreviewCreateResponse, PreviewGetResponse

Methods:

client.email_security.investigate.preview.create(*, account_id, **params) -> PreviewCreateResponse
client.email_security.investigate.preview.get(postfix_id, *, account_id) -> PreviewGetResponse

Raw

Types:

from cloudflare.types.email_security.investigate import RawGetResponse

Methods:

client.email_security.investigate.raw.get(postfix_id, *, account_id) -> RawGetResponse

Trace

Types:

from cloudflare.types.email_security.investigate import TraceGetResponse

Methods:

client.email_security.investigate.trace.get(postfix_id, *, account_id) -> TraceGetResponse

Move

Types:

from cloudflare.types.email_security.investigate import MoveCreateResponse, MoveBulkResponse

Methods:

client.email_security.investigate.move.create(postfix_id, *, account_id, **params) -> SyncSinglePage[MoveCreateResponse]
client.email_security.investigate.move.bulk(*, account_id, **params) -> SyncSinglePage[MoveBulkResponse]

Reclassify

Types:

from cloudflare.types.email_security.investigate import ReclassifyCreateResponse

Methods:

client.email_security.investigate.reclassify.create(postfix_id, *, account_id, **params) -> object

Release

Types:

from cloudflare.types.email_security.investigate import ReleaseBulkResponse

Methods:

client.email_security.investigate.release.bulk(*, account_id, **params) -> SyncSinglePage[ReleaseBulkResponse]

Settings

AllowPolicies

Types:

from cloudflare.types.email_security.settings import (
    AllowPolicyCreateResponse,
    AllowPolicyListResponse,
    AllowPolicyDeleteResponse,
    AllowPolicyEditResponse,
    AllowPolicyGetResponse,
)

Methods:

client.email_security.settings.allow_policies.create(*, account_id, **params) -> AllowPolicyCreateResponse
client.email_security.settings.allow_policies.list(*, account_id, **params) -> SyncV4PagePaginationArray[AllowPolicyListResponse]
client.email_security.settings.allow_policies.delete(policy_id, *, account_id) -> AllowPolicyDeleteResponse
client.email_security.settings.allow_policies.edit(policy_id, *, account_id, **params) -> AllowPolicyEditResponse
client.email_security.settings.allow_policies.get(policy_id, *, account_id) -> AllowPolicyGetResponse

BlockSenders

Types:

from cloudflare.types.email_security.settings import (
    BlockSenderCreateResponse,
    BlockSenderListResponse,
    BlockSenderDeleteResponse,
    BlockSenderEditResponse,
    BlockSenderGetResponse,
)

Methods:

client.email_security.settings.block_senders.create(*, account_id, **params) -> BlockSenderCreateResponse
client.email_security.settings.block_senders.list(*, account_id, **params) -> SyncV4PagePaginationArray[BlockSenderListResponse]
client.email_security.settings.block_senders.delete(pattern_id, *, account_id) -> BlockSenderDeleteResponse
client.email_security.settings.block_senders.edit(pattern_id, *, account_id, **params) -> BlockSenderEditResponse
client.email_security.settings.block_senders.get(pattern_id, *, account_id) -> BlockSenderGetResponse

Domains

Types:

from cloudflare.types.email_security.settings import (
    DomainListResponse,
    DomainDeleteResponse,
    DomainBulkDeleteResponse,
    DomainEditResponse,
    DomainGetResponse,
)

Methods:

client.email_security.settings.domains.list(*, account_id, **params) -> SyncV4PagePaginationArray[DomainListResponse]
client.email_security.settings.domains.delete(domain_id, *, account_id) -> DomainDeleteResponse
client.email_security.settings.domains.bulk_delete(*, account_id) -> SyncSinglePage[DomainBulkDeleteResponse]
client.email_security.settings.domains.edit(domain_id, *, account_id, **params) -> DomainEditResponse
client.email_security.settings.domains.get(domain_id, *, account_id) -> DomainGetResponse

ImpersonationRegistry

Types:

from cloudflare.types.email_security.settings import (
    ImpersonationRegistryCreateResponse,
    ImpersonationRegistryListResponse,
    ImpersonationRegistryDeleteResponse,
    ImpersonationRegistryEditResponse,
    ImpersonationRegistryGetResponse,
)

Methods:

client.email_security.settings.impersonation_registry.create(*, account_id, **params) -> ImpersonationRegistryCreateResponse
client.email_security.settings.impersonation_registry.list(*, account_id, **params) -> SyncV4PagePaginationArray[ImpersonationRegistryListResponse]
client.email_security.settings.impersonation_registry.delete(display_name_id, *, account_id) -> ImpersonationRegistryDeleteResponse
client.email_security.settings.impersonation_registry.edit(display_name_id, *, account_id, **params) -> ImpersonationRegistryEditResponse
client.email_security.settings.impersonation_registry.get(display_name_id, *, account_id) -> ImpersonationRegistryGetResponse

TrustedDomains

Types:

from cloudflare.types.email_security.settings import (
    TrustedDomainCreateResponse,
    TrustedDomainListResponse,
    TrustedDomainDeleteResponse,
    TrustedDomainEditResponse,
    TrustedDomainGetResponse,
)

Methods:

client.email_security.settings.trusted_domains.create(*, account_id, **params) -> TrustedDomainCreateResponse
client.email_security.settings.trusted_domains.list(*, account_id, **params) -> SyncV4PagePaginationArray[TrustedDomainListResponse]
client.email_security.settings.trusted_domains.delete(trusted_domain_id, *, account_id) -> TrustedDomainDeleteResponse
client.email_security.settings.trusted_domains.edit(trusted_domain_id, *, account_id, **params) -> TrustedDomainEditResponse
client.email_security.settings.trusted_domains.get(trusted_domain_id, *, account_id) -> TrustedDomainGetResponse

Submissions

Types:

from cloudflare.types.email_security import SubmissionListResponse

Methods:

client.email_security.submissions.list(*, account_id, **params) -> SyncV4PagePaginationArray[SubmissionListResponse]

EmailRouting

Types:

from cloudflare.types.email_routing import Settings

Methods:

client.email_routing.disable(*, zone_id, **params) -> Optional[Settings]
client.email_routing.enable(*, zone_id, **params) -> Optional[Settings]
client.email_routing.get(*, zone_id) -> Optional[Settings]

DNS

Types:

from cloudflare.types.email_routing import DNSRecord, DNSGetResponse

Methods:

client.email_routing.dns.create(*, zone_id, **params) -> Optional[Settings]
client.email_routing.dns.delete(*, zone_id) -> SyncSinglePage[DNSRecord]
client.email_routing.dns.edit(*, zone_id, **params) -> Optional[Settings]
client.email_routing.dns.get(*, zone_id, **params) -> DNSGetResponse

Rules

Types:

from cloudflare.types.email_routing import Action, EmailRoutingRule, Matcher

Methods:

client.email_routing.rules.create(*, zone_id, **params) -> Optional[EmailRoutingRule]
client.email_routing.rules.update(rule_identifier, *, zone_id, **params) -> Optional[EmailRoutingRule]
client.email_routing.rules.list(*, zone_id, **params) -> SyncV4PagePaginationArray[EmailRoutingRule]
client.email_routing.rules.delete(rule_identifier, *, zone_id) -> Optional[EmailRoutingRule]
client.email_routing.rules.get(rule_identifier, *, zone_id) -> Optional[EmailRoutingRule]

CatchAlls

Types:

from cloudflare.types.email_routing.rules import (
    CatchAllAction,
    CatchAllMatcher,
    CatchAllUpdateResponse,
    CatchAllGetResponse,
)

Methods:

client.email_routing.rules.catch_alls.update(*, zone_id, **params) -> Optional[CatchAllUpdateResponse]
client.email_routing.rules.catch_alls.get(*, zone_id) -> Optional[CatchAllGetResponse]

Addresses

Types:

from cloudflare.types.email_routing import Address

Methods:

client.email_routing.addresses.create(*, account_id, **params) -> Optional[Address]
client.email_routing.addresses.list(*, account_id, **params) -> SyncV4PagePaginationArray[Address]
client.email_routing.addresses.delete(destination_address_identifier, *, account_id) -> Optional[Address]
client.email_routing.addresses.get(destination_address_identifier, *, account_id) -> Optional[Address]

Filters

Types:

from cloudflare.types.filters import FirewallFilter

Methods:

client.filters.create(*, zone_id, **params) -> SyncSinglePage[FirewallFilter]
client.filters.update(filter_id, *, zone_id, **params) -> FirewallFilter
client.filters.list(*, zone_id, **params) -> SyncV4PagePaginationArray[FirewallFilter]
client.filters.delete(filter_id, *, zone_id) -> FirewallFilter
client.filters.bulk_delete(*, zone_id) -> SyncSinglePage[FirewallFilter]
client.filters.bulk_update(*, zone_id) -> SyncSinglePage[FirewallFilter]
client.filters.get(filter_id, *, zone_id) -> FirewallFilter

Firewall

Lockdowns

Types:

from cloudflare.types.firewall import (
    Configuration,
    Lockdown,
    LockdownCIDRConfiguration,
    LockdownIPConfiguration,
    LockdownURL,
    LockdownDeleteResponse,
)

Methods:

client.firewall.lockdowns.create(*, zone_id, **params) -> Lockdown
client.firewall.lockdowns.update(lock_downs_id, *, zone_id, **params) -> Lockdown
client.firewall.lockdowns.list(*, zone_id, **params) -> SyncV4PagePaginationArray[Lockdown]
client.firewall.lockdowns.delete(lock_downs_id, *, zone_id) -> Optional[LockdownDeleteResponse]
client.firewall.lockdowns.get(lock_downs_id, *, zone_id) -> Lockdown

Rules

Types:

from cloudflare.types.firewall import DeletedFilter, FirewallRule, Product

Methods:

client.firewall.rules.create(*, zone_id, **params) -> SyncSinglePage[FirewallRule]
client.firewall.rules.update(rule_id, *, zone_id, **params) -> FirewallRule
client.firewall.rules.list(*, zone_id, **params) -> SyncV4PagePaginationArray[FirewallRule]
client.firewall.rules.delete(rule_id, *, zone_id) -> FirewallRule
client.firewall.rules.bulk_delete(*, zone_id) -> SyncSinglePage[FirewallRule]
client.firewall.rules.bulk_edit(*, zone_id, **params) -> SyncSinglePage[FirewallRule]
client.firewall.rules.bulk_update(*, zone_id, **params) -> SyncSinglePage[FirewallRule]
client.firewall.rules.edit(rule_id, *, zone_id) -> SyncSinglePage[FirewallRule]
client.firewall.rules.get(rule_id, *, zone_id) -> FirewallRule

AccessRules

Types:

from cloudflare.types.firewall import (
    AccessRuleCIDRConfiguration,
    AccessRuleIPConfiguration,
    ASNConfiguration,
    CountryConfiguration,
    IPV6Configuration,
    AccessRuleCreateResponse,
    AccessRuleListResponse,
    AccessRuleDeleteResponse,
    AccessRuleEditResponse,
    AccessRuleGetResponse,
)

Methods:

client.firewall.access_rules.create(*, account_id, zone_id, **params) -> AccessRuleCreateResponse
client.firewall.access_rules.list(*, account_id, zone_id, **params) -> SyncV4PagePaginationArray[AccessRuleListResponse]
client.firewall.access_rules.delete(rule_id, *, account_id, zone_id) -> Optional[AccessRuleDeleteResponse]
client.firewall.access_rules.edit(rule_id, *, account_id, zone_id, **params) -> AccessRuleEditResponse
client.firewall.access_rules.get(rule_id, *, account_id, zone_id) -> AccessRuleGetResponse

UARules

Types:

from cloudflare.types.firewall import (
    UARuleCreateResponse,
    UARuleUpdateResponse,
    UARuleListResponse,
    UARuleDeleteResponse,
    UARuleGetResponse,
)

Methods:

client.firewall.ua_rules.create(*, zone_id, **params) -> UARuleCreateResponse
client.firewall.ua_rules.update(ua_rule_id, *, zone_id, **params) -> UARuleUpdateResponse
client.firewall.ua_rules.list(*, zone_id, **params) -> SyncV4PagePaginationArray[UARuleListResponse]
client.firewall.ua_rules.delete(ua_rule_id, *, zone_id) -> UARuleDeleteResponse
client.firewall.ua_rules.get(ua_rule_id, *, zone_id) -> UARuleGetResponse

WAF

Overrides

Types:

from cloudflare.types.firewall.waf import (
    Override,
    OverrideURL,
    RewriteAction,
    WAFRule,
    OverrideDeleteResponse,
)

Methods:

client.firewall.waf.overrides.create(*, zone_id, **params) -> Override
client.firewall.waf.overrides.update(overrides_id, *, zone_id, **params) -> Override
client.firewall.waf.overrides.list(*, zone_id, **params) -> SyncV4PagePaginationArray[Override]
client.firewall.waf.overrides.delete(overrides_id, *, zone_id) -> Optional[OverrideDeleteResponse]
client.firewall.waf.overrides.get(overrides_id, *, zone_id) -> Override

Packages

Types:

from cloudflare.types.firewall.waf import PackageListResponse, PackageGetResponse

Methods:

client.firewall.waf.packages.list(*, zone_id, **params) -> SyncV4PagePaginationArray[object]
client.firewall.waf.packages.get(package_id, *, zone_id) -> PackageGetResponse

Groups

Types:

from cloudflare.types.firewall.waf.packages import Group, GroupEditResponse, GroupGetResponse

Methods:

client.firewall.waf.packages.groups.list(package_id, *, zone_id, **params) -> SyncV4PagePaginationArray[Group]
client.firewall.waf.packages.groups.edit(group_id, *, zone_id, package_id, **params) -> GroupEditResponse
client.firewall.waf.packages.groups.get(group_id, *, zone_id, package_id) -> GroupGetResponse

Rules

Types:

from cloudflare.types.firewall.waf.packages import (
    AllowedModesAnomaly,
    WAFRuleGroup,
    RuleListResponse,
    RuleEditResponse,
    RuleGetResponse,
)

Methods:

client.firewall.waf.packages.rules.list(package_id, *, zone_id, **params) -> SyncV4PagePaginationArray[RuleListResponse]
client.firewall.waf.packages.rules.edit(rule_id, *, zone_id, package_id, **params) -> RuleEditResponse
client.firewall.waf.packages.rules.get(rule_id, *, zone_id, package_id) -> RuleGetResponse

Healthchecks

Types:

from cloudflare.types.healthchecks import (
    CheckRegion,
    Healthcheck,
    HTTPConfiguration,
    QueryHealthcheck,
    TCPConfiguration,
    HealthcheckDeleteResponse,
)

Methods:

client.healthchecks.create(*, zone_id, **params) -> Healthcheck
client.healthchecks.update(healthcheck_id, *, zone_id, **params) -> Healthcheck
client.healthchecks.list(*, zone_id, **params) -> SyncV4PagePaginationArray[Healthcheck]
client.healthchecks.delete(healthcheck_id, *, zone_id) -> HealthcheckDeleteResponse
client.healthchecks.edit(healthcheck_id, *, zone_id, **params) -> Healthcheck
client.healthchecks.get(healthcheck_id, *, zone_id) -> Healthcheck

Previews

Types:

from cloudflare.types.healthchecks import PreviewDeleteResponse

Methods:

client.healthchecks.previews.create(*, zone_id, **params) -> Healthcheck
client.healthchecks.previews.delete(healthcheck_id, *, zone_id) -> PreviewDeleteResponse
client.healthchecks.previews.get(healthcheck_id, *, zone_id) -> Healthcheck

KeylessCertificates

Types:

from cloudflare.types.keyless_certificates import (
    KeylessCertificate,
    Tunnel,
    KeylessCertificateDeleteResponse,
)

Methods:

client.keyless_certificates.create(*, zone_id, **params) -> Optional[KeylessCertificate]
client.keyless_certificates.list(*, zone_id) -> SyncSinglePage[KeylessCertificate]
client.keyless_certificates.delete(keyless_certificate_id, *, zone_id) -> Optional[KeylessCertificateDeleteResponse]
client.keyless_certificates.edit(keyless_certificate_id, *, zone_id, **params) -> Optional[KeylessCertificate]
client.keyless_certificates.get(keyless_certificate_id, *, zone_id) -> Optional[KeylessCertificate]

Logpush

Datasets

Fields

Types:

from cloudflare.types.logpush.datasets import FieldGetResponse

Methods:

client.logpush.datasets.fields.get(dataset_id, *, account_id, zone_id) -> object

Jobs

Methods:

client.logpush.datasets.jobs.get(dataset_id, *, account_id, zone_id) -> SyncSinglePage[Optional[LogpushJob]]

Edge

Types:

from cloudflare.types.logpush import InstantLogpushJob

Methods:

client.logpush.edge.create(*, zone_id, **params) -> Optional[InstantLogpushJob]
client.logpush.edge.get(*, zone_id) -> SyncSinglePage[Optional[InstantLogpushJob]]

Jobs

Types:

from cloudflare.types.logpush import LogpushJob, OutputOptions, JobDeleteResponse

Methods:

client.logpush.jobs.create(*, account_id, zone_id, **params) -> Optional[LogpushJob]
client.logpush.jobs.update(job_id, *, account_id, zone_id, **params) -> Optional[LogpushJob]
client.logpush.jobs.list(*, account_id, zone_id) -> SyncSinglePage[Optional[LogpushJob]]
client.logpush.jobs.delete(job_id, *, account_id, zone_id) -> Optional[JobDeleteResponse]
client.logpush.jobs.get(job_id, *, account_id, zone_id) -> Optional[LogpushJob]

Ownership

Types:

from cloudflare.types.logpush import OwnershipValidation, OwnershipCreateResponse

Methods:

client.logpush.ownership.create(*, account_id, zone_id, **params) -> Optional[OwnershipCreateResponse]
client.logpush.ownership.validate(*, account_id, zone_id, **params) -> Optional[OwnershipValidation]

Validate

Types:

from cloudflare.types.logpush import (
    ValidateDestinationResponse,
    ValidateDestinationExistsResponse,
    ValidateOriginResponse,
)

Methods:

client.logpush.validate.destination(*, account_id, zone_id, **params) -> Optional[ValidateDestinationResponse]
client.logpush.validate.destination_exists(*, account_id, zone_id, **params) -> Optional[ValidateDestinationExistsResponse]
client.logpush.validate.origin(*, account_id, zone_id, **params) -> Optional[ValidateOriginResponse]

Logs

Control

Retention

Types:

from cloudflare.types.logs.control import RetentionCreateResponse, RetentionGetResponse

Methods:

client.logs.control.retention.create(*, zone_id, **params) -> Optional[RetentionCreateResponse]
client.logs.control.retention.get(*, zone_id) -> Optional[RetentionGetResponse]

Cmb

Config

Types:

from cloudflare.types.logs.control.cmb import CmbConfig, ConfigDeleteResponse

Methods:

client.logs.control.cmb.config.create(*, account_id, **params) -> Optional[CmbConfig]
client.logs.control.cmb.config.delete(*, account_id) -> object
client.logs.control.cmb.config.get(*, account_id) -> Optional[CmbConfig]

RayID

Types:

from cloudflare.types.logs import RayIDGetResponse

Methods:

client.logs.rayid.get(rayid, *, zone_id, **params) -> RayIDGetResponse

Received

Types:

from cloudflare.types.logs import ReceivedGetResponse

Methods:

client.logs.received.get(*, zone_id, **params) -> ReceivedGetResponse

Fields

Types:

from cloudflare.types.logs.received import FieldGetResponse

Methods:

client.logs.received.fields.get(*, zone_id) -> FieldGetResponse

OriginTLSClientAuth

Types:

from cloudflare.types.origin_tls_client_auth import (
    ZoneAuthenticatedOriginPull,
    OriginTLSClientAuthCreateResponse,
    OriginTLSClientAuthListResponse,
    OriginTLSClientAuthDeleteResponse,
    OriginTLSClientAuthGetResponse,
)

Methods:

client.origin_tls_client_auth.create(*, zone_id, **params) -> Optional[OriginTLSClientAuthCreateResponse]
client.origin_tls_client_auth.list(*, zone_id) -> SyncSinglePage[OriginTLSClientAuthListResponse]
client.origin_tls_client_auth.delete(certificate_id, *, zone_id) -> Optional[OriginTLSClientAuthDeleteResponse]
client.origin_tls_client_auth.get(certificate_id, *, zone_id) -> Optional[OriginTLSClientAuthGetResponse]

Hostnames

Types:

from cloudflare.types.origin_tls_client_auth import AuthenticatedOriginPull, HostnameUpdateResponse

Methods:

client.origin_tls_client_auth.hostnames.update(*, zone_id, **params) -> SyncSinglePage[HostnameUpdateResponse]
client.origin_tls_client_auth.hostnames.get(hostname, *, zone_id) -> Optional[AuthenticatedOriginPull]

Certificates

Types:

from cloudflare.types.origin_tls_client_auth.hostnames import (
    Certificate,
    CertificateCreateResponse,
    CertificateListResponse,
    CertificateDeleteResponse,
    CertificateGetResponse,
)

Methods:

client.origin_tls_client_auth.hostnames.certificates.create(*, zone_id, **params) -> Optional[CertificateCreateResponse]
client.origin_tls_client_auth.hostnames.certificates.list(*, zone_id) -> SyncSinglePage[CertificateListResponse]
client.origin_tls_client_auth.hostnames.certificates.delete(certificate_id, *, zone_id) -> Optional[CertificateDeleteResponse]
client.origin_tls_client_auth.hostnames.certificates.get(certificate_id, *, zone_id) -> Optional[CertificateGetResponse]

Settings

Types:

from cloudflare.types.origin_tls_client_auth import SettingUpdateResponse, SettingGetResponse

Methods:

client.origin_tls_client_auth.settings.update(*, zone_id, **params) -> Optional[SettingUpdateResponse]
client.origin_tls_client_auth.settings.get(*, zone_id) -> Optional[SettingGetResponse]

PageRules

Types:

from cloudflare.types.page_rules import (
    PageRule,
    Target,
    PageRuleListResponse,
    PageRuleDeleteResponse,
)

Methods:

client.page_rules.create(*, zone_id, **params) -> Optional[PageRule]
client.page_rules.update(pagerule_id, *, zone_id, **params) -> Optional[PageRule]
client.page_rules.list(*, zone_id, **params) -> Optional[PageRuleListResponse]
client.page_rules.delete(pagerule_id, *, zone_id) -> Optional[PageRuleDeleteResponse]
client.page_rules.edit(pagerule_id, *, zone_id, **params) -> Optional[PageRule]
client.page_rules.get(pagerule_id, *, zone_id) -> Optional[PageRule]

RateLimits

Types:

from cloudflare.types.rate_limits import Action, Methods, RateLimit, RateLimitDeleteResponse

Methods:

client.rate_limits.create(*, zone_id, **params) -> RateLimit
client.rate_limits.list(*, zone_id, **params) -> SyncV4PagePaginationArray[RateLimit]
client.rate_limits.delete(rate_limit_id, *, zone_id) -> RateLimitDeleteResponse
client.rate_limits.edit(rate_limit_id, *, zone_id, **params) -> RateLimit
client.rate_limits.get(rate_limit_id, *, zone_id) -> RateLimit

WaitingRooms

Types:

from cloudflare.types.waiting_rooms import (
    AdditionalRoutes,
    CookieAttributes,
    Query,
    WaitingRoom,
    WaitingRoomDeleteResponse,
)

Methods:

client.waiting_rooms.create(*, zone_id, **params) -> WaitingRoom
client.waiting_rooms.update(waiting_room_id, *, zone_id, **params) -> WaitingRoom
client.waiting_rooms.list(*, account_id, zone_id, **params) -> SyncV4PagePaginationArray[WaitingRoom]
client.waiting_rooms.delete(waiting_room_id, *, zone_id) -> WaitingRoomDeleteResponse
client.waiting_rooms.edit(waiting_room_id, *, zone_id, **params) -> WaitingRoom
client.waiting_rooms.get(waiting_room_id, *, zone_id) -> WaitingRoom

Page

Types:

from cloudflare.types.waiting_rooms import PagePreviewResponse

Methods:

client.waiting_rooms.page.preview(*, zone_id, **params) -> PagePreviewResponse

Events

Types:

from cloudflare.types.waiting_rooms import Event, EventDeleteResponse

Methods:

client.waiting_rooms.events.create(waiting_room_id, *, zone_id, **params) -> Event
client.waiting_rooms.events.update(event_id, *, zone_id, waiting_room_id, **params) -> Event
client.waiting_rooms.events.list(waiting_room_id, *, zone_id, **params) -> SyncV4PagePaginationArray[Event]
client.waiting_rooms.events.delete(event_id, *, zone_id, waiting_room_id) -> EventDeleteResponse
client.waiting_rooms.events.edit(event_id, *, zone_id, waiting_room_id, **params) -> Event
client.waiting_rooms.events.get(event_id, *, zone_id, waiting_room_id) -> Event

Details

Types:

from cloudflare.types.waiting_rooms.events import EventQuery, DetailGetResponse

Methods:

client.waiting_rooms.events.details.get(event_id, *, zone_id, waiting_room_id) -> DetailGetResponse

Rules

Types:

from cloudflare.types.waiting_rooms import WaitingRoomRule

Methods:

client.waiting_rooms.rules.create(waiting_room_id, *, zone_id, **params) -> SyncSinglePage[WaitingRoomRule]
client.waiting_rooms.rules.update(waiting_room_id, *, zone_id, **params) -> SyncSinglePage[WaitingRoomRule]
client.waiting_rooms.rules.delete(rule_id, *, zone_id, waiting_room_id) -> SyncSinglePage[WaitingRoomRule]
client.waiting_rooms.rules.edit(rule_id, *, zone_id, waiting_room_id, **params) -> SyncSinglePage[WaitingRoomRule]
client.waiting_rooms.rules.get(waiting_room_id, *, zone_id) -> SyncSinglePage[WaitingRoomRule]

Statuses

Types:

from cloudflare.types.waiting_rooms import StatusGetResponse

Methods:

client.waiting_rooms.statuses.get(waiting_room_id, *, zone_id) -> StatusGetResponse

Settings

Types:

from cloudflare.types.waiting_rooms import (
    Setting,
    SettingUpdateResponse,
    SettingEditResponse,
    SettingGetResponse,
)

Methods:

client.waiting_rooms.settings.update(*, zone_id, **params) -> SettingUpdateResponse
client.waiting_rooms.settings.edit(*, zone_id, **params) -> SettingEditResponse
client.waiting_rooms.settings.get(*, zone_id) -> SettingGetResponse

Web3

Hostnames

Types:

from cloudflare.types.web3 import Hostname, HostnameDeleteResponse

Methods:

client.web3.hostnames.create(*, zone_id, **params) -> Hostname
client.web3.hostnames.list(*, zone_id) -> SyncSinglePage[Hostname]
client.web3.hostnames.delete(identifier, *, zone_id) -> Optional[HostnameDeleteResponse]
client.web3.hostnames.edit(identifier, *, zone_id, **params) -> Hostname
client.web3.hostnames.get(identifier, *, zone_id) -> Hostname

IPFSUniversalPaths

ContentLists

Types:

from cloudflare.types.web3.hostnames.ipfs_universal_paths import ContentList

Methods:

client.web3.hostnames.ipfs_universal_paths.content_lists.update(identifier, *, zone_id, **params) -> ContentList
client.web3.hostnames.ipfs_universal_paths.content_lists.get(identifier, *, zone_id) -> ContentList

Entries

Types:

from cloudflare.types.web3.hostnames.ipfs_universal_paths.content_lists import (
    EntryCreateResponse,
    EntryUpdateResponse,
    EntryListResponse,
    EntryDeleteResponse,
    EntryGetResponse,
)

Methods:

client.web3.hostnames.ipfs_universal_paths.content_lists.entries.create(identifier, *, zone_id, **params) -> EntryCreateResponse
client.web3.hostnames.ipfs_universal_paths.content_lists.entries.update(content_list_entry_identifier, *, zone_id, identifier, **params) -> EntryUpdateResponse
client.web3.hostnames.ipfs_universal_paths.content_lists.entries.list(identifier, *, zone_id) -> Optional[EntryListResponse]
client.web3.hostnames.ipfs_universal_paths.content_lists.entries.delete(content_list_entry_identifier, *, zone_id, identifier) -> Optional[EntryDeleteResponse]
client.web3.hostnames.ipfs_universal_paths.content_lists.entries.get(content_list_entry_identifier, *, zone_id, identifier) -> EntryGetResponse

Workers

Types:

from cloudflare.types.workers import MigrationStep, SingleStepMigration, WorkerMetadata

Routes

Types:

from cloudflare.types.workers import (
    RouteCreateResponse,
    RouteUpdateResponse,
    RouteListResponse,
    RouteDeleteResponse,
    RouteGetResponse,
)

Methods:

client.workers.routes.create(*, zone_id, **params) -> RouteCreateResponse
client.workers.routes.update(route_id, *, zone_id, **params) -> Optional[RouteUpdateResponse]
client.workers.routes.list(*, zone_id) -> SyncSinglePage[RouteListResponse]
client.workers.routes.delete(route_id, *, zone_id) -> RouteDeleteResponse
client.workers.routes.get(route_id, *, zone_id) -> Optional[RouteGetResponse]

Assets

Upload

Types:

from cloudflare.types.workers.assets import UploadCreateResponse

Methods:

client.workers.assets.upload.create(*, account_id, **params) -> Optional[UploadCreateResponse]

Scripts

Types:

from cloudflare.types.workers import Script, ScriptSetting, ScriptUpdateResponse, ScriptGetResponse

Methods:

client.workers.scripts.update(script_name, *, account_id, **params) -> Optional[ScriptUpdateResponse]
client.workers.scripts.list(*, account_id) -> SyncSinglePage[Script]
client.workers.scripts.delete(script_name, *, account_id, **params) -> None
client.workers.scripts.get(script_name, *, account_id) -> str

Assets

Upload

Types:

from cloudflare.types.workers.scripts.assets import UploadCreateResponse

Methods:

client.workers.scripts.assets.upload.create(script_name, *, account_id, **params) -> Optional[UploadCreateResponse]

Subdomain

Types:

from cloudflare.types.workers.scripts import SubdomainCreateResponse, SubdomainGetResponse

Methods:

client.workers.scripts.subdomain.create(script_name, *, account_id, **params) -> SubdomainCreateResponse
client.workers.scripts.subdomain.get(script_name, *, account_id) -> SubdomainGetResponse

Schedules

Types:

from cloudflare.types.workers.scripts import Schedule, ScheduleUpdateResponse, ScheduleGetResponse

Methods:

client.workers.scripts.schedules.update(script_name, *, account_id, **params) -> Optional[ScheduleUpdateResponse]
client.workers.scripts.schedules.get(script_name, *, account_id) -> Optional[ScheduleGetResponse]

Tail

Types:

from cloudflare.types.workers.scripts import (
    ConsumerScript,
    TailCreateResponse,
    TailDeleteResponse,
    TailGetResponse,
)

Methods:

client.workers.scripts.tail.create(script_name, *, account_id, **params) -> Optional[TailCreateResponse]
client.workers.scripts.tail.delete(id, *, account_id, script_name) -> TailDeleteResponse
client.workers.scripts.tail.get(script_name, *, account_id) -> Optional[TailGetResponse]

Content

Methods:

client.workers.scripts.content.update(script_name, *, account_id, **params) -> Optional[Script]
client.workers.scripts.content.get(script_name, *, account_id) -> BinaryAPIResponse

Settings

Methods:

client.workers.scripts.settings.edit(script_name, *, account_id, **params) -> Optional[ScriptSetting]
client.workers.scripts.settings.get(script_name, *, account_id) -> Optional[ScriptSetting]

Deployments

Types:

from cloudflare.types.workers.scripts import (
    Deployment,
    DeploymentCreateResponse,
    DeploymentGetResponse,
)

Methods:

client.workers.scripts.deployments.create(script_name, *, account_id, **params) -> Optional[DeploymentCreateResponse]
client.workers.scripts.deployments.get(script_name, *, account_id) -> Optional[DeploymentGetResponse]

Versions

Types:

from cloudflare.types.workers.scripts import (
    VersionCreateResponse,
    VersionListResponse,
    VersionGetResponse,
)

Methods:

client.workers.scripts.versions.create(script_name, *, account_id, **params) -> Optional[VersionCreateResponse]
client.workers.scripts.versions.list(script_name, *, account_id, **params) -> SyncV4PagePagination[VersionListResponse]
client.workers.scripts.versions.get(version_id, *, account_id, script_name) -> Optional[VersionGetResponse]

Secrets

Types:

from cloudflare.types.workers.scripts import (
    SecretUpdateResponse,
    SecretListResponse,
    SecretDeleteResponse,
    SecretGetResponse,
)

Methods:

client.workers.scripts.secrets.update(script_name, *, account_id, **params) -> Optional[SecretUpdateResponse]
client.workers.scripts.secrets.list(script_name, *, account_id) -> SyncSinglePage[SecretListResponse]
client.workers.scripts.secrets.delete(secret_name, *, account_id, script_name) -> object
client.workers.scripts.secrets.get(secret_name, *, account_id, script_name) -> Optional[SecretGetResponse]

AccountSettings

Types:

from cloudflare.types.workers import AccountSettingUpdateResponse, AccountSettingGetResponse

Methods:

client.workers.account_settings.update(*, account_id, **params) -> Optional[AccountSettingUpdateResponse]
client.workers.account_settings.get(*, account_id) -> Optional[AccountSettingGetResponse]

Domains

Types:

from cloudflare.types.workers import Domain

Methods:

client.workers.domains.update(*, account_id, **params) -> Optional[Domain]
client.workers.domains.list(*, account_id, **params) -> SyncSinglePage[Domain]
client.workers.domains.delete(domain_id, *, account_id) -> None
client.workers.domains.get(domain_id, *, account_id) -> Optional[Domain]

Subdomains

Types:

from cloudflare.types.workers import SubdomainUpdateResponse, SubdomainGetResponse

Methods:

client.workers.subdomains.update(*, account_id, **params) -> Optional[SubdomainUpdateResponse]
client.workers.subdomains.get(*, account_id) -> Optional[SubdomainGetResponse]

KV

Namespaces

Types:

from cloudflare.types.kv import (
    Namespace,
    NamespaceUpdateResponse,
    NamespaceDeleteResponse,
    NamespaceBulkDeleteResponse,
    NamespaceBulkUpdateResponse,
)

Methods:

client.kv.namespaces.create(*, account_id, **params) -> Optional[Namespace]
client.kv.namespaces.update(namespace_id, *, account_id, **params) -> Optional[NamespaceUpdateResponse]
client.kv.namespaces.list(*, account_id, **params) -> SyncV4PagePaginationArray[Namespace]
client.kv.namespaces.delete(namespace_id, *, account_id) -> Optional[NamespaceDeleteResponse]
client.kv.namespaces.bulk_delete(namespace_id, *, account_id, **params) -> Optional[NamespaceBulkDeleteResponse]
client.kv.namespaces.bulk_update(namespace_id, *, account_id, **params) -> Optional[NamespaceBulkUpdateResponse]
client.kv.namespaces.get(namespace_id, *, account_id) -> Optional[Namespace]

Analytics

Types:

from cloudflare.types.kv.namespaces import Components, Schema

Methods:

client.kv.namespaces.analytics.list(*, account_id, **params) -> Optional[Schema]
client.kv.namespaces.analytics.stored(*, account_id, **params) -> Optional[Components]

Keys

Types:

from cloudflare.types.kv.namespaces import Key

Methods:

client.kv.namespaces.keys.list(namespace_id, *, account_id, **params) -> SyncCursorLimitPagination[Key]

Metadata

Types:

from cloudflare.types.kv.namespaces import MetadataGetResponse

Methods:

client.kv.namespaces.metadata.get(key_name, *, account_id, namespace_id) -> Optional[MetadataGetResponse]

Values

Types:

from cloudflare.types.kv.namespaces import ValueUpdateResponse, ValueDeleteResponse

Methods:

client.kv.namespaces.values.update(key_name, *, account_id, namespace_id, **params) -> Optional[ValueUpdateResponse]
client.kv.namespaces.values.delete(key_name, *, account_id, namespace_id) -> Optional[ValueDeleteResponse]
client.kv.namespaces.values.get(key_name, *, account_id, namespace_id) -> BinaryAPIResponse

DurableObjects

Namespaces

Types:

from cloudflare.types.durable_objects import Namespace

Methods:

client.durable_objects.namespaces.list(*, account_id) -> SyncSinglePage[Namespace]

Objects

Types:

from cloudflare.types.durable_objects.namespaces import DurableObject

Methods:

client.durable_objects.namespaces.objects.list(id, *, account_id, **params) -> SyncCursorLimitPagination[DurableObject]

Queues

Types:

from cloudflare.types.queues import Queue, QueueDeleteResponse

Methods:

client.queues.create(*, account_id, **params) -> Optional[Queue]
client.queues.update(queue_id, *, account_id, **params) -> Optional[Queue]
client.queues.list(*, account_id) -> SyncSinglePage[Queue]
client.queues.delete(queue_id, *, account_id) -> QueueDeleteResponse
client.queues.get(queue_id, *, account_id) -> Optional[Queue]

Consumers

Types:

from cloudflare.types.queues import Consumer, ConsumerDeleteResponse

Methods:

client.queues.consumers.create(queue_id, *, account_id, **params) -> Optional[Consumer]
client.queues.consumers.update(consumer_id, *, account_id, queue_id, **params) -> Optional[Consumer]
client.queues.consumers.delete(consumer_id, *, account_id, queue_id) -> ConsumerDeleteResponse
client.queues.consumers.get(queue_id, *, account_id) -> SyncSinglePage[Consumer]

Messages

Types:

from cloudflare.types.queues import MessageAckResponse, MessagePullResponse

Methods:

client.queues.messages.ack(queue_id, *, account_id, **params) -> Optional[MessageAckResponse]
client.queues.messages.pull(queue_id, *, account_id, **params) -> SyncSinglePage[MessagePullResponse]

APIGateway

Configurations

Types:

from cloudflare.types.api_gateway import Configuration, ConfigurationUpdateResponse

Methods:

client.api_gateway.configurations.update(*, zone_id, **params) -> ConfigurationUpdateResponse
client.api_gateway.configurations.get(*, zone_id, **params) -> Configuration

Discovery

Types:

from cloudflare.types.api_gateway import DiscoveryOperation, DiscoveryGetResponse

Methods:

client.api_gateway.discovery.get(*, zone_id) -> DiscoveryGetResponse

Operations

Types:

from cloudflare.types.api_gateway.discovery import OperationBulkEditResponse, OperationEditResponse

Methods:

client.api_gateway.discovery.operations.list(*, zone_id, **params) -> SyncV4PagePaginationArray[DiscoveryOperation]
client.api_gateway.discovery.operations.bulk_edit(*, zone_id, **params) -> OperationBulkEditResponse
client.api_gateway.discovery.operations.edit(operation_id, *, zone_id, **params) -> OperationEditResponse

Operations

Types:

from cloudflare.types.api_gateway import (
    APIShield,
    OperationCreateResponse,
    OperationListResponse,
    OperationDeleteResponse,
    OperationBulkCreateResponse,
    OperationBulkDeleteResponse,
    OperationGetResponse,
)

Methods:

client.api_gateway.operations.create(*, zone_id, **params) -> OperationCreateResponse
client.api_gateway.operations.list(*, zone_id, **params) -> SyncV4PagePaginationArray[OperationListResponse]
client.api_gateway.operations.delete(operation_id, *, zone_id) -> OperationDeleteResponse
client.api_gateway.operations.bulk_create(*, zone_id, **params) -> SyncSinglePage[OperationBulkCreateResponse]
client.api_gateway.operations.bulk_delete(*, zone_id) -> OperationBulkDeleteResponse
client.api_gateway.operations.get(operation_id, *, zone_id, **params) -> OperationGetResponse

SchemaValidation

Types:

from cloudflare.types.api_gateway.operations import (
    SettingsMultipleRequest,
    SchemaValidationUpdateResponse,
    SchemaValidationGetResponse,
)

Methods:

client.api_gateway.operations.schema_validation.update(operation_id, *, zone_id, **params) -> SchemaValidationUpdateResponse
client.api_gateway.operations.schema_validation.edit(*, zone_id, **params) -> SettingsMultipleRequest
client.api_gateway.operations.schema_validation.get(operation_id, *, zone_id) -> SchemaValidationGetResponse

Schemas

Types:

from cloudflare.types.api_gateway import SchemaListResponse

Methods:

client.api_gateway.schemas.list(*, zone_id, **params) -> SchemaListResponse

Settings

Types:

from cloudflare.types.api_gateway import Settings

SchemaValidation

Methods:

client.api_gateway.settings.schema_validation.update(*, zone_id, **params) -> Settings
client.api_gateway.settings.schema_validation.edit(*, zone_id, **params) -> Settings
client.api_gateway.settings.schema_validation.get(*, zone_id) -> Settings

UserSchemas

Types:

from cloudflare.types.api_gateway import (
    Message,
    PublicSchema,
    SchemaUpload,
    UserSchemaDeleteResponse,
)

Methods:

client.api_gateway.user_schemas.create(*, zone_id, **params) -> SchemaUpload
client.api_gateway.user_schemas.list(*, zone_id, **params) -> SyncV4PagePaginationArray[PublicSchema]
client.api_gateway.user_schemas.delete(schema_id, *, zone_id) -> UserSchemaDeleteResponse
client.api_gateway.user_schemas.edit(schema_id, *, zone_id, **params) -> PublicSchema
client.api_gateway.user_schemas.get(schema_id, *, zone_id, **params) -> PublicSchema

Operations

Types:

from cloudflare.types.api_gateway.user_schemas import OperationListResponse

Methods:

client.api_gateway.user_schemas.operations.list(schema_id, *, zone_id, **params) -> SyncV4PagePaginationArray[OperationListResponse]

Hosts

Types:

from cloudflare.types.api_gateway.user_schemas import HostListResponse

Methods:

client.api_gateway.user_schemas.hosts.list(*, zone_id, **params) -> SyncV4PagePaginationArray[HostListResponse]

ExpressionTemplate

Fallthrough

Types:

from cloudflare.types.api_gateway.expression_template import FallthroughCreateResponse

Methods:

client.api_gateway.expression_template.fallthrough.create(*, zone_id, **params) -> FallthroughCreateResponse

ManagedTransforms

Types:

from cloudflare.types.managed_transforms import (
    ManagedTransformListResponse,
    ManagedTransformEditResponse,
)

Methods:

client.managed_transforms.list(*, zone_id) -> ManagedTransformListResponse
client.managed_transforms.delete(*, zone_id) -> None
client.managed_transforms.edit(*, zone_id, **params) -> ManagedTransformEditResponse

PageShield

Types:

from cloudflare.types.page_shield import Setting, PageShieldUpdateResponse

Methods:

client.page_shield.update(*, zone_id, **params) -> Optional[PageShieldUpdateResponse]
client.page_shield.get(*, zone_id) -> Optional[Setting]

Policies

Types:

from cloudflare.types.page_shield import (
    Policy,
    PolicyCreateResponse,
    PolicyUpdateResponse,
    PolicyListResponse,
    PolicyGetResponse,
)

Methods:

client.page_shield.policies.create(*, zone_id, **params) -> Optional[PolicyCreateResponse]
client.page_shield.policies.update(policy_id, *, zone_id, **params) -> Optional[PolicyUpdateResponse]
client.page_shield.policies.list(*, zone_id) -> SyncSinglePage[PolicyListResponse]
client.page_shield.policies.delete(policy_id, *, zone_id) -> None
client.page_shield.policies.get(policy_id, *, zone_id) -> Optional[PolicyGetResponse]

Connections

Types:

from cloudflare.types.page_shield import Connection

Methods:

client.page_shield.connections.list(*, zone_id, **params) -> SyncSinglePage[Connection]
client.page_shield.connections.get(connection_id, *, zone_id) -> Optional[Connection]

Scripts

Types:

from cloudflare.types.page_shield import Script, ScriptGetResponse

Methods:

client.page_shield.scripts.list(*, zone_id, **params) -> SyncSinglePage[Script]
client.page_shield.scripts.get(script_id, *, zone_id) -> Optional[ScriptGetResponse]

Cookies

Types:

from cloudflare.types.page_shield import CookieListResponse, CookieGetResponse

Methods:

client.page_shield.cookies.list(*, zone_id, **params) -> SyncSinglePage[CookieListResponse]
client.page_shield.cookies.get(cookie_id, *, zone_id) -> Optional[CookieGetResponse]

Rulesets

Types:

from cloudflare.types.rulesets import (
    Kind,
    Phase,
    Ruleset,
    RulesetCreateResponse,
    RulesetUpdateResponse,
    RulesetListResponse,
    RulesetGetResponse,
)

Methods:

client.rulesets.create(*, account_id, zone_id, **params) -> RulesetCreateResponse
client.rulesets.update(ruleset_id, *, account_id, zone_id, **params) -> RulesetUpdateResponse
client.rulesets.list(*, account_id, zone_id, **params) -> SyncCursorPagination[RulesetListResponse]
client.rulesets.delete(ruleset_id, *, account_id, zone_id) -> None
client.rulesets.get(ruleset_id, *, account_id, zone_id) -> RulesetGetResponse

Phases

Types:

from cloudflare.types.rulesets import PhaseUpdateResponse, PhaseGetResponse

Methods:

client.rulesets.phases.update(ruleset_phase, *, account_id, zone_id, **params) -> PhaseUpdateResponse
client.rulesets.phases.get(ruleset_phase, *, account_id, zone_id) -> PhaseGetResponse

Versions

Types:

from cloudflare.types.rulesets.phases import VersionListResponse, VersionGetResponse

Methods:

client.rulesets.phases.versions.list(ruleset_phase, *, account_id, zone_id) -> SyncSinglePage[VersionListResponse]
client.rulesets.phases.versions.get(ruleset_version, *, ruleset_phase, account_id, zone_id) -> VersionGetResponse

Rules

Types:

from cloudflare.types.rulesets import (
    BlockRule,
    CompressResponseRule,
    DDoSDynamicRule,
    ExecuteRule,
    ForceConnectionCloseRule,
    LogCustomFieldRule,
    LogRule,
    Logging,
    ManagedChallengeRule,
    RedirectRule,
    RewriteRule,
    RewriteURIPart,
    RouteRule,
    RulesetRule,
    ScoreRule,
    ServeErrorRule,
    SetCacheSettingsRule,
    SetConfigRule,
    SkipRule,
    RuleCreateResponse,
    RuleDeleteResponse,
    RuleEditResponse,
)

Methods:

client.rulesets.rules.create(ruleset_id, *, account_id, zone_id, **params) -> RuleCreateResponse
client.rulesets.rules.delete(rule_id, *, ruleset_id, account_id, zone_id) -> RuleDeleteResponse
client.rulesets.rules.edit(rule_id, *, ruleset_id, account_id, zone_id, **params) -> RuleEditResponse

Versions

Types:

from cloudflare.types.rulesets import VersionListResponse, VersionGetResponse

Methods:

client.rulesets.versions.list(ruleset_id, *, account_id, zone_id) -> SyncSinglePage[VersionListResponse]
client.rulesets.versions.delete(ruleset_version, *, ruleset_id, account_id, zone_id) -> None
client.rulesets.versions.get(ruleset_version, *, ruleset_id, account_id, zone_id) -> VersionGetResponse

URLNormalization

Types:

from cloudflare.types.url_normalization import (
    URLNormalizationUpdateResponse,
    URLNormalizationGetResponse,
)

Methods:

client.url_normalization.update(*, zone_id, **params) -> URLNormalizationUpdateResponse
client.url_normalization.delete(*, zone_id) -> None
client.url_normalization.get(*, zone_id) -> URLNormalizationGetResponse

Spectrum

Types:

from cloudflare.types.spectrum import DNS, EdgeIPs, OriginDNS, OriginPort

Analytics

Aggregates

Currents

Types:

from cloudflare.types.spectrum.analytics.aggregates import CurrentGetResponse

Methods:

client.spectrum.analytics.aggregates.currents.get(*, zone_id, **params) -> Optional[CurrentGetResponse]

Events

Types:

from cloudflare.types.spectrum.analytics import Dimension

Bytimes

Types:

from cloudflare.types.spectrum.analytics.events import BytimeGetResponse

Methods:

client.spectrum.analytics.events.bytimes.get(*, zone_id, **params) -> Optional[BytimeGetResponse]

Summaries

Types:

from cloudflare.types.spectrum.analytics.events import SummaryGetResponse

Methods:

client.spectrum.analytics.events.summaries.get(*, zone_id, **params) -> Optional[SummaryGetResponse]

Apps

Types:

from cloudflare.types.spectrum import (
    AppCreateResponse,
    AppUpdateResponse,
    AppListResponse,
    AppDeleteResponse,
    AppGetResponse,
)

Methods:

client.spectrum.apps.create(*, zone_id, **params) -> Optional[AppCreateResponse]
client.spectrum.apps.update(app_id, *, zone_id, **params) -> Optional[AppUpdateResponse]
client.spectrum.apps.list(*, zone_id, **params) -> SyncV4PagePaginationArray[Optional[AppListResponse]]
client.spectrum.apps.delete(app_id, *, zone_id) -> Optional[AppDeleteResponse]
client.spectrum.apps.get(app_id, *, zone_id) -> Optional[AppGetResponse]

Addressing

RegionalHostnames

Types:

from cloudflare.types.addressing import (
    RegionalHostnameCreateResponse,
    RegionalHostnameListResponse,
    RegionalHostnameDeleteResponse,
    RegionalHostnameEditResponse,
    RegionalHostnameGetResponse,
)

Methods:

client.addressing.regional_hostnames.create(*, zone_id, **params) -> Optional[RegionalHostnameCreateResponse]
client.addressing.regional_hostnames.list(*, zone_id) -> SyncSinglePage[RegionalHostnameListResponse]
client.addressing.regional_hostnames.delete(hostname, *, zone_id) -> RegionalHostnameDeleteResponse
client.addressing.regional_hostnames.edit(hostname, *, zone_id, **params) -> Optional[RegionalHostnameEditResponse]
client.addressing.regional_hostnames.get(hostname, *, zone_id) -> Optional[RegionalHostnameGetResponse]

Regions

Types:

from cloudflare.types.addressing.regional_hostnames import RegionListResponse

Methods:

client.addressing.regional_hostnames.regions.list(*, account_id) -> SyncSinglePage[RegionListResponse]

Services

Types:

from cloudflare.types.addressing import ServiceListResponse

Methods:

client.addressing.services.list(*, account_id) -> SyncSinglePage[ServiceListResponse]

AddressMaps

Types:

from cloudflare.types.addressing import (
    AddressMap,
    Kind,
    AddressMapCreateResponse,
    AddressMapDeleteResponse,
    AddressMapGetResponse,
)

Methods:

client.addressing.address_maps.create(*, account_id, **params) -> Optional[AddressMapCreateResponse]
client.addressing.address_maps.list(*, account_id) -> SyncSinglePage[AddressMap]
client.addressing.address_maps.delete(address_map_id, *, account_id) -> AddressMapDeleteResponse
client.addressing.address_maps.edit(address_map_id, *, account_id, **params) -> Optional[AddressMap]
client.addressing.address_maps.get(address_map_id, *, account_id) -> Optional[AddressMapGetResponse]

Accounts

Types:

from cloudflare.types.addressing.address_maps import AccountUpdateResponse, AccountDeleteResponse

Methods:

client.addressing.address_maps.accounts.update(address_map_id, *, account_id, **params) -> AccountUpdateResponse
client.addressing.address_maps.accounts.delete(address_map_id, *, account_id) -> AccountDeleteResponse

IPs

Types:

from cloudflare.types.addressing.address_maps import IPUpdateResponse, IPDeleteResponse

Methods:

client.addressing.address_maps.ips.update(ip_address, *, account_id, address_map_id, **params) -> IPUpdateResponse
client.addressing.address_maps.ips.delete(ip_address, *, account_id, address_map_id) -> IPDeleteResponse

Zones

Types:

from cloudflare.types.addressing.address_maps import ZoneUpdateResponse, ZoneDeleteResponse

Methods:

client.addressing.address_maps.zones.update(address_map_id, *, zone_id, account_id, **params) -> ZoneUpdateResponse
client.addressing.address_maps.zones.delete(address_map_id, *, zone_id, account_id) -> ZoneDeleteResponse

LOADocuments

Types:

from cloudflare.types.addressing import LOADocumentCreateResponse

Methods:

client.addressing.loa_documents.create(*, account_id, **params) -> Optional[LOADocumentCreateResponse]
client.addressing.loa_documents.get(loa_document_id, *, account_id) -> BinaryAPIResponse

Prefixes

Types:

from cloudflare.types.addressing import Prefix, PrefixDeleteResponse

Methods:

client.addressing.prefixes.create(*, account_id, **params) -> Optional[Prefix]
client.addressing.prefixes.list(*, account_id) -> SyncSinglePage[Prefix]
client.addressing.prefixes.delete(prefix_id, *, account_id) -> PrefixDeleteResponse
client.addressing.prefixes.edit(prefix_id, *, account_id, **params) -> Optional[Prefix]
client.addressing.prefixes.get(prefix_id, *, account_id) -> Optional[Prefix]

ServiceBindings

Types:

from cloudflare.types.addressing.prefixes import ServiceBinding, ServiceBindingDeleteResponse

Methods:

client.addressing.prefixes.service_bindings.create(prefix_id, *, account_id, **params) -> Optional[ServiceBinding]
client.addressing.prefixes.service_bindings.list(prefix_id, *, account_id) -> SyncSinglePage[ServiceBinding]
client.addressing.prefixes.service_bindings.delete(binding_id, *, account_id, prefix_id) -> ServiceBindingDeleteResponse
client.addressing.prefixes.service_bindings.get(binding_id, *, account_id, prefix_id) -> Optional[ServiceBinding]

BGPPrefixes

Types:

from cloudflare.types.addressing.prefixes import BGPPrefix

Methods:

client.addressing.prefixes.bgp_prefixes.create(prefix_id, *, account_id, **params) -> Optional[BGPPrefix]
client.addressing.prefixes.bgp_prefixes.list(prefix_id, *, account_id) -> SyncSinglePage[BGPPrefix]
client.addressing.prefixes.bgp_prefixes.edit(bgp_prefix_id, *, account_id, prefix_id, **params) -> Optional[BGPPrefix]
client.addressing.prefixes.bgp_prefixes.get(bgp_prefix_id, *, account_id, prefix_id) -> Optional[BGPPrefix]

AdvertisementStatus

Types:

from cloudflare.types.addressing.prefixes import (
    AdvertisementStatusEditResponse,
    AdvertisementStatusGetResponse,
)

Methods:

client.addressing.prefixes.advertisement_status.edit(prefix_id, *, account_id, **params) -> Optional[AdvertisementStatusEditResponse]
client.addressing.prefixes.advertisement_status.get(prefix_id, *, account_id) -> Optional[AdvertisementStatusGetResponse]

Delegations

Types:

from cloudflare.types.addressing.prefixes import Delegations, DelegationDeleteResponse

Methods:

client.addressing.prefixes.delegations.create(prefix_id, *, account_id, **params) -> Optional[Delegations]
client.addressing.prefixes.delegations.list(prefix_id, *, account_id) -> SyncSinglePage[Delegations]
client.addressing.prefixes.delegations.delete(delegation_id, *, account_id, prefix_id) -> Optional[DelegationDeleteResponse]

AuditLogs

Methods:

client.audit_logs.list(*, account_id, **params) -> SyncV4PagePaginationArray[AuditLog]

Billing

Profiles

Types:

from cloudflare.types.billing import ProfileGetResponse

Methods:

client.billing.profiles.get(*, account_id) -> ProfileGetResponse

BrandProtection

Types:

from cloudflare.types.brand_protection import (
    Info,
    RuleMatch,
    ScanStatus,
    Submit,
    URLInfoModelResults,
)

Methods:

client.brand_protection.submit(*, account_id, **params) -> Optional[Submit]
client.brand_protection.url_info(*, account_id, **params) -> Optional[Info]

Diagnostics

Traceroutes

Types:

from cloudflare.types.diagnostics import Traceroute

Methods:

client.diagnostics.traceroutes.create(*, account_id, **params) -> SyncSinglePage[Traceroute]

Images

V1

Types:

from cloudflare.types.images import Image, V1ListResponse, V1DeleteResponse

Methods:

client.images.v1.create(*, account_id, **params) -> Image
client.images.v1.list(*, account_id, **params) -> SyncV4PagePagination[V1ListResponse]
client.images.v1.delete(image_id, *, account_id) -> V1DeleteResponse
client.images.v1.edit(image_id, *, account_id, **params) -> Image
client.images.v1.get(image_id, *, account_id) -> Image

Keys

Types:

from cloudflare.types.images.v1 import Key, KeyUpdateResponse, KeyListResponse, KeyDeleteResponse

Methods:

client.images.v1.keys.update(signing_key_name, *, account_id) -> KeyUpdateResponse
client.images.v1.keys.list(*, account_id) -> KeyListResponse
client.images.v1.keys.delete(signing_key_name, *, account_id) -> KeyDeleteResponse

Stats

Types:

from cloudflare.types.images.v1 import Stat

Methods:

client.images.v1.stats.get(*, account_id) -> Stat

Variants

Types:

from cloudflare.types.images.v1 import (
    Variant,
    VariantCreateResponse,
    VariantDeleteResponse,
    VariantEditResponse,
    VariantGetResponse,
)

Methods:

client.images.v1.variants.create(*, account_id, **params) -> VariantCreateResponse
client.images.v1.variants.list(*, account_id) -> Variant
client.images.v1.variants.delete(variant_id, *, account_id) -> VariantDeleteResponse
client.images.v1.variants.edit(variant_id, *, account_id, **params) -> VariantEditResponse
client.images.v1.variants.get(variant_id, *, account_id) -> VariantGetResponse

Blobs

Methods:

client.images.v1.blobs.get(image_id, *, account_id) -> BinaryAPIResponse

V2

Types:

from cloudflare.types.images import V2ListResponse

Methods:

client.images.v2.list(*, account_id, **params) -> V2ListResponse

DirectUploads

Types:

from cloudflare.types.images.v2 import DirectUploadCreateResponse

Methods:

client.images.v2.direct_uploads.create(*, account_id, **params) -> DirectUploadCreateResponse

Intel

ASN

Methods:

client.intel.asn.get(asn, *, account_id) -> Optional[ASN]

Subnets

Types:

from cloudflare.types.intel.asn import SubnetGetResponse

Methods:

client.intel.asn.subnets.get(asn, *, account_id) -> SubnetGetResponse

DNS

Types:

from cloudflare.types.intel import DNS

Methods:

client.intel.dns.list(*, account_id, **params) -> SyncV4PagePagination[Optional[DNS]]

Domains

Types:

from cloudflare.types.intel import Domain

Methods:

client.intel.domains.get(*, account_id, **params) -> Optional[Domain]

Bulks

Types:

from cloudflare.types.intel.domains import BulkGetResponse

Methods:

client.intel.domains.bulks.get(*, account_id, **params) -> Optional[BulkGetResponse]

DomainHistory

Types:

from cloudflare.types.intel import DomainHistory, DomainHistoryGetResponse

Methods:

client.intel.domain_history.get(*, account_id, **params) -> Optional[DomainHistoryGetResponse]

IPs

Types:

from cloudflare.types.intel import IP, IPGetResponse

Methods:

client.intel.ips.get(*, account_id, **params) -> Optional[IPGetResponse]

IPLists

Types:

from cloudflare.types.intel import IPList

Methods:

client.intel.ip_lists.get(*, account_id) -> SyncSinglePage[IPList]

Miscategorizations

Types:

from cloudflare.types.intel import MiscategorizationCreateResponse

Methods:

client.intel.miscategorizations.create(*, account_id, **params) -> MiscategorizationCreateResponse

Whois

Types:

from cloudflare.types.intel import Whois, WhoisGetResponse

Methods:

client.intel.whois.get(*, account_id, **params) -> Optional[WhoisGetResponse]

IndicatorFeeds

Types:

from cloudflare.types.intel import (
    IndicatorFeedCreateResponse,
    IndicatorFeedUpdateResponse,
    IndicatorFeedListResponse,
    IndicatorFeedDataResponse,
    IndicatorFeedGetResponse,
)

Methods:

client.intel.indicator_feeds.create(*, account_id, **params) -> Optional[IndicatorFeedCreateResponse]
client.intel.indicator_feeds.update(feed_id, *, account_id, **params) -> Optional[IndicatorFeedUpdateResponse]
client.intel.indicator_feeds.list(*, account_id) -> SyncSinglePage[IndicatorFeedListResponse]
client.intel.indicator_feeds.data(feed_id, *, account_id) -> str
client.intel.indicator_feeds.get(feed_id, *, account_id) -> Optional[IndicatorFeedGetResponse]

Snapshots

Types:

from cloudflare.types.intel.indicator_feeds import SnapshotUpdateResponse

Methods:

client.intel.indicator_feeds.snapshots.update(feed_id, *, account_id, **params) -> Optional[SnapshotUpdateResponse]

Permissions

Types:

from cloudflare.types.intel.indicator_feeds import (
    PermissionCreateResponse,
    PermissionListResponse,
    PermissionDeleteResponse,
)

Methods:

client.intel.indicator_feeds.permissions.create(*, account_id, **params) -> Optional[PermissionCreateResponse]
client.intel.indicator_feeds.permissions.list(*, account_id) -> Optional[PermissionListResponse]
client.intel.indicator_feeds.permissions.delete(*, account_id, **params) -> Optional[PermissionDeleteResponse]

Downloads

Types:

from cloudflare.types.intel.indicator_feeds import DownloadGetResponse

Methods:

client.intel.indicator_feeds.downloads.get(feed_id, *, account_id) -> Optional[DownloadGetResponse]

Sinkholes

Types:

from cloudflare.types.intel import Sinkhole

Methods:

client.intel.sinkholes.list(*, account_id) -> SyncSinglePage[Sinkhole]

AttackSurfaceReport

IssueTypes

Types:

from cloudflare.types.intel.attack_surface_report import IssueTypeGetResponse

Methods:

client.intel.attack_surface_report.issue_types.get(*, account_id) -> SyncSinglePage[IssueTypeGetResponse]

Issues

Types:

from cloudflare.types.intel.attack_surface_report import (
    IssueType,
    SeverityQueryParam,
    IssueListResponse,
    IssueClassResponse,
    IssueDismissResponse,
    IssueSeverityResponse,
    IssueTypeResponse,
)

Methods:

client.intel.attack_surface_report.issues.list(*, account_id, **params) -> SyncV4PagePagination[Optional[IssueListResponse]]
client.intel.attacksurface_report.issues.class(*, account_id, **params) -> Optional[IssueClassResponse]
client.intel.attack_surface_report.issues.dismiss(issue_id, *, account_id, **params) -> IssueDismissResponse
client.intel.attack_surface_report.issues.severity(*, account_id, **params) -> Optional[IssueSeverityResponse]
client.intel.attack_surface_report.issues.type(*, account_id, **params) -> Optional[IssueTypeResponse]

MagicTransit

Types:

from cloudflare.types.magic_transit import HealthCheck, HealthCheckRate, HealthCheckType

Apps

Types:

from cloudflare.types.magic_transit import (
    AppCreateResponse,
    AppUpdateResponse,
    AppListResponse,
    AppDeleteResponse,
)

Methods:

client.magic_transit.apps.create(*, account_id, **params) -> Optional[AppCreateResponse]
client.magic_transit.apps.update(account_app_id, *, account_id, **params) -> Optional[AppUpdateResponse]
client.magic_transit.apps.list(*, account_id) -> SyncSinglePage[AppListResponse]
client.magic_transit.apps.delete(account_app_id, *, account_id) -> Optional[AppDeleteResponse]

CfInterconnects

Types:

from cloudflare.types.magic_transit import (
    CfInterconnectUpdateResponse,
    CfInterconnectListResponse,
    CfInterconnectBulkUpdateResponse,
    CfInterconnectGetResponse,
)

Methods:

client.magic_transit.cf_interconnects.update(cf_interconnect_id, *, account_id, **params) -> CfInterconnectUpdateResponse
client.magic_transit.cf_interconnects.list(*, account_id) -> CfInterconnectListResponse
client.magic_transit.cf_interconnects.bulk_update(*, account_id, **params) -> CfInterconnectBulkUpdateResponse
client.magic_transit.cf_interconnects.get(cf_interconnect_id, *, account_id) -> CfInterconnectGetResponse

GRETunnels

Types:

from cloudflare.types.magic_transit import (
    GRETunnelCreateResponse,
    GRETunnelUpdateResponse,
    GRETunnelListResponse,
    GRETunnelDeleteResponse,
    GRETunnelBulkUpdateResponse,
    GRETunnelGetResponse,
)

Methods:

client.magic_transit.gre_tunnels.create(*, account_id, **params) -> GRETunnelCreateResponse
client.magic_transit.gre_tunnels.update(gre_tunnel_id, *, account_id, **params) -> GRETunnelUpdateResponse
client.magic_transit.gre_tunnels.list(*, account_id) -> GRETunnelListResponse
client.magic_transit.gre_tunnels.delete(gre_tunnel_id, *, account_id) -> GRETunnelDeleteResponse
client.magic_transit.gre_tunnels.bulk_update(*, account_id, **params) -> GRETunnelBulkUpdateResponse
client.magic_transit.gre_tunnels.get(gre_tunnel_id, *, account_id) -> GRETunnelGetResponse

IPSECTunnels

Types:

from cloudflare.types.magic_transit import (
    PSKMetadata,
    IPSECTunnelCreateResponse,
    IPSECTunnelUpdateResponse,
    IPSECTunnelListResponse,
    IPSECTunnelDeleteResponse,
    IPSECTunnelBulkUpdateResponse,
    IPSECTunnelGetResponse,
    IPSECTunnelPSKGenerateResponse,
)

Methods:

client.magic_transit.ipsec_tunnels.create(*, account_id, **params) -> IPSECTunnelCreateResponse
client.magic_transit.ipsec_tunnels.update(ipsec_tunnel_id, *, account_id, **params) -> IPSECTunnelUpdateResponse
client.magic_transit.ipsec_tunnels.list(*, account_id) -> IPSECTunnelListResponse
client.magic_transit.ipsec_tunnels.delete(ipsec_tunnel_id, *, account_id) -> IPSECTunnelDeleteResponse
client.magic_transit.ipsec_tunnels.bulk_update(*, account_id, **params) -> IPSECTunnelBulkUpdateResponse
client.magic_transit.ipsec_tunnels.get(ipsec_tunnel_id, *, account_id) -> IPSECTunnelGetResponse
client.magic_transit.ipsec_tunnels.psk_generate(ipsec_tunnel_id, *, account_id, **params) -> IPSECTunnelPSKGenerateResponse

Routes

Types:

from cloudflare.types.magic_transit import (
    Scope,
    RouteCreateResponse,
    RouteUpdateResponse,
    RouteListResponse,
    RouteDeleteResponse,
    RouteBulkUpdateResponse,
    RouteEmptyResponse,
    RouteGetResponse,
)

Methods:

client.magic_transit.routes.create(*, account_id, **params) -> RouteCreateResponse
client.magic_transit.routes.update(route_id, *, account_id, **params) -> RouteUpdateResponse
client.magic_transit.routes.list(*, account_id) -> RouteListResponse
client.magic_transit.routes.delete(route_id, *, account_id) -> RouteDeleteResponse
client.magic_transit.routes.bulk_update(*, account_id, **params) -> RouteBulkUpdateResponse
client.magic_transit.routes.empty(*, account_id) -> RouteEmptyResponse
client.magic_transit.routes.get(route_id, *, account_id) -> RouteGetResponse

Sites

Types:

from cloudflare.types.magic_transit import Site, SiteLocation

Methods:

client.magic_transit.sites.create(*, account_id, **params) -> Site
client.magic_transit.sites.update(site_id, *, account_id, **params) -> Site
client.magic_transit.sites.list(*, account_id, **params) -> SyncSinglePage[Site]
client.magic_transit.sites.delete(site_id, *, account_id) -> Site
client.magic_transit.sites.edit(site_id, *, account_id, **params) -> Site
client.magic_transit.sites.get(site_id, *, account_id) -> Site

ACLs

Types:

from cloudflare.types.magic_transit.sites import ACL, ACLConfiguration, AllowedProtocol, Subnet

Methods:

client.magic_transit.sites.acls.create(site_id, *, account_id, **params) -> ACL
client.magic_transit.sites.acls.update(acl_id, *, account_id, site_id, **params) -> ACL
client.magic_transit.sites.acls.list(site_id, *, account_id) -> SyncSinglePage[ACL]
client.magic_transit.sites.acls.delete(acl_id, *, account_id, site_id) -> ACL
client.magic_transit.sites.acls.edit(acl_id, *, account_id, site_id, **params) -> ACL
client.magic_transit.sites.acls.get(acl_id, *, account_id, site_id) -> ACL

LANs

Types:

from cloudflare.types.magic_transit.sites import (
    DHCPRelay,
    DHCPServer,
    LAN,
    LANStaticAddressing,
    Nat,
    RoutedSubnet,
)

Methods:

client.magic_transit.sites.lans.create(site_id, *, account_id, **params) -> SyncSinglePage[LAN]
client.magic_transit.sites.lans.update(lan_id, *, account_id, site_id, **params) -> LAN
client.magic_transit.sites.lans.list(site_id, *, account_id) -> SyncSinglePage[LAN]
client.magic_transit.sites.lans.delete(lan_id, *, account_id, site_id) -> LAN
client.magic_transit.sites.lans.edit(lan_id, *, account_id, site_id, **params) -> LAN
client.magic_transit.sites.lans.get(lan_id, *, account_id, site_id) -> LAN

WANs

Types:

from cloudflare.types.magic_transit.sites import WAN, WANStaticAddressing

Methods:

client.magic_transit.sites.wans.create(site_id, *, account_id, **params) -> SyncSinglePage[WAN]
client.magic_transit.sites.wans.update(wan_id, *, account_id, site_id, **params) -> WAN
client.magic_transit.sites.wans.list(site_id, *, account_id) -> SyncSinglePage[WAN]
client.magic_transit.sites.wans.delete(wan_id, *, account_id, site_id) -> WAN
client.magic_transit.sites.wans.edit(wan_id, *, account_id, site_id, **params) -> WAN
client.magic_transit.sites.wans.get(wan_id, *, account_id, site_id) -> WAN

Connectors

Types:

from cloudflare.types.magic_transit import (
    ConnectorUpdateResponse,
    ConnectorListResponse,
    ConnectorEditResponse,
    ConnectorGetResponse,
)

Methods:

client.magic_transit.connectors.update(connector_id, *, account_id, **params) -> ConnectorUpdateResponse
client.magic_transit.connectors.list(*, account_id) -> SyncSinglePage[ConnectorListResponse]
client.magic_transit.connectors.edit(connector_id, *, account_id, **params) -> ConnectorEditResponse
client.magic_transit.connectors.get(connector_id, *, account_id) -> ConnectorGetResponse

Events

Types:

from cloudflare.types.magic_transit.connectors import EventListResponse, EventGetResponse

Methods:

client.magic_transit.connectors.events.list(connector_id, *, account_id, **params) -> EventListResponse
client.magic_transit.connectors.events.get(event_n, *, account_id, connector_id, event_t) -> EventGetResponse

Snapshots

Types:

from cloudflare.types.magic_transit.connectors import SnapshotListResponse, SnapshotGetResponse

Methods:

client.magic_transit.connectors.snapshots.list(connector_id, *, account_id, **params) -> SnapshotListResponse
client.magic_transit.connectors.snapshots.get(snapshot_t, *, account_id, connector_id) -> SnapshotGetResponse

PCAPs

Types:

from cloudflare.types.magic_transit import (
    PCAP,
    PCAPFilter,
    PCAPCreateResponse,
    PCAPListResponse,
    PCAPGetResponse,
)

Methods:

client.magic_transit.pcaps.create(*, account_id, **params) -> PCAPCreateResponse
client.magic_transit.pcaps.list(*, account_id) -> SyncSinglePage[PCAPListResponse]
client.magic_transit.pcaps.get(pcap_id, *, account_id) -> PCAPGetResponse

Ownership

Types:

from cloudflare.types.magic_transit.pcaps import Ownership

Methods:

client.magic_transit.pcaps.ownership.create(*, account_id, **params) -> Ownership
client.magic_transit.pcaps.ownership.delete(ownership_id, *, account_id) -> None
client.magic_transit.pcaps.ownership.get(*, account_id) -> SyncSinglePage[Ownership]
client.magic_transit.pcaps.ownership.validate(*, account_id, **params) -> Ownership

Download

Methods:

client.magic_transit.pcaps.download.get(pcap_id, *, account_id) -> BinaryAPIResponse

MagicNetworkMonitoring

VPCFlows

Tokens

Types:

from cloudflare.types.magic_network_monitoring.vpc_flows import TokenCreateResponse

Methods:

client.magic_network_monitoring.vpc_flows.tokens.create(*, account_id) -> str

Configs

Types:

from cloudflare.types.magic_network_monitoring import Configuration

Methods:

client.magic_network_monitoring.configs.create(*, account_id, **params) -> Configuration
client.magic_network_monitoring.configs.update(*, account_id, **params) -> Configuration
client.magic_network_monitoring.configs.delete(*, account_id) -> Configuration
client.magic_network_monitoring.configs.edit(*, account_id, **params) -> Configuration
client.magic_network_monitoring.configs.get(*, account_id) -> Configuration

Full

Methods:

client.magic_network_monitoring.configs.full.get(*, account_id) -> Configuration

Rules

Types:

from cloudflare.types.magic_network_monitoring import MagicNetworkMonitoringRule

Methods:

client.magic_network_monitoring.rules.create(*, account_id, **params) -> Optional[MagicNetworkMonitoringRule]
client.magic_network_monitoring.rules.update(*, account_id, **params) -> Optional[MagicNetworkMonitoringRule]
client.magic_network_monitoring.rules.list(*, account_id) -> SyncSinglePage[Optional[MagicNetworkMonitoringRule]]
client.magic_network_monitoring.rules.delete(rule_id, *, account_id) -> Optional[MagicNetworkMonitoringRule]
client.magic_network_monitoring.rules.edit(rule_id, *, account_id, **params) -> Optional[MagicNetworkMonitoringRule]
client.magic_network_monitoring.rules.get(rule_id, *, account_id) -> Optional[MagicNetworkMonitoringRule]

MagicCloudNetworking

CatalogSyncs

Types:

from cloudflare.types.magic_cloud_networking import (
    CatalogSyncCreateResponse,
    CatalogSyncUpdateResponse,
    CatalogSyncListResponse,
    CatalogSyncDeleteResponse,
    CatalogSyncEditResponse,
    CatalogSyncGetResponse,
    CatalogSyncRefreshResponse,
)

Methods:

client.magic_cloud_networking.catalog_syncs.create(*, account_id, **params) -> CatalogSyncCreateResponse
client.magic_cloud_networking.catalog_syncs.update(sync_id, *, account_id, **params) -> CatalogSyncUpdateResponse
client.magic_cloud_networking.catalog_syncs.list(*, account_id) -> SyncSinglePage[CatalogSyncListResponse]
client.magic_cloud_networking.catalog_syncs.delete(sync_id, *, account_id, **params) -> CatalogSyncDeleteResponse
client.magic_cloud_networking.catalog_syncs.edit(sync_id, *, account_id, **params) -> CatalogSyncEditResponse
client.magic_cloud_networking.catalog_syncs.get(sync_id, *, account_id) -> CatalogSyncGetResponse
client.magic_cloud_networking.catalog_syncs.refresh(sync_id, *, account_id) -> str

PrebuiltPolicies

Types:

from cloudflare.types.magic_cloud_networking.catalog_syncs import PrebuiltPolicyListResponse

Methods:

client.magic_cloud_networking.catalog_syncs.prebuilt_policies.list(*, account_id, **params) -> SyncSinglePage[PrebuiltPolicyListResponse]

OnRamps

Types:

from cloudflare.types.magic_cloud_networking import (
    OnRampCreateResponse,
    OnRampUpdateResponse,
    OnRampListResponse,
    OnRampDeleteResponse,
    OnRampApplyResponse,
    OnRampEditResponse,
    OnRampGetResponse,
    OnRampPlanResponse,
)

Methods:

client.magic_cloud_networking.on_ramps.create(*, account_id, **params) -> OnRampCreateResponse
client.magic_cloud_networking.on_ramps.update(onramp_id, *, account_id, **params) -> OnRampUpdateResponse
client.magic_cloud_networking.on_ramps.list(*, account_id, **params) -> SyncSinglePage[OnRampListResponse]
client.magic_cloud_networking.on_ramps.delete(onramp_id, *, account_id, **params) -> OnRampDeleteResponse
client.magic_cloud_networking.on_ramps.apply(onramp_id, *, account_id) -> OnRampApplyResponse
client.magic_cloud_networking.on_ramps.edit(onramp_id, *, account_id, **params) -> OnRampEditResponse
client.magic_cloud_networking.on_ramps.export(onramp_id, *, account_id) -> BinaryAPIResponse
client.magic_cloud_networking.on_ramps.get(onramp_id, *, account_id, **params) -> OnRampGetResponse
client.magic_cloud_networking.on_ramps.plan(onramp_id, *, account_id) -> OnRampPlanResponse

AddressSpaces

Types:

from cloudflare.types.magic_cloud_networking.on_ramps import (
    AddressSpaceUpdateResponse,
    AddressSpaceListResponse,
    AddressSpaceEditResponse,
)

Methods:

client.magic_cloud_networking.on_ramps.address_spaces.update(*, account_id, **params) -> AddressSpaceUpdateResponse
client.magic_cloud_networking.on_ramps.address_spaces.list(*, account_id) -> AddressSpaceListResponse
client.magic_cloud_networking.on_ramps.address_spaces.edit(*, account_id, **params) -> AddressSpaceEditResponse

CloudIntegrations

Types:

from cloudflare.types.magic_cloud_networking import (
    CloudIntegrationCreateResponse,
    CloudIntegrationUpdateResponse,
    CloudIntegrationListResponse,
    CloudIntegrationDeleteResponse,
    CloudIntegrationDiscoverResponse,
    CloudIntegrationDiscoverAllResponse,
    CloudIntegrationEditResponse,
    CloudIntegrationGetResponse,
    CloudIntegrationInitialSetupResponse,
)

Methods:

client.magic_cloud_networking.cloud_integrations.create(*, account_id, **params) -> CloudIntegrationCreateResponse
client.magic_cloud_networking.cloud_integrations.update(provider_id, *, account_id, **params) -> CloudIntegrationUpdateResponse
client.magic_cloud_networking.cloud_integrations.list(*, account_id, **params) -> SyncSinglePage[CloudIntegrationListResponse]
client.magic_cloud_networking.cloud_integrations.delete(provider_id, *, account_id) -> CloudIntegrationDeleteResponse
client.magic_cloud_networking.cloud_integrations.discover(provider_id, *, account_id, **params) -> CloudIntegrationDiscoverResponse
client.magic_cloud_networking.cloud_integrations.discover_all(*, account_id) -> CloudIntegrationDiscoverAllResponse
client.magic_cloud_networking.cloud_integrations.edit(provider_id, *, account_id, **params) -> CloudIntegrationEditResponse
client.magic_cloud_networking.cloud_integrations.get(provider_id, *, account_id, **params) -> CloudIntegrationGetResponse
client.magic_cloud_networking.cloud_integrations.initial_setup(provider_id, *, account_id) -> CloudIntegrationInitialSetupResponse

Resources

Types:

from cloudflare.types.magic_cloud_networking import (
    ResourceListResponse,
    ResourceGetResponse,
    ResourcePolicyPreviewResponse,
)

Methods:

client.magic_cloud_networking.resources.list(*, account_id, **params) -> SyncV4PagePaginationArray[ResourceListResponse]
client.magic_cloud_networking.resources.export(*, account_id, **params) -> BinaryAPIResponse
client.magic_cloud_networking.resources.get(resource_id, *, account_id, **params) -> ResourceGetResponse
client.magic_cloud_networking.resources.policy_preview(*, account_id, **params) -> str

NetworkInterconnects

CNIs

Types:

from cloudflare.types.network_interconnects import (
    CNICreateResponse,
    CNIUpdateResponse,
    CNIListResponse,
    CNIGetResponse,
)

Methods:

client.network_interconnects.cnis.create(*, account_id, **params) -> CNICreateResponse
client.network_interconnects.cnis.update(cni, *, account_id, **params) -> CNIUpdateResponse
client.network_interconnects.cnis.list(*, account_id, **params) -> CNIListResponse
client.network_interconnects.cnis.delete(cni, *, account_id) -> None
client.network_interconnects.cnis.get(cni, *, account_id) -> CNIGetResponse

Interconnects

Types:

from cloudflare.types.network_interconnects import (
    InterconnectCreateResponse,
    InterconnectListResponse,
    InterconnectGetResponse,
    InterconnectStatusResponse,
)

Methods:

client.network_interconnects.interconnects.create(*, account_id, **params) -> InterconnectCreateResponse
client.network_interconnects.interconnects.list(*, account_id, **params) -> InterconnectListResponse
client.network_interconnects.interconnects.delete(icon, *, account_id) -> None
client.network_interconnects.interconnects.get(icon, *, account_id) -> InterconnectGetResponse
client.network_interconnects.interconnects.loa(icon, *, account_id) -> None
client.network_interconnects.interconnects.status(icon, *, account_id) -> InterconnectStatusResponse

Settings

Types:

from cloudflare.types.network_interconnects import SettingUpdateResponse, SettingGetResponse

Methods:

client.network_interconnects.settings.update(*, account_id, **params) -> SettingUpdateResponse
client.network_interconnects.settings.get(*, account_id) -> SettingGetResponse

Slots

Types:

from cloudflare.types.network_interconnects import SlotListResponse, SlotGetResponse

Methods:

client.network_interconnects.slots.list(*, account_id, **params) -> SlotListResponse
client.network_interconnects.slots.get(slot, *, account_id) -> SlotGetResponse

MTLSCertificates

Types:

from cloudflare.types.mtls_certificates import MTLSCertificate, MTLSCertificateCreateResponse

Methods:

client.mtls_certificates.create(*, account_id, **params) -> Optional[MTLSCertificateCreateResponse]
client.mtls_certificates.list(*, account_id) -> SyncSinglePage[MTLSCertificate]
client.mtls_certificates.delete(mtls_certificate_id, *, account_id) -> Optional[MTLSCertificate]
client.mtls_certificates.get(mtls_certificate_id, *, account_id) -> Optional[MTLSCertificate]

Associations

Types:

from cloudflare.types.mtls_certificates import CertificateAsssociation

Methods:

client.mtls_certificates.associations.get(mtls_certificate_id, *, account_id) -> SyncSinglePage[CertificateAsssociation]

Pages

Projects

Types:

from cloudflare.types.pages import (
    Deployment,
    Project,
    Stage,
    ProjectDeleteResponse,
    ProjectPurgeBuildCacheResponse,
)

Methods:

client.pages.projects.create(*, account_id, **params) -> Project
client.pages.projects.list(*, account_id) -> SyncSinglePage[Deployment]
client.pages.projects.delete(project_name, *, account_id) -> object
client.pages.projects.edit(project_name, *, account_id, **params) -> Project
client.pages.projects.get(project_name, *, account_id) -> Project
client.pages.projects.purge_build_cache(project_name, *, account_id) -> object

Deployments

Types:

from cloudflare.types.pages.projects import DeploymentDeleteResponse

Methods:

client.pages.projects.deployments.create(project_name, *, account_id, **params) -> Deployment
client.pages.projects.deployments.list(project_name, *, account_id, **params) -> SyncSinglePage[Deployment]
client.pages.projects.deployments.delete(deployment_id, *, account_id, project_name) -> object
client.pages.projects.deployments.get(deployment_id, *, account_id, project_name) -> Deployment
client.pages.projects.deployments.retry(deployment_id, *, account_id, project_name, **params) -> Deployment
client.pages.projects.deployments.rollback(deployment_id, *, account_id, project_name, **params) -> Deployment

History

Logs

Types:

from cloudflare.types.pages.projects.deployments.history import LogGetResponse

Methods:

client.pages.projects.deployments.history.logs.get(deployment_id, *, account_id, project_name) -> LogGetResponse

Domains

Types:

from cloudflare.types.pages.projects import (
    DomainCreateResponse,
    DomainListResponse,
    DomainDeleteResponse,
    DomainEditResponse,
    DomainGetResponse,
)

Methods:

client.pages.projects.domains.create(project_name, *, account_id, **params) -> Optional[DomainCreateResponse]
client.pages.projects.domains.list(project_name, *, account_id) -> SyncSinglePage[DomainListResponse]
client.pages.projects.domains.delete(domain_name, *, account_id, project_name) -> object
client.pages.projects.domains.edit(domain_name, *, account_id, project_name, **params) -> Optional[DomainEditResponse]
client.pages.projects.domains.get(domain_name, *, account_id, project_name) -> Optional[DomainGetResponse]

Registrar

Domains

Types:

from cloudflare.types.registrar import Domain, DomainUpdateResponse, DomainGetResponse

Methods:

client.registrar.domains.update(domain_name, *, account_id, **params) -> object
client.registrar.domains.list(*, account_id) -> SyncSinglePage[Domain]
client.registrar.domains.get(domain_name, *, account_id) -> object

RequestTracers

Traces

Types:

from cloudflare.types.request_tracers import Trace, TraceItem, TraceCreateResponse

Methods:

client.request_tracers.traces.create(*, account_id, **params) -> Optional[TraceCreateResponse]

Rules

Lists

Types:

from cloudflare.types.rules import Hostname, ListsList, Redirect, ListDeleteResponse

Methods:

client.rules.lists.create(*, account_id, **params) -> ListsList
client.rules.lists.update(list_id, *, account_id, **params) -> ListsList
client.rules.lists.list(*, account_id) -> SyncSinglePage[ListsList]
client.rules.lists.delete(list_id, *, account_id) -> ListDeleteResponse
client.rules.lists.get(list_id, *, account_id) -> ListsList

BulkOperations

Types:

from cloudflare.types.rules.lists import OperationStatus, BulkOperationGetResponse

Methods:

client.rules.lists.bulk_operations.get(operation_id, *, account_identifier) -> BulkOperationGetResponse

Items

Types:

from cloudflare.types.rules.lists import (
    ListCursor,
    ListItem,
    ItemCreateResponse,
    ItemUpdateResponse,
    ItemListResponse,
    ItemDeleteResponse,
    ItemGetResponse,
)

Methods:

client.rules.lists.items.create(list_id, *, account_id, **params) -> ItemCreateResponse
client.rules.lists.items.update(list_id, *, account_id, **params) -> ItemUpdateResponse
client.rules.lists.items.list(list_id, *, account_id, **params) -> SyncCursorPagination[ItemListResponse]
client.rules.lists.items.delete(list_id, *, account_id) -> ItemDeleteResponse
client.rules.lists.items.get(item_id, *, account_identifier, list_id) -> ItemGetResponse

Stream

Types:

from cloudflare.types.stream import AllowedOrigins, Video

Methods:

client.stream.create(*, account_id, **params) -> None
client.stream.list(*, account_id, **params) -> SyncSinglePage[Video]
client.stream.delete(identifier, *, account_id) -> None
client.stream.edit(identifier, *, account_id, **params) -> Optional[Video]
client.stream.get(identifier, *, account_id) -> Optional[Video]

AudioTracks

Types:

from cloudflare.types.stream import Audio, AudioTrackDeleteResponse

Methods:

client.stream.audio_tracks.delete(audio_identifier, *, account_id, identifier) -> str
client.stream.audio_tracks.copy(identifier, *, account_id, **params) -> Optional[Audio]
client.stream.audio_tracks.edit(audio_identifier, *, account_id, identifier, **params) -> Optional[Audio]
client.stream.audio_tracks.get(identifier, *, account_id) -> SyncSinglePage[Audio]

Videos

Types:

from cloudflare.types.stream import VideoStorageUsageResponse

Methods:

client.stream.videos.storage_usage(*, account_id, **params) -> Optional[VideoStorageUsageResponse]

Clip

Types:

from cloudflare.types.stream import Clip

Methods:

client.stream.clip.create(*, account_id, **params) -> Optional[Clip]

Copy

Methods:

client.stream.copy.create(*, account_id, **params) -> Optional[Video]

DirectUpload

Types:

from cloudflare.types.stream import DirectUploadCreateResponse

Methods:

client.stream.direct_upload.create(*, account_id, **params) -> Optional[DirectUploadCreateResponse]

Keys

Types:

from cloudflare.types.stream import Keys, KeyDeleteResponse, KeyGetResponse

Methods:

client.stream.keys.create(*, account_id, **params) -> Optional[Keys]
client.stream.keys.delete(identifier, *, account_id) -> str
client.stream.keys.get(*, account_id) -> SyncSinglePage[KeyGetResponse]

LiveInputs

Types:

from cloudflare.types.stream import LiveInput, LiveInputListResponse

Methods:

client.stream.live_inputs.create(*, account_id, **params) -> Optional[LiveInput]
client.stream.live_inputs.update(live_input_identifier, *, account_id, **params) -> Optional[LiveInput]
client.stream.live_inputs.list(*, account_id, **params) -> Optional[LiveInputListResponse]
client.stream.live_inputs.delete(live_input_identifier, *, account_id) -> None
client.stream.live_inputs.get(live_input_identifier, *, account_id) -> Optional[LiveInput]

Outputs

Types:

from cloudflare.types.stream.live_inputs import Output

Methods:

client.stream.live_inputs.outputs.create(live_input_identifier, *, account_id, **params) -> Optional[Output]
client.stream.live_inputs.outputs.update(output_identifier, *, account_id, live_input_identifier, **params) -> Optional[Output]
client.stream.live_inputs.outputs.list(live_input_identifier, *, account_id) -> SyncSinglePage[Output]
client.stream.live_inputs.outputs.delete(output_identifier, *, account_id, live_input_identifier) -> None

Watermarks

Types:

from cloudflare.types.stream import Watermark, WatermarkDeleteResponse

Methods:

client.stream.watermarks.create(*, account_id, **params) -> Optional[Watermark]
client.stream.watermarks.list(*, account_id) -> SyncSinglePage[Watermark]
client.stream.watermarks.delete(identifier, *, account_id) -> str
client.stream.watermarks.get(identifier, *, account_id) -> Optional[Watermark]

Webhooks

Types:

from cloudflare.types.stream import WebhookUpdateResponse, WebhookDeleteResponse, WebhookGetResponse

Methods:

client.stream.webhooks.update(*, account_id, **params) -> object
client.stream.webhooks.delete(*, account_id) -> str
client.stream.webhooks.get(*, account_id) -> object

Captions

Types:

from cloudflare.types.stream import Caption

Methods:

client.stream.captions.get(identifier, *, account_id) -> SyncSinglePage[Caption]

Language

Types:

from cloudflare.types.stream.captions import LanguageDeleteResponse

Methods:

client.stream.captions.language.create(language, *, account_id, identifier) -> Optional[Caption]
client.stream.captions.language.update(language, *, account_id, identifier, **params) -> Optional[Caption]
client.stream.captions.language.delete(language, *, account_id, identifier) -> str
client.stream.captions.language.get(language, *, account_id, identifier) -> Optional[Caption]

Vtt

Types:

from cloudflare.types.stream.captions.language import VttGetResponse

Methods:

client.stream.captions.language.vtt.get(language, *, account_id, identifier) -> str

Downloads

Types:

from cloudflare.types.stream import (
    DownloadCreateResponse,
    DownloadDeleteResponse,
    DownloadGetResponse,
)

Methods:

client.stream.downloads.create(identifier, *, account_id, **params) -> object
client.stream.downloads.delete(identifier, *, account_id) -> str
client.stream.downloads.get(identifier, *, account_id) -> object

Embed

Types:

from cloudflare.types.stream import EmbedGetResponse

Methods:

client.stream.embed.get(identifier, *, account_id) -> str

Token

Types:

from cloudflare.types.stream import TokenCreateResponse

Methods:

client.stream.token.create(identifier, *, account_id, **params) -> Optional[TokenCreateResponse]

Alerting

AvailableAlerts

Types:

from cloudflare.types.alerting import AvailableAlertListResponse

Methods:

client.alerting.available_alerts.list(*, account_id) -> Optional[AvailableAlertListResponse]

Destinations

Eligible

Types:

from cloudflare.types.alerting.destinations import EligibleGetResponse

Methods:

client.alerting.destinations.eligible.get(*, account_id) -> Optional[EligibleGetResponse]

Pagerduty

Types:

from cloudflare.types.alerting.destinations import (
    Pagerduty,
    PagerdutyCreateResponse,
    PagerdutyDeleteResponse,
    PagerdutyLinkResponse,
)

Methods:

client.alerting.destinations.pagerduty.create(*, account_id) -> Optional[PagerdutyCreateResponse]
client.alerting.destinations.pagerduty.delete(*, account_id) -> PagerdutyDeleteResponse
client.alerting.destinations.pagerduty.get(*, account_id) -> SyncSinglePage[Pagerduty]
client.alerting.destinations.pagerduty.link(token_id, *, account_id) -> Optional[PagerdutyLinkResponse]

Webhooks

Types:

from cloudflare.types.alerting.destinations import (
    Webhooks,
    WebhookCreateResponse,
    WebhookUpdateResponse,
    WebhookDeleteResponse,
)

Methods:

client.alerting.destinations.webhooks.create(*, account_id, **params) -> Optional[WebhookCreateResponse]
client.alerting.destinations.webhooks.update(webhook_id, *, account_id, **params) -> Optional[WebhookUpdateResponse]
client.alerting.destinations.webhooks.list(*, account_id) -> SyncSinglePage[Webhooks]
client.alerting.destinations.webhooks.delete(webhook_id, *, account_id) -> WebhookDeleteResponse
client.alerting.destinations.webhooks.get(webhook_id, *, account_id) -> Optional[Webhooks]

History

Types:

from cloudflare.types.alerting import History

Methods:

client.alerting.history.list(*, account_id, **params) -> SyncV4PagePaginationArray[History]

Policies

Types:

from cloudflare.types.alerting import (
    Mechanism,
    Policy,
    PolicyFilter,
    PolicyCreateResponse,
    PolicyUpdateResponse,
    PolicyDeleteResponse,
)

Methods:

client.alerting.policies.create(*, account_id, **params) -> Optional[PolicyCreateResponse]
client.alerting.policies.update(policy_id, *, account_id, **params) -> Optional[PolicyUpdateResponse]
client.alerting.policies.list(*, account_id) -> SyncSinglePage[Policy]
client.alerting.policies.delete(policy_id, *, account_id) -> PolicyDeleteResponse
client.alerting.policies.get(policy_id, *, account_id) -> Optional[Policy]

D1

Types:

from cloudflare.types.d1 import D1

Database

Types:

from cloudflare.types.d1 import (
    QueryResult,
    DatabaseListResponse,
    DatabaseDeleteResponse,
    DatabaseExportResponse,
    DatabaseImportResponse,
    DatabaseRawResponse,
)

Methods:

client.d1.database.create(*, account_id, **params) -> D1
client.d1.database.list(*, account_id, **params) -> SyncV4PagePaginationArray[DatabaseListResponse]
client.d1.database.delete(database_id, *, account_id) -> object
client.d1.database.export(database_id, *, account_id, **params) -> DatabaseExportResponse
client.d1.database.get(database_id, *, account_id) -> D1
client.d1.database.import_(database_id, *, account_id, **params) -> DatabaseImportResponse
client.d1.database.query(database_id, *, account_id, **params) -> SyncSinglePage[QueryResult]
client.d1.database.raw(database_id, *, account_id, **params) -> SyncSinglePage[DatabaseRawResponse]

R2

Buckets

Types:

from cloudflare.types.r2 import Bucket, BucketListResponse, BucketDeleteResponse

Methods:

client.r2.buckets.create(*, account_id, **params) -> Bucket
client.r2.buckets.list(*, account_id, **params) -> BucketListResponse
client.r2.buckets.delete(bucket_name, *, account_id) -> object
client.r2.buckets.get(bucket_name, *, account_id) -> Bucket

Lifecycle

Types:

from cloudflare.types.r2.buckets import LifecycleUpdateResponse, LifecycleGetResponse

Methods:

client.r2.buckets.lifecycle.update(bucket_name, *, account_id, **params) -> object
client.r2.buckets.lifecycle.get(bucket_name, *, account_id) -> LifecycleGetResponse

CORS

Types:

from cloudflare.types.r2.buckets import CORSUpdateResponse, CORSDeleteResponse, CORSGetResponse

Methods:

client.r2.buckets.cors.update(bucket_name, *, account_id, **params) -> object
client.r2.buckets.cors.delete(bucket_name, *, account_id) -> object
client.r2.buckets.cors.get(bucket_name, *, account_id) -> CORSGetResponse

Domains

Custom

Types:

from cloudflare.types.r2.buckets.domains import (
    CustomCreateResponse,
    CustomUpdateResponse,
    CustomListResponse,
    CustomDeleteResponse,
    CustomGetResponse,
)

Methods:

client.r2.buckets.domains.custom.create(bucket_name, *, account_id, **params) -> CustomCreateResponse
client.r2.buckets.domains.custom.update(domain, *, account_id, bucket_name, **params) -> CustomUpdateResponse
client.r2.buckets.domains.custom.list(bucket_name, *, account_id) -> CustomListResponse
client.r2.buckets.domains.custom.delete(domain, *, account_id, bucket_name) -> CustomDeleteResponse
client.r2.buckets.domains.custom.get(domain, *, account_id, bucket_name) -> CustomGetResponse

Managed

Types:

from cloudflare.types.r2.buckets.domains import ManagedUpdateResponse, ManagedListResponse

Methods:

client.r2.buckets.domains.managed.update(bucket_name, *, account_id, **params) -> ManagedUpdateResponse
client.r2.buckets.domains.managed.list(bucket_name, *, account_id) -> ManagedListResponse

EventNotifications

Types:

from cloudflare.types.r2.buckets import (
    EventNotificationUpdateResponse,
    EventNotificationDeleteResponse,
    EventNotificationGetResponse,
)

Methods:

client.r2.buckets.event_notifications.update(queue_id, *, account_id, bucket_name, **params) -> object
client.r2.buckets.event_notifications.delete(queue_id, *, account_id, bucket_name) -> object
client.r2.buckets.event_notifications.get(bucket_name, *, account_id) -> EventNotificationGetResponse

Locks

Types:

from cloudflare.types.r2.buckets import LockUpdateResponse, LockGetResponse

Methods:

client.r2.buckets.locks.update(bucket_name, *, account_id, **params) -> object
client.r2.buckets.locks.get(bucket_name, *, account_id) -> LockGetResponse

Metrics

Types:

from cloudflare.types.r2.buckets import MetricListResponse

Methods:

client.r2.buckets.metrics.list(*, account_id) -> MetricListResponse

Sippy

Types:

from cloudflare.types.r2.buckets import Provider, Sippy, SippyDeleteResponse

Methods:

client.r2.buckets.sippy.update(bucket_name, *, account_id, **params) -> Sippy
client.r2.buckets.sippy.delete(bucket_name, *, account_id) -> SippyDeleteResponse
client.r2.buckets.sippy.get(bucket_name, *, account_id) -> Sippy

TemporaryCredentials

Types:

from cloudflare.types.r2 import TemporaryCredential, TemporaryCredentialCreateResponse

Methods:

client.r2.temporary_credentials.create(*, account_id, **params) -> TemporaryCredentialCreateResponse

WorkersForPlatforms

Dispatch

Namespaces

Types:

from cloudflare.types.workers_for_platforms.dispatch import (
    NamespaceCreateResponse,
    NamespaceListResponse,
    NamespaceDeleteResponse,
    NamespaceGetResponse,
)

Methods:

client.workers_for_platforms.dispatch.namespaces.create(*, account_id, **params) -> Optional[NamespaceCreateResponse]
client.workers_for_platforms.dispatch.namespaces.list(*, account_id) -> SyncSinglePage[NamespaceListResponse]
client.workers_for_platforms.dispatch.namespaces.delete(dispatch_namespace, *, account_id) -> object
client.workers_for_platforms.dispatch.namespaces.get(dispatch_namespace, *, account_id) -> Optional[NamespaceGetResponse]

Scripts

Types:

from cloudflare.types.workers_for_platforms.dispatch.namespaces import Script, ScriptUpdateResponse

Methods:

client.workers_for_platforms.dispatch.namespaces.scripts.update(script_name, *, account_id, dispatch_namespace, **params) -> Optional[ScriptUpdateResponse]
client.workers_for_platforms.dispatch.namespaces.scripts.delete(script_name, *, account_id, dispatch_namespace, **params) -> None
client.workers_for_platforms.dispatch.namespaces.scripts.get(script_name, *, account_id, dispatch_namespace) -> Optional[Script]

AssetUpload

Types:

from cloudflare.types.workers_for_platforms.dispatch.namespaces.scripts import (
    AssetUploadCreateResponse,
)

Methods:

client.workers_for_platforms.dispatch.namespaces.scripts.asset_upload.create(script_name, *, account_id, dispatch_namespace, **params) -> Optional[AssetUploadCreateResponse]

Content

Methods:

client.workers_for_platforms.dispatch.namespaces.scripts.content.update(script_name, *, account_id, dispatch_namespace, **params) -> Optional[Script]
client.workers_for_platforms.dispatch.namespaces.scripts.content.get(script_name, *, account_id, dispatch_namespace) -> BinaryAPIResponse

Settings

Types:

from cloudflare.types.workers_for_platforms.dispatch.namespaces.scripts import (
    SettingEditResponse,
    SettingGetResponse,
)

Methods:

client.workers_for_platforms.dispatch.namespaces.scripts.settings.edit(script_name, *, account_id, dispatch_namespace, **params) -> Optional[SettingEditResponse]
client.workers_for_platforms.dispatch.namespaces.scripts.settings.get(script_name, *, account_id, dispatch_namespace) -> Optional[SettingGetResponse]

Bindings

Types:

from cloudflare.types.workers_for_platforms.dispatch.namespaces.scripts import BindingGetResponse

Methods:

client.workers_for_platforms.dispatch.namespaces.scripts.bindings.get(script_name, *, account_id, dispatch_namespace) -> SyncSinglePage[BindingGetResponse]

Secrets

Types:

from cloudflare.types.workers_for_platforms.dispatch.namespaces.scripts import (
    SecretUpdateResponse,
    SecretListResponse,
    SecretDeleteResponse,
    SecretGetResponse,
)

Methods:

client.workers_for_platforms.dispatch.namespaces.scripts.secrets.update(script_name, *, account_id, dispatch_namespace, **params) -> Optional[SecretUpdateResponse]
client.workers_for_platforms.dispatch.namespaces.scripts.secrets.list(script_name, *, account_id, dispatch_namespace) -> SyncSinglePage[SecretListResponse]
client.workers_for_platforms.dispatch.namespaces.scripts.secrets.delete(secret_name, *, account_id, dispatch_namespace, script_name) -> object
client.workers_for_platforms.dispatch.namespaces.scripts.secrets.get(secret_name, *, account_id, dispatch_namespace, script_name) -> Optional[SecretGetResponse]

ZeroTrust

Devices

Types:

from cloudflare.types.zero_trust import Device, DeviceGetResponse

Methods:

client.zero_trust.devices.list(*, account_id) -> SyncSinglePage[Device]
client.zero_trust.devices.get(device_id, *, account_id) -> Optional[DeviceGetResponse]

DEXTests

Types:

from cloudflare.types.zero_trust.devices import (
    DEXTest,
    SchemaData,
    SchemaHTTP,
    DEXTestDeleteResponse,
)

Methods:

client.zero_trust.devices.dex_tests.create(*, account_id, **params) -> Optional[SchemaHTTP]
client.zero_trust.devices.dex_tests.update(dex_test_id, *, account_id, **params) -> Optional[SchemaHTTP]
client.zero_trust.devices.dex_tests.list(*, account_id) -> SyncSinglePage[SchemaHTTP]
client.zero_trust.devices.dex_tests.delete(dex_test_id, *, account_id) -> DEXTestDeleteResponse
client.zero_trust.devices.dex_tests.get(dex_test_id, *, account_id) -> Optional[SchemaHTTP]

Networks

Types:

from cloudflare.types.zero_trust.devices import DeviceNetwork

Methods:

client.zero_trust.devices.networks.create(*, account_id, **params) -> Optional[DeviceNetwork]
client.zero_trust.devices.networks.update(network_id, *, account_id, **params) -> Optional[DeviceNetwork]
client.zero_trust.devices.networks.list(*, account_id) -> SyncSinglePage[DeviceNetwork]
client.zero_trust.devices.networks.delete(network_id, *, account_id) -> SyncSinglePage[DeviceNetwork]
client.zero_trust.devices.networks.get(network_id, *, account_id) -> Optional[DeviceNetwork]

FleetStatus

Types:

from cloudflare.types.zero_trust.devices import FleetStatusGetResponse

Methods:

client.zero_trust.devices.fleet_status.get(device_id, *, account_id, **params) -> FleetStatusGetResponse

Policies

Types:

from cloudflare.types.zero_trust.devices import (
    DevicePolicyCertificates,
    FallbackDomain,
    FallbackDomainPolicy,
    SettingsPolicy,
    SplitTunnelExclude,
    SplitTunnelInclude,
)

Default

Types:

from cloudflare.types.zero_trust.devices.policies import DefaultEditResponse, DefaultGetResponse

Methods:

client.zero_trust.devices.policies.default.edit(*, account_id, **params) -> Optional[DefaultEditResponse]
client.zero_trust.devices.policies.default.get(*, account_id) -> Optional[DefaultGetResponse]

Excludes

Methods:

client.zero_trust.devices.policies.default.excludes.update(*, account_id, **params) -> SyncSinglePage[SplitTunnelExclude]
client.zero_trust.devices.policies.default.excludes.get(*, account_id) -> SyncSinglePage[SplitTunnelExclude]

Includes

Methods:

client.zero_trust.devices.policies.default.includes.update(*, account_id, **params) -> SyncSinglePage[SplitTunnelInclude]
client.zero_trust.devices.policies.default.includes.get(*, account_id) -> SyncSinglePage[SplitTunnelInclude]

FallbackDomains

Methods:

client.zero_trust.devices.policies.default.fallback_domains.update(*, account_id, **params) -> SyncSinglePage[FallbackDomain]
client.zero_trust.devices.policies.default.fallback_domains.get(*, account_id) -> SyncSinglePage[FallbackDomain]

Certificates

Types:

from cloudflare.types.zero_trust.devices.policies.default import (
    CertificateEditResponse,
    CertificateGetResponse,
)

Methods:

client.zero_trust.devices.policies.default.certificates.edit(*, zone_id, **params) -> Optional[CertificateEditResponse]
client.zero_trust.devices.policies.default.certificates.get(*, zone_id) -> Optional[CertificateGetResponse]

Custom

Methods:

client.zero_trust.devices.policies.custom.create(*, account_id, **params) -> Optional[SettingsPolicy]
client.zero_trust.devices.policies.custom.list(*, account_id) -> SyncSinglePage[SettingsPolicy]
client.zero_trust.devices.policies.custom.delete(policy_id, *, account_id) -> SyncSinglePage[SettingsPolicy]
client.zero_trust.devices.policies.custom.edit(policy_id, *, account_id, **params) -> Optional[SettingsPolicy]
client.zero_trust.devices.policies.custom.get(policy_id, *, account_id) -> Optional[SettingsPolicy]

Excludes

Methods:

client.zero_trust.devices.policies.custom.excludes.update(policy_id, *, account_id, **params) -> SyncSinglePage[SplitTunnelExclude]
client.zero_trust.devices.policies.custom.excludes.get(policy_id, *, account_id) -> SyncSinglePage[SplitTunnelExclude]

Includes

Methods:

client.zero_trust.devices.policies.custom.includes.update(policy_id, *, account_id, **params) -> SyncSinglePage[SplitTunnelInclude]
client.zero_trust.devices.policies.custom.includes.get(policy_id, *, account_id) -> SyncSinglePage[SplitTunnelInclude]

FallbackDomains

Methods:

client.zero_trust.devices.policies.custom.fallback_domains.update(policy_id, *, account_id, **params) -> SyncSinglePage[FallbackDomain]
client.zero_trust.devices.policies.custom.fallback_domains.get(policy_id, *, account_id) -> SyncSinglePage[FallbackDomain]

Posture

Types:

from cloudflare.types.zero_trust.devices import (
    CarbonblackInput,
    ClientCertificateInput,
    CrowdstrikeInput,
    DeviceInput,
    DeviceMatch,
    DevicePostureRule,
    DiskEncryptionInput,
    DomainJoinedInput,
    FileInput,
    FirewallInput,
    IntuneInput,
    KolideInput,
    OSVersionInput,
    SentineloneInput,
    SentineloneS2sInput,
    TaniumInput,
    UniqueClientIDInput,
    WorkspaceOneInput,
    PostureDeleteResponse,
)

Methods:

client.zero_trust.devices.posture.create(*, account_id, **params) -> Optional[DevicePostureRule]
client.zero_trust.devices.posture.update(rule_id, *, account_id, **params) -> Optional[DevicePostureRule]
client.zero_trust.devices.posture.list(*, account_id) -> SyncSinglePage[DevicePostureRule]
client.zero_trust.devices.posture.delete(rule_id, *, account_id) -> Optional[PostureDeleteResponse]
client.zero_trust.devices.posture.get(rule_id, *, account_id) -> Optional[DevicePostureRule]

Integrations

Types:

from cloudflare.types.zero_trust.devices.posture import Integration, IntegrationDeleteResponse

Methods:

client.zero_trust.devices.posture.integrations.create(*, account_id, **params) -> Optional[Integration]
client.zero_trust.devices.posture.integrations.list(*, account_id) -> SyncSinglePage[Integration]
client.zero_trust.devices.posture.integrations.delete(integration_id, *, account_id) -> Optional[IntegrationDeleteResponse]
client.zero_trust.devices.posture.integrations.edit(integration_id, *, account_id, **params) -> Optional[Integration]
client.zero_trust.devices.posture.integrations.get(integration_id, *, account_id) -> Optional[Integration]

Revoke

Types:

from cloudflare.types.zero_trust.devices import RevokeCreateResponse

Methods:

client.zero_trust.devices.revoke.create(*, account_id, **params) -> Optional[RevokeCreateResponse]

Settings

Types:

from cloudflare.types.zero_trust.devices import DeviceSettings

Methods:

client.zero_trust.devices.settings.update(*, account_id, **params) -> Optional[DeviceSettings]
client.zero_trust.devices.settings.list(*, account_id) -> Optional[DeviceSettings]
client.zero_trust.devices.settings.edit(*, account_id, **params) -> Optional[DeviceSettings]

Unrevoke

Types:

from cloudflare.types.zero_trust.devices import UnrevokeCreateResponse

Methods:

client.zero_trust.devices.unrevoke.create(*, account_id, **params) -> Optional[UnrevokeCreateResponse]

OverrideCodes

Types:

from cloudflare.types.zero_trust.devices import OverrideCodeListResponse

Methods:

client.zero_trust.devices.override_codes.list(device_id, *, account_id) -> Optional[OverrideCodeListResponse]

IdentityProviders

Types:

from cloudflare.types.zero_trust import (
    AzureAD,
    GenericOAuthConfig,
    IdentityProvider,
    IdentityProviderSCIMConfig,
    IdentityProviderType,
    IdentityProviderListResponse,
    IdentityProviderDeleteResponse,
)

Methods:

client.zero_trust.identity_providers.create(*, account_id, zone_id, **params) -> Optional[IdentityProvider]
client.zero_trust.identity_providers.update(identity_provider_id, *, account_id, zone_id, **params) -> Optional[IdentityProvider]
client.zero_trust.identity_providers.list(*, account_id, zone_id, **params) -> SyncSinglePage[IdentityProviderListResponse]
client.zero_trust.identity_providers.delete(identity_provider_id, *, account_id, zone_id) -> Optional[IdentityProviderDeleteResponse]
client.zero_trust.identity_providers.get(identity_provider_id, *, account_id, zone_id) -> Optional[IdentityProvider]

SCIM

Groups

Methods:

client.zero_trust.identity_providers.scim.groups.list(identity_provider_id, *, account_id, **params) -> SyncSinglePage[ZeroTrustGroup]

Users

Methods:

client.zero_trust.identity_providers.scim.users.list(identity_provider_id, *, account_id, **params) -> SyncSinglePage[AccessUser]

Organizations

Types:

from cloudflare.types.zero_trust import LoginDesign, Organization, OrganizationRevokeUsersResponse

Methods:

client.zero_trust.organizations.create(*, account_id, zone_id, **params) -> Optional[Organization]
client.zero_trust.organizations.update(*, account_id, zone_id, **params) -> Optional[Organization]
client.zero_trust.organizations.list(*, account_id, zone_id) -> Optional[Organization]
client.zero_trust.organizations.revoke_users(*, account_id, zone_id, **params) -> Optional[OrganizationRevokeUsersResponse]

DOH

Types:

from cloudflare.types.zero_trust.organizations import DOHUpdateResponse, DOHGetResponse

Methods:

client.zero_trust.organizations.doh.update(*, account_id, **params) -> Optional[DOHUpdateResponse]
client.zero_trust.organizations.doh.get(*, account_id) -> Optional[DOHGetResponse]

Seats

Types:

from cloudflare.types.zero_trust import Seat

Methods:

client.zero_trust.seats.edit(*, account_id, **params) -> SyncSinglePage[Seat]

Access

GatewayCA

Types:

from cloudflare.types.zero_trust.access import (
    GatewayCACreateResponse,
    GatewayCAListResponse,
    GatewayCADeleteResponse,
)

Methods:

client.zero_trust.access.gateway_ca.create(*, account_id) -> Optional[GatewayCACreateResponse]
client.zero_trust.access.gateway_ca.list(*, account_id) -> SyncSinglePage[GatewayCAListResponse]
client.zero_trust.access.gateway_ca.delete(certificate_id, *, account_id) -> Optional[GatewayCADeleteResponse]

Infrastructure

Targets

Types:

from cloudflare.types.zero_trust.access.infrastructure import (
    TargetCreateResponse,
    TargetUpdateResponse,
    TargetListResponse,
    TargetBulkUpdateResponse,
    TargetGetResponse,
)

Methods:

client.zero_trust.access.infrastructure.targets.create(*, account_id, **params) -> Optional[TargetCreateResponse]
client.zero_trust.access.infrastructure.targets.update(target_id, *, account_id, **params) -> Optional[TargetUpdateResponse]
client.zero_trust.access.infrastructure.targets.list(*, account_id, **params) -> SyncV4PagePaginationArray[TargetListResponse]
client.zero_trust.access.infrastructure.targets.delete(target_id, *, account_id) -> None
client.zero_trust.access.infrastructure.targets.bulk_delete(*, account_id) -> None
client.zero_trust.access.infrastructure.targets.bulk_update(*, account_id, **params) -> TargetBulkUpdateResponse
client.zero_trust.access.infrastructure.targets.get(target_id, *, account_id) -> Optional[TargetGetResponse]

Applications

Types:

from cloudflare.types.zero_trust.access import (
    AllowedHeaders,
    AllowedIdPs,
    AllowedMethods,
    AllowedOrigins,
    AppID,
    Application,
    ApplicationPolicy,
    ApplicationSCIMConfig,
    ApplicationType,
    CORSHeaders,
    Decision,
    OIDCSaaSApp,
    SaaSAppNameIDFormat,
    SAMLSaaSApp,
    SCIMConfigAuthenticationHTTPBasic,
    SCIMConfigAuthenticationOAuthBearerToken,
    SCIMConfigAuthenticationOauth2,
    SCIMConfigMapping,
    SelfHostedDomains,
    ApplicationCreateResponse,
    ApplicationUpdateResponse,
    ApplicationListResponse,
    ApplicationDeleteResponse,
    ApplicationGetResponse,
    ApplicationRevokeTokensResponse,
)

Methods:

client.zero_trust.access.applications.create(*, account_id, zone_id, **params) -> Optional[ApplicationCreateResponse]
client.zero_trust.access.applications.update(app_id, *, account_id, zone_id, **params) -> Optional[ApplicationUpdateResponse]
client.zero_trust.access.applications.list(*, account_id, zone_id, **params) -> SyncSinglePage[ApplicationListResponse]
client.zero_trust.access.applications.delete(app_id, *, account_id, zone_id) -> Optional[ApplicationDeleteResponse]
client.zero_trust.access.applications.get(app_id, *, account_id, zone_id) -> Optional[ApplicationGetResponse]
client.zero_trust.access.applications.revoke_tokens(app_id, *, account_id, zone_id) -> object

CAs

Types:

from cloudflare.types.zero_trust.access.applications import CA, CADeleteResponse

Methods:

client.zero_trust.access.applications.cas.create(app_id, *, account_id, zone_id) -> Optional[CA]
client.zero_trust.access.applications.cas.list(*, account_id, zone_id) -> SyncSinglePage[CA]
client.zero_trust.access.applications.cas.delete(app_id, *, account_id, zone_id) -> Optional[CADeleteResponse]
client.zero_trust.access.applications.cas.get(app_id, *, account_id, zone_id) -> Optional[CA]

UserPolicyChecks

Types:

from cloudflare.types.zero_trust.access.applications import (
    UserPolicyCheckGeo,
    UserPolicyCheckListResponse,
)

Methods:

client.zero_trust.access.applications.user_policy_checks.list(app_id, *, account_id, zone_id) -> Optional[UserPolicyCheckListResponse]

Policies

Types:

from cloudflare.types.zero_trust.access.applications import (
    AccessDevicePostureRule,
    AccessRule,
    AnyValidServiceTokenRule,
    AuthenticationMethodRule,
    AzureGroupRule,
    CertificateRule,
    CountryRule,
    DomainRule,
    EmailListRule,
    EmailRule,
    EveryoneRule,
    ExternalEvaluationRule,
    GitHubOrganizationRule,
    GroupRule,
    GSuiteGroupRule,
    IPListRule,
    IPRule,
    OktaGroupRule,
    SAMLGroupRule,
    ServiceTokenRule,
    PolicyCreateResponse,
    PolicyUpdateResponse,
    PolicyListResponse,
    PolicyDeleteResponse,
    PolicyGetResponse,
)

Methods:

client.zero_trust.access.applications.policies.create(app_id, *, account_id, zone_id, **params) -> Optional[PolicyCreateResponse]
client.zero_trust.access.applications.policies.update(policy_id, *, app_id, account_id, zone_id, **params) -> Optional[PolicyUpdateResponse]
client.zero_trust.access.applications.policies.list(app_id, *, account_id, zone_id) -> SyncSinglePage[PolicyListResponse]
client.zero_trust.access.applications.policies.delete(policy_id, *, app_id, account_id, zone_id) -> Optional[PolicyDeleteResponse]
client.zero_trust.access.applications.policies.get(policy_id, *, app_id, account_id, zone_id) -> Optional[PolicyGetResponse]

PolicyTests

Types:

from cloudflare.types.zero_trust.access.applications import (
    PolicyTestCreateResponse,
    PolicyTestGetResponse,
)

Methods:

client.zero_trust.access.applications.policy_tests.create(*, account_id, **params) -> Optional[PolicyTestCreateResponse]
client.zero_trust.access.applications.policy_tests.get(policy_test_id, *, account_id, **params) -> Optional[PolicyTestGetResponse]

Users

Types:

from cloudflare.types.zero_trust.access.applications.policy_tests import UserListResponse

Methods:

client.zero_trust.access.applications.policy_tests.users.list(policy_test_id, *, account_id, **params) -> SyncSinglePage[UserListResponse]

Certificates

Types:

from cloudflare.types.zero_trust.access import (
    AssociatedHostnames,
    Certificate,
    CertificateDeleteResponse,
)

Methods:

client.zero_trust.access.certificates.create(*, account_id, zone_id, **params) -> Optional[Certificate]
client.zero_trust.access.certificates.update(certificate_id, *, account_id, zone_id, **params) -> Optional[Certificate]
client.zero_trust.access.certificates.list(*, account_id, zone_id) -> SyncSinglePage[Certificate]
client.zero_trust.access.certificates.delete(certificate_id, *, account_id, zone_id) -> Optional[CertificateDeleteResponse]
client.zero_trust.access.certificates.get(certificate_id, *, account_id, zone_id) -> Optional[Certificate]

Settings

Types:

from cloudflare.types.zero_trust.access.certificates import CertificateSettings

Methods:

client.zero_trust.access.certificates.settings.update(*, account_id, zone_id, **params) -> SyncSinglePage[CertificateSettings]
client.zero_trust.access.certificates.settings.get(*, account_id, zone_id) -> SyncSinglePage[CertificateSettings]

Groups

Types:

from cloudflare.types.zero_trust.access import (
    ZeroTrustGroup,
    GroupCreateResponse,
    GroupUpdateResponse,
    GroupListResponse,
    GroupDeleteResponse,
    GroupGetResponse,
)

Methods:

client.zero_trust.access.groups.create(*, account_id, zone_id, **params) -> Optional[GroupCreateResponse]
client.zero_trust.access.groups.update(group_id, *, account_id, zone_id, **params) -> Optional[GroupUpdateResponse]
client.zero_trust.access.groups.list(*, account_id, zone_id, **params) -> SyncSinglePage[GroupListResponse]
client.zero_trust.access.groups.delete(group_id, *, account_id, zone_id) -> Optional[GroupDeleteResponse]
client.zero_trust.access.groups.get(group_id, *, account_id, zone_id) -> Optional[GroupGetResponse]

ServiceTokens

Types:

from cloudflare.types.zero_trust.access import (
    ServiceToken,
    ServiceTokenCreateResponse,
    ServiceTokenRotateResponse,
)

Methods:

client.zero_trust.access.service_tokens.create(*, account_id, zone_id, **params) -> Optional[ServiceTokenCreateResponse]
client.zero_trust.access.service_tokens.update(service_token_id, *, account_id, zone_id, **params) -> Optional[ServiceToken]
client.zero_trust.access.service_tokens.list(*, account_id, zone_id, **params) -> SyncSinglePage[ServiceToken]
client.zero_trust.access.service_tokens.delete(service_token_id, *, account_id, zone_id) -> Optional[ServiceToken]
client.zero_trust.access.service_tokens.get(service_token_id, *, account_id, zone_id) -> Optional[ServiceToken]
client.zero_trust.access.service_tokens.refresh(service_token_id, *, account_id) -> Optional[ServiceToken]
client.zero_trust.access.service_tokens.rotate(service_token_id, *, account_id) -> Optional[ServiceTokenRotateResponse]

Bookmarks

Types:

from cloudflare.types.zero_trust.access import Bookmark, BookmarkDeleteResponse

Methods:

client.zero_trust.access.bookmarks.create(bookmark_id, *, account_id, **params) -> Optional[Bookmark]
client.zero_trust.access.bookmarks.update(bookmark_id, *, account_id, **params) -> Optional[Bookmark]
client.zero_trust.access.bookmarks.list(*, account_id) -> SyncSinglePage[Bookmark]
client.zero_trust.access.bookmarks.delete(bookmark_id, *, account_id) -> Optional[BookmarkDeleteResponse]
client.zero_trust.access.bookmarks.get(bookmark_id, *, account_id) -> Optional[Bookmark]

Keys

Types:

from cloudflare.types.zero_trust.access import KeyUpdateResponse, KeyGetResponse, KeyRotateResponse

Methods:

client.zero_trust.access.keys.update(*, account_id, **params) -> Optional[KeyUpdateResponse]
client.zero_trust.access.keys.get(*, account_id) -> Optional[KeyGetResponse]
client.zero_trust.access.keys.rotate(*, account_id) -> Optional[KeyRotateResponse]

Logs

AccessRequests

Types:

from cloudflare.types.zero_trust.access.logs import AccessRequestListResponse

Methods:

client.zero_trust.access.logs.access_requests.list(*, account_id, **params) -> Optional[AccessRequestListResponse]

SCIM

Types:

from cloudflare.types.zero_trust.access.logs import AccessRequest

Updates

Types:

from cloudflare.types.zero_trust.access.logs.scim import UpdateListResponse

Methods:

client.zero_trust.access.logs.scim.updates.list(*, account_id, **params) -> SyncSinglePage[UpdateListResponse]

Users

Types:

from cloudflare.types.zero_trust.access import AccessUser, UserListResponse

Methods:

client.zero_trust.access.users.list(*, account_id, **params) -> SyncSinglePage[UserListResponse]

ActiveSessions

Types:

from cloudflare.types.zero_trust.access.users import (
    ActiveSessionListResponse,
    ActiveSessionGetResponse,
)

Methods:

client.zero_trust.access.users.active_sessions.list(user_id, *, account_id) -> SyncSinglePage[ActiveSessionListResponse]
client.zero_trust.access.users.active_sessions.get(nonce, *, account_id, user_id) -> Optional[ActiveSessionGetResponse]

LastSeenIdentity

Types:

from cloudflare.types.zero_trust.access.users import Identity

Methods:

client.zero_trust.access.users.last_seen_identity.get(user_id, *, account_id) -> Optional[Identity]

FailedLogins

Types:

from cloudflare.types.zero_trust.access.users import FailedLoginListResponse

Methods:

client.zero_trust.access.users.failed_logins.list(user_id, *, account_id) -> SyncSinglePage[FailedLoginListResponse]

CustomPages

Types:

from cloudflare.types.zero_trust.access import (
    CustomPage,
    CustomPageWithoutHTML,
    CustomPageDeleteResponse,
)

Methods:

client.zero_trust.access.custom_pages.create(*, account_id, **params) -> Optional[CustomPageWithoutHTML]
client.zero_trust.access.custom_pages.update(custom_page_id, *, account_id, **params) -> Optional[CustomPageWithoutHTML]
client.zero_trust.access.custom_pages.list(*, account_id) -> SyncSinglePage[CustomPageWithoutHTML]
client.zero_trust.access.custom_pages.delete(custom_page_id, *, account_id) -> Optional[CustomPageDeleteResponse]
client.zero_trust.access.custom_pages.get(custom_page_id, *, account_id) -> Optional[CustomPage]

Policies

Types:

from cloudflare.types.zero_trust.access import (
    ApprovalGroup,
    Policy,
    PolicyCreateResponse,
    PolicyUpdateResponse,
    PolicyListResponse,
    PolicyDeleteResponse,
    PolicyGetResponse,
)

Methods:

client.zero_trust.access.policies.create(*, account_id, **params) -> Optional[PolicyCreateResponse]
client.zero_trust.access.policies.update(policy_id, *, account_id, **params) -> Optional[PolicyUpdateResponse]
client.zero_trust.access.policies.list(*, account_id) -> SyncSinglePage[PolicyListResponse]
client.zero_trust.access.policies.delete(policy_id, *, account_id) -> Optional[PolicyDeleteResponse]
client.zero_trust.access.policies.get(policy_id, *, account_id) -> Optional[PolicyGetResponse]

DEX

Types:

from cloudflare.types.zero_trust import (
    DigitalExperienceMonitor,
    NetworkPath,
    NetworkPathResponse,
    Percentiles,
)

Commands

Types:

from cloudflare.types.zero_trust.dex import CommandCreateResponse, CommandListResponse

Methods:

client.zero_trust.dex.commands.create(*, account_id, **params) -> Optional[CommandCreateResponse]
client.zero_trust.dex.commands.list(*, account_id, **params) -> SyncV4PagePagination[Optional[CommandListResponse]]

Devices

Types:

from cloudflare.types.zero_trust.dex.commands import DeviceListResponse

Methods:

client.zero_trust.dex.commands.devices.list(*, account_id, **params) -> SyncV4PagePagination[Optional[DeviceListResponse]]

Downloads

Methods:

client.zero_trust.dex.commands.downloads.get(filename, *, account_id, command_id) -> BinaryAPIResponse

Quota

Types:

from cloudflare.types.zero_trust.dex.commands import QuotaGetResponse

Methods:

client.zero_trust.dex.commands.quota.get(*, account_id) -> Optional[QuotaGetResponse]

Colos

Types:

from cloudflare.types.zero_trust.dex import ColoListResponse

Methods:

client.zero_trust.dex.colos.list(*, account_id, **params) -> SyncSinglePage[object]

FleetStatus

Types:

from cloudflare.types.zero_trust.dex import LiveStat, FleetStatusLiveResponse

Methods:

client.zero_trust.dex.fleet_status.live(*, account_id, **params) -> Optional[FleetStatusLiveResponse]
client.zero_trust.dex.fleet_status.over_time(*, account_id, **params) -> None

Devices

Types:

from cloudflare.types.zero_trust.dex.fleet_status import DeviceListResponse

Methods:

client.zero_trust.dex.fleet_status.devices.list(*, account_id, **params) -> SyncV4PagePaginationArray[DeviceListResponse]

HTTPTests

Types:

from cloudflare.types.zero_trust.dex import HTTPDetails

Methods:

client.zero_trust.dex.http_tests.get(test_id, *, account_id, **params) -> Optional[HTTPDetails]

Percentiles

Types:

from cloudflare.types.zero_trust.dex.http_tests import HTTPDetailsPercentiles, TestStatOverTime

Methods:

client.zero_trust.dex.http_tests.percentiles.get(test_id, *, account_id, **params) -> Optional[HTTPDetailsPercentiles]

Tests

Types:

from cloudflare.types.zero_trust.dex import AggregateTimePeriod, Tests

Methods:

client.zero_trust.dex.tests.list(*, account_id, **params) -> SyncV4PagePagination[Optional[Tests]]

UniqueDevices

Types:

from cloudflare.types.zero_trust.dex.tests import UniqueDevices

Methods:

client.zero_trust.dex.tests.unique_devices.list(*, account_id, **params) -> Optional[UniqueDevices]

TracerouteTestResults

NetworkPath

Types:

from cloudflare.types.zero_trust.dex.traceroute_test_results import NetworkPathGetResponse

Methods:

client.zero_trust.dex.traceroute_test_results.network_path.get(test_result_id, *, account_id) -> Optional[NetworkPathGetResponse]

TracerouteTests

Types:

from cloudflare.types.zero_trust.dex import Traceroute, TracerouteTestPercentilesResponse

Methods:

client.zero_trust.dex.traceroute_tests.get(test_id, *, account_id, **params) -> Optional[Traceroute]
client.zero_trust.dex.traceroute_tests.network_path(test_id, *, account_id, **params) -> Optional[NetworkPathResponse]
client.zero_trust.dex.traceroute_tests.percentiles(test_id, *, account_id, **params) -> Optional[TracerouteTestPercentilesResponse]

Tunnels

Types:

from cloudflare.types.zero_trust import Connection, TunnelListResponse

Methods:

client.zero_trust.tunnels.list(*, account_id, **params) -> SyncV4PagePaginationArray[TunnelListResponse]

Cloudflared

Types:

from cloudflare.types.zero_trust.tunnels import (
    CloudflaredCreateResponse,
    CloudflaredListResponse,
    CloudflaredDeleteResponse,
    CloudflaredEditResponse,
    CloudflaredGetResponse,
)

Methods:

client.zero_trust.tunnels.cloudflared.create(*, account_id, **params) -> CloudflaredCreateResponse
client.zero_trust.tunnels.cloudflared.list(*, account_id, **params) -> SyncV4PagePaginationArray[CloudflaredListResponse]
client.zero_trust.tunnels.cloudflared.delete(tunnel_id, *, account_id) -> CloudflaredDeleteResponse
client.zero_trust.tunnels.cloudflared.edit(tunnel_id, *, account_id, **params) -> CloudflaredEditResponse
client.zero_trust.tunnels.cloudflared.get(tunnel_id, *, account_id) -> CloudflaredGetResponse

Configurations

Types:

from cloudflare.types.zero_trust.tunnels.cloudflared import (
    ConfigurationUpdateResponse,
    ConfigurationGetResponse,
)

Methods:

client.zero_trust.tunnels.cloudflared.configurations.update(tunnel_id, *, account_id, **params) -> Optional[ConfigurationUpdateResponse]
client.zero_trust.tunnels.cloudflared.configurations.get(tunnel_id, *, account_id) -> Optional[ConfigurationGetResponse]

Connections

Types:

from cloudflare.types.zero_trust.tunnels.cloudflared import Client, ConnectionDeleteResponse

Methods:

client.zero_trust.tunnels.cloudflared.connections.delete(tunnel_id, *, account_id, **params) -> object
client.zero_trust.tunnels.cloudflared.connections.get(tunnel_id, *, account_id) -> SyncSinglePage[Client]

Token

Types:

from cloudflare.types.zero_trust.tunnels.cloudflared import TokenGetResponse

Methods:

client.zero_trust.tunnels.cloudflared.token.get(tunnel_id, *, account_id) -> str

Connectors

Methods:

client.zero_trust.tunnels.cloudflared.connectors.get(connector_id, *, account_id, tunnel_id) -> Client

Management

Types:

from cloudflare.types.zero_trust.tunnels.cloudflared import ManagementCreateResponse

Methods:

client.zero_trust.tunnels.cloudflared.management.create(tunnel_id, *, account_id, **params) -> str

WARPConnector

Types:

from cloudflare.types.zero_trust.tunnels import (
    WARPConnectorCreateResponse,
    WARPConnectorListResponse,
    WARPConnectorDeleteResponse,
    WARPConnectorEditResponse,
    WARPConnectorGetResponse,
)

Methods:

client.zero_trust.tunnels.warp_connector.create(*, account_id, **params) -> WARPConnectorCreateResponse
client.zero_trust.tunnels.warp_connector.list(*, account_id, **params) -> SyncV4PagePaginationArray[WARPConnectorListResponse]
client.zero_trust.tunnels.warp_connector.delete(tunnel_id, *, account_id) -> WARPConnectorDeleteResponse
client.zero_trust.tunnels.warp_connector.edit(tunnel_id, *, account_id, **params) -> WARPConnectorEditResponse
client.zero_trust.tunnels.warp_connector.get(tunnel_id, *, account_id) -> WARPConnectorGetResponse

Token

Types:

from cloudflare.types.zero_trust.tunnels.warp_connector import TokenGetResponse

Methods:

client.zero_trust.tunnels.warp_connector.token.get(tunnel_id, *, account_id) -> str

ConnectivitySettings

Types:

from cloudflare.types.zero_trust import (
    ConnectivitySettingEditResponse,
    ConnectivitySettingGetResponse,
)

Methods:

client.zero_trust.connectivity_settings.edit(*, account_id, **params) -> ConnectivitySettingEditResponse
client.zero_trust.connectivity_settings.get(*, account_id) -> ConnectivitySettingGetResponse

DLP

Datasets

Types:

from cloudflare.types.zero_trust.dlp import Dataset, DatasetArray, DatasetCreation

Methods:

client.zero_trust.dlp.datasets.create(*, account_id, **params) -> Optional[DatasetCreation]
client.zero_trust.dlp.datasets.update(dataset_id, *, account_id, **params) -> Optional[Dataset]
client.zero_trust.dlp.datasets.list(*, account_id) -> SyncSinglePage[Dataset]
client.zero_trust.dlp.datasets.delete(dataset_id, *, account_id) -> None
client.zero_trust.dlp.datasets.get(dataset_id, *, account_id) -> Optional[Dataset]

Upload

Types:

from cloudflare.types.zero_trust.dlp.datasets import NewVersion

Methods:

client.zero_trust.dlp.datasets.upload.create(dataset_id, *, account_id) -> Optional[NewVersion]
client.zero_trust.dlp.datasets.upload.edit(version, *, account_id, dataset_id, **params) -> Optional[Dataset]

Versions

Types:

from cloudflare.types.zero_trust.dlp.datasets import VersionCreateResponse

Methods:

client.zero_trust.dlp.datasets.versions.create(version, *, account_id, dataset_id, **params) -> SyncSinglePage[VersionCreateResponse]

Entries

Types:

from cloudflare.types.zero_trust.dlp.datasets.versions import EntryCreateResponse

Methods:

client.zero_trust.dlp.datasets.versions.entries.create(entry_id, *, account_id, dataset_id, version, **params) -> Optional[EntryCreateResponse]

Patterns

Types:

from cloudflare.types.zero_trust.dlp import PatternValidateResponse

Methods:

client.zero_trust.dlp.patterns.validate(*, account_id, **params) -> Optional[PatternValidateResponse]

PayloadLogs

Types:

from cloudflare.types.zero_trust.dlp import PayloadLogUpdateResponse, PayloadLogGetResponse

Methods:

client.zero_trust.dlp.payload_logs.update(*, account_id, **params) -> Optional[PayloadLogUpdateResponse]
client.zero_trust.dlp.payload_logs.get(*, account_id) -> Optional[PayloadLogGetResponse]

Email

AccountMapping

Types:

from cloudflare.types.zero_trust.dlp.email import (
    AccountMappingCreateResponse,
    AccountMappingGetResponse,
)

Methods:

client.zero_trust.dlp.email.account_mapping.create(*, account_id, **params) -> Optional[AccountMappingCreateResponse]
client.zero_trust.dlp.email.account_mapping.get(*, account_id) -> Optional[AccountMappingGetResponse]

Rules

Types:

from cloudflare.types.zero_trust.dlp.email import (
    RuleCreateResponse,
    RuleUpdateResponse,
    RuleListResponse,
    RuleDeleteResponse,
    RuleBulkEditResponse,
    RuleGetResponse,
)

Methods:

client.zero_trust.dlp.email.rules.create(*, account_id, **params) -> Optional[RuleCreateResponse]
client.zero_trust.dlp.email.rules.update(rule_id, *, account_id, **params) -> Optional[RuleUpdateResponse]
client.zero_trust.dlp.email.rules.list(*, account_id) -> SyncSinglePage[RuleListResponse]
client.zero_trust.dlp.email.rules.delete(rule_id, *, account_id) -> Optional[RuleDeleteResponse]
client.zero_trust.dlp.email.rules.bulk_edit(*, account_id, **params) -> Optional[RuleBulkEditResponse]
client.zero_trust.dlp.email.rules.get(rule_id, *, account_id) -> Optional[RuleGetResponse]

Profiles

Types:

from cloudflare.types.zero_trust.dlp import ContextAwareness, Profile, SkipConfiguration

Methods:

client.zero_trust.dlp.profiles.list(*, account_id, **params) -> SyncSinglePage[Profile]
client.zero_trust.dlp.profiles.get(profile_id, *, account_id) -> Optional[Profile]

Custom

Types:

from cloudflare.types.zero_trust.dlp.profiles import (
    CustomProfile,
    Pattern,
    CustomCreateResponse,
    CustomDeleteResponse,
)

Methods:

client.zero_trust.dlp.profiles.custom.create(*, account_id, **params) -> Optional[CustomCreateResponse]
client.zero_trust.dlp.profiles.custom.update(profile_id, *, account_id, **params) -> Optional[Profile]
client.zero_trust.dlp.profiles.custom.delete(profile_id, *, account_id) -> object
client.zero_trust.dlp.profiles.custom.get(profile_id, *, account_id) -> Optional[Profile]

Predefined

Types:

from cloudflare.types.zero_trust.dlp.profiles import PredefinedProfile

Methods:

client.zero_trust.dlp.profiles.predefined.update(profile_id, *, account_id, **params) -> Optional[Profile]
client.zero_trust.dlp.profiles.predefined.get(profile_id, *, account_id) -> Optional[Profile]

Limits

Types:

from cloudflare.types.zero_trust.dlp import LimitListResponse

Methods:

client.zero_trust.dlp.limits.list(*, account_id) -> Optional[LimitListResponse]

Entries

Types:

from cloudflare.types.zero_trust.dlp import (
    EntryCreateResponse,
    EntryUpdateResponse,
    EntryListResponse,
    EntryDeleteResponse,
    EntryGetResponse,
)

Methods:

client.zero_trust.dlp.entries.create(*, account_id, **params) -> Optional[EntryCreateResponse]
client.zero_trust.dlp.entries.update(entry_id, *, account_id, **params) -> Optional[EntryUpdateResponse]
client.zero_trust.dlp.entries.list(*, account_id) -> SyncSinglePage[EntryListResponse]
client.zero_trust.dlp.entries.delete(entry_id, *, account_id) -> object
client.zero_trust.dlp.entries.get(entry_id, *, account_id) -> Optional[EntryGetResponse]

Gateway

Types:

from cloudflare.types.zero_trust import GatewayCreateResponse, GatewayListResponse

Methods:

client.zero_trust.gateway.create(*, account_id) -> Optional[GatewayCreateResponse]
client.zero_trust.gateway.list(*, account_id) -> Optional[GatewayListResponse]

AuditSSHSettings

Types:

from cloudflare.types.zero_trust.gateway import GatewaySettings

Methods:

client.zero_trust.gateway.audit_ssh_settings.update(*, account_id, **params) -> Optional[GatewaySettings]
client.zero_trust.gateway.audit_ssh_settings.get(*, account_id) -> Optional[GatewaySettings]
client.zero_trust.gateway.audit_ssh_settings.rotate_seed(*, account_id) -> Optional[GatewaySettings]

AppTypes

Types:

from cloudflare.types.zero_trust.gateway import AppType

Methods:

client.zero_trust.gateway.app_types.list(*, account_id) -> SyncSinglePage[AppType]

Configurations

Types:

from cloudflare.types.zero_trust.gateway import (
    ActivityLogSettings,
    AntiVirusSettings,
    BlockPageSettings,
    BodyScanningSettings,
    BrowserIsolationSettings,
    CustomCertificateSettings,
    ExtendedEmailMatching,
    FipsSettings,
    GatewayConfigurationSettings,
    NotificationSettings,
    ProtocolDetection,
    TLSSettings,
    ConfigurationUpdateResponse,
    ConfigurationEditResponse,
    ConfigurationGetResponse,
)

Methods:

client.zero_trust.gateway.configurations.update(*, account_id, **params) -> Optional[ConfigurationUpdateResponse]
client.zero_trust.gateway.configurations.edit(*, account_id, **params) -> Optional[ConfigurationEditResponse]
client.zero_trust.gateway.configurations.get(*, account_id) -> Optional[ConfigurationGetResponse]

CustomCertificate

Methods:

client.zero_trust.gateway.configurations.custom_certificate.get(*, account_id) -> CustomCertificateSettings

Lists

Types:

from cloudflare.types.zero_trust.gateway import (
    GatewayItem,
    GatewayList,
    ListCreateResponse,
    ListDeleteResponse,
)

Methods:

client.zero_trust.gateway.lists.create(*, account_id, **params) -> Optional[ListCreateResponse]
client.zero_trust.gateway.lists.update(list_id, *, account_id, **params) -> Optional[GatewayList]
client.zero_trust.gateway.lists.list(*, account_id, **params) -> SyncSinglePage[GatewayList]
client.zero_trust.gateway.lists.delete(list_id, *, account_id) -> object
client.zero_trust.gateway.lists.edit(list_id, *, account_id, **params) -> Optional[GatewayList]
client.zero_trust.gateway.lists.get(list_id, *, account_id) -> Optional[GatewayList]

Items

Types:

from cloudflare.types.zero_trust.gateway.lists import ItemListResponse

Methods:

client.zero_trust.gateway.lists.items.list(list_id, *, account_id) -> SyncSinglePage[ItemListResponse]

Locations

Types:

from cloudflare.types.zero_trust.gateway import (
    DOHEndpoint,
    DOTEndpoint,
    Endpoint,
    IPNetwork,
    IPV4Endpoint,
    IPV6Endpoint,
    IPV6Network,
    Location,
    LocationDeleteResponse,
)

Methods:

client.zero_trust.gateway.locations.create(*, account_id, **params) -> Optional[Location]
client.zero_trust.gateway.locations.update(location_id, *, account_id, **params) -> Optional[Location]
client.zero_trust.gateway.locations.list(*, account_id) -> SyncSinglePage[Location]
client.zero_trust.gateway.locations.delete(location_id, *, account_id) -> object
client.zero_trust.gateway.locations.get(location_id, *, account_id) -> Optional[Location]

Logging

Types:

from cloudflare.types.zero_trust.gateway import LoggingSetting

Methods:

client.zero_trust.gateway.logging.update(*, account_id, **params) -> Optional[LoggingSetting]
client.zero_trust.gateway.logging.get(*, account_id) -> Optional[LoggingSetting]

ProxyEndpoints

Types:

from cloudflare.types.zero_trust.gateway import (
    GatewayIPs,
    ProxyEndpoint,
    ProxyEndpointDeleteResponse,
)

Methods:

client.zero_trust.gateway.proxy_endpoints.create(*, account_id, **params) -> Optional[ProxyEndpoint]
client.zero_trust.gateway.proxy_endpoints.list(*, account_id) -> Optional[ProxyEndpoint]
client.zero_trust.gateway.proxy_endpoints.delete(proxy_endpoint_id, *, account_id) -> object
client.zero_trust.gateway.proxy_endpoints.edit(proxy_endpoint_id, *, account_id, **params) -> Optional[ProxyEndpoint]
client.zero_trust.gateway.proxy_endpoints.get(proxy_endpoint_id, *, account_id) -> SyncSinglePage[ProxyEndpoint]

Rules

Types:

from cloudflare.types.zero_trust.gateway import (
    DNSResolverSettingsV4,
    DNSResolverSettingsV6,
    GatewayFilter,
    GatewayRule,
    RuleSetting,
    Schedule,
    RuleDeleteResponse,
)

Methods:

client.zero_trust.gateway.rules.create(*, account_id, **params) -> Optional[GatewayRule]
client.zero_trust.gateway.rules.update(rule_id, *, account_id, **params) -> Optional[GatewayRule]
client.zero_trust.gateway.rules.list(*, account_id) -> SyncSinglePage[GatewayRule]
client.zero_trust.gateway.rules.delete(rule_id, *, account_id) -> object
client.zero_trust.gateway.rules.get(rule_id, *, account_id) -> Optional[GatewayRule]
client.zero_trust.gateway.rules.reset_expiration(rule_id, *, account_id) -> Optional[GatewayRule]

Certificates

Types:

from cloudflare.types.zero_trust.gateway import (
    CertificateCreateResponse,
    CertificateListResponse,
    CertificateDeleteResponse,
    CertificateActivateResponse,
    CertificateDeactivateResponse,
    CertificateGetResponse,
)

Methods:

client.zero_trust.gateway.certificates.create(*, account_id, **params) -> Optional[CertificateCreateResponse]
client.zero_trust.gateway.certificates.list(*, account_id) -> SyncSinglePage[CertificateListResponse]
client.zero_trust.gateway.certificates.delete(certificate_id, *, account_id) -> Optional[CertificateDeleteResponse]
client.zero_trust.gateway.certificates.activate(certificate_id, *, account_id, **params) -> Optional[CertificateActivateResponse]
client.zero_trust.gateway.certificates.deactivate(certificate_id, *, account_id, **params) -> Optional[CertificateDeactivateResponse]
client.zero_trust.gateway.certificates.get(certificate_id, *, account_id) -> Optional[CertificateGetResponse]

Networks

Routes

Types:

from cloudflare.types.zero_trust.networks import NetworkRoute, Route, Teamnet

Methods:

client.zero_trust.networks.routes.create(*, account_id, **params) -> Route
client.zero_trust.networks.routes.list(*, account_id, **params) -> SyncV4PagePaginationArray[Teamnet]
client.zero_trust.networks.routes.delete(route_id, *, account_id) -> Route
client.zero_trust.networks.routes.edit(route_id, *, account_id, **params) -> Route
client.zero_trust.networks.routes.get(route_id, *, account_id) -> Route

IPs

Methods:

client.zero_trust.networks.routes.ips.get(ip, *, account_id, **params) -> Teamnet

Networks

Methods:

client.zero_trust.networks.routes.networks.create(ip_network_encoded, *, account_id, **params) -> Route
client.zero_trust.networks.routes.networks.delete(ip_network_encoded, *, account_id, **params) -> Route
client.zero_trust.networks.routes.networks.edit(ip_network_encoded, *, account_id) -> Route

VirtualNetworks

Types:

from cloudflare.types.zero_trust.networks import VirtualNetwork

Methods:

client.zero_trust.networks.virtual_networks.create(*, account_id, **params) -> VirtualNetwork
client.zero_trust.networks.virtual_networks.list(*, account_id, **params) -> SyncSinglePage[VirtualNetwork]
client.zero_trust.networks.virtual_networks.delete(virtual_network_id, *, account_id) -> VirtualNetwork
client.zero_trust.networks.virtual_networks.edit(virtual_network_id, *, account_id, **params) -> VirtualNetwork
client.zero_trust.networks.virtual_networks.get(virtual_network_id, *, account_id) -> VirtualNetwork

Subnets

Types:

from cloudflare.types.zero_trust.networks import SubnetListResponse

Methods:

client.zero_trust.networks.subnets.list(*, account_id, **params) -> SyncV4PagePaginationArray[SubnetListResponse]

CloudflareSource

Types:

from cloudflare.types.zero_trust.networks.subnets import CloudflareSourceUpdateResponse

Methods:

client.zero_trust.networks.subnets.cloudflare_source.update(address_family, *, account_id, **params) -> CloudflareSourceUpdateResponse

RiskScoring

Types:

from cloudflare.types.zero_trust import RiskScoringGetResponse, RiskScoringResetResponse

Methods:

client.zero_trust.risk_scoring.get(user_id, *, account_id) -> Optional[RiskScoringGetResponse]
client.zero_trust.risk_scoring.reset(user_id, *, account_id) -> object

Behaviours

Types:

from cloudflare.types.zero_trust.risk_scoring import BehaviourUpdateResponse, BehaviourGetResponse

Methods:

client.zero_trust.risk_scoring.behaviours.update(*, account_id, **params) -> Optional[BehaviourUpdateResponse]
client.zero_trust.risk_scoring.behaviours.get(*, account_id) -> Optional[BehaviourGetResponse]

Summary

Types:

from cloudflare.types.zero_trust.risk_scoring import SummaryGetResponse

Methods:

client.zero_trust.risk_scoring.summary.get(*, account_id) -> Optional[SummaryGetResponse]

Integrations

Types:

from cloudflare.types.zero_trust.risk_scoring import (
    IntegrationCreateResponse,
    IntegrationUpdateResponse,
    IntegrationListResponse,
    IntegrationDeleteResponse,
    IntegrationGetResponse,
)

Methods:

client.zero_trust.risk_scoring.integrations.create(*, account_id, **params) -> Optional[IntegrationCreateResponse]
client.zero_trust.risk_scoring.integrations.update(integration_id, *, account_id, **params) -> Optional[IntegrationUpdateResponse]
client.zero_trust.risk_scoring.integrations.list(*, account_id) -> SyncSinglePage[IntegrationListResponse]
client.zero_trust.risk_scoring.integrations.delete(integration_id, *, account_id) -> object
client.zero_trust.risk_scoring.integrations.get(integration_id, *, account_id) -> Optional[IntegrationGetResponse]

References

Types:

from cloudflare.types.zero_trust.risk_scoring.integrations import ReferenceGetResponse

Methods:

client.zero_trust.risk_scoring.integrations.references.get(reference_id, *, account_id) -> Optional[ReferenceGetResponse]

Turnstile

Widgets

Types:

from cloudflare.types.turnstile import Widget, WidgetDomain, WidgetListResponse

Methods:

client.turnstile.widgets.create(*, account_id, **params) -> Optional[Widget]
client.turnstile.widgets.update(sitekey, *, account_id, **params) -> Optional[Widget]
client.turnstile.widgets.list(*, account_id, **params) -> SyncV4PagePaginationArray[WidgetListResponse]
client.turnstile.widgets.delete(sitekey, *, account_id) -> Optional[Widget]
client.turnstile.widgets.get(sitekey, *, account_id) -> Optional[Widget]
client.turnstile.widgets.rotate_secret(sitekey, *, account_id, **params) -> Optional[Widget]

Hyperdrive

Types:

from cloudflare.types.hyperdrive import Configuration, Hyperdrive

Configs

Types:

from cloudflare.types.hyperdrive import ConfigDeleteResponse

Methods:

client.hyperdrive.configs.create(*, account_id, **params) -> Hyperdrive
client.hyperdrive.configs.update(hyperdrive_id, *, account_id, **params) -> Hyperdrive
client.hyperdrive.configs.list(*, account_id) -> SyncSinglePage[Hyperdrive]
client.hyperdrive.configs.delete(hyperdrive_id, *, account_id) -> object
client.hyperdrive.configs.edit(hyperdrive_id, *, account_id, **params) -> Hyperdrive
client.hyperdrive.configs.get(hyperdrive_id, *, account_id) -> Hyperdrive

RUM

SiteInfo

Types:

from cloudflare.types.rum import Site, SiteInfoDeleteResponse

Methods:

client.rum.site_info.create(*, account_id, **params) -> Optional[Site]
client.rum.site_info.update(site_id, *, account_id, **params) -> Optional[Site]
client.rum.site_info.list(*, account_id, **params) -> SyncV4PagePaginationArray[Site]
client.rum.site_info.delete(site_id, *, account_id) -> Optional[SiteInfoDeleteResponse]
client.rum.site_info.get(site_id, *, account_id) -> Optional[Site]

Rules

Types:

from cloudflare.types.rum import (
    RUMRule,
    RuleListResponse,
    RuleDeleteResponse,
    RuleBulkCreateResponse,
)

Methods:

client.rum.rules.create(ruleset_id, *, account_id, **params) -> Optional[RUMRule]
client.rum.rules.update(rule_id, *, account_id, ruleset_id, **params) -> Optional[RUMRule]
client.rum.rules.list(ruleset_id, *, account_id) -> Optional[RuleListResponse]
client.rum.rules.delete(rule_id, *, account_id, ruleset_id) -> Optional[RuleDeleteResponse]
client.rum.rules.bulk_create(ruleset_id, *, account_id, **params) -> Optional[RuleBulkCreateResponse]

Vectorize

Indexes

Types:

from cloudflare.types.vectorize import (
    CreateIndex,
    IndexDeleteVectorsByID,
    IndexDimensionConfiguration,
    IndexInsert,
    IndexQuery,
    IndexUpsert,
    IndexDeleteResponse,
    IndexDeleteByIDsResponse,
    IndexGetByIDsResponse,
    IndexInfoResponse,
    IndexInsertResponse,
    IndexQueryResponse,
    IndexUpsertResponse,
)

Methods:

client.vectorize.indexes.create(*, account_id, **params) -> Optional[CreateIndex]
client.vectorize.indexes.list(*, account_id) -> SyncSinglePage[CreateIndex]
client.vectorize.indexes.delete(index_name, *, account_id) -> Optional[IndexDeleteResponse]
client.vectorize.indexes.delete_by_ids(index_name, *, account_id, **params) -> Optional[IndexDeleteByIDsResponse]
client.vectorize.indexes.get(index_name, *, account_id) -> Optional[CreateIndex]
client.vectorize.indexes.get_by_ids(index_name, *, account_id, **params) -> object
client.vectorize.indexes.info(index_name, *, account_id) -> Optional[IndexInfoResponse]
client.vectorize.indexes.insert(index_name, *, account_id, **params) -> Optional[IndexInsertResponse]
client.vectorize.indexes.query(index_name, *, account_id, **params) -> Optional[IndexQueryResponse]
client.vectorize.indexes.upsert(index_name, *, account_id, **params) -> Optional[IndexUpsertResponse]

MetadataIndex

Types:

from cloudflare.types.vectorize.indexes import (
    MetadataIndexCreateResponse,
    MetadataIndexListResponse,
    MetadataIndexDeleteResponse,
)

Methods:

client.vectorize.indexes.metadata_index.create(index_name, *, account_id, **params) -> Optional[MetadataIndexCreateResponse]
client.vectorize.indexes.metadata_index.list(index_name, *, account_id) -> Optional[MetadataIndexListResponse]
client.vectorize.indexes.metadata_index.delete(index_name, *, account_id, **params) -> Optional[MetadataIndexDeleteResponse]

URLScanner

Types:

from cloudflare.types.url_scanner import URLScannerDomain, URLScannerTask

Responses

Types:

from cloudflare.types.url_scanner import ResponseGetResponse

Methods:

client.url_scanner.responses.get(response_id, *, account_id) -> str

Scans

Types:

from cloudflare.types.url_scanner import (
    ScanCreateResponse,
    ScanListResponse,
    ScanBulkCreateResponse,
    ScanDOMResponse,
    ScanGetResponse,
    ScanHARResponse,
)

Methods:

client.url_scanner.scans.create(*, account_id, **params) -> str
client.url_scanner.scans.list(*, account_id, **params) -> ScanListResponse
client.url_scanner.scans.bulk_create(*, account_id, **params) -> ScanBulkCreateResponse
client.url_scanner.scans.dom(scan_id, *, account_id) -> str
client.url_scanner.scans.get(scan_id, *, account_id) -> ScanGetResponse
client.url_scanner.scans.har(scan_id, *, account_id) -> ScanHARResponse
client.url_scanner.scans.screenshot(scan_id, *, account_id, **params) -> BinaryAPIResponse

Radar

AI

Inference

Summary

Types:

from cloudflare.types.radar.ai.inference import SummaryModelResponse, SummaryTaskResponse

Methods:

client.radar.ai.inference.summary.model(**params) -> SummaryModelResponse
client.radar.ai.inference.summary.task(**params) -> SummaryTaskResponse

TimeseriesGroups

Summary

Types:

from cloudflare.types.radar.ai.inference.timeseries_groups import (
    SummaryModelResponse,
    SummaryTaskResponse,
)

Methods:

client.radar.ai.inference.timeseries_groups.summary.model(**params) -> SummaryModelResponse
client.radar.ai.inference.timeseries_groups.summary.task(**params) -> SummaryTaskResponse

Bots

Summary

Types:

from cloudflare.types.radar.ai.bots import SummaryUserAgentResponse

Methods:

client.radar.ai.bots.summary.user_agent(**params) -> SummaryUserAgentResponse

TimeseriesGroups

Types:

from cloudflare.types.radar.ai import TimeseriesGroupUserAgentResponse

Methods:

client.radar.ai.timeseries_groups.user_agent(**params) -> TimeseriesGroupUserAgentResponse

Annotations

Types:

from cloudflare.types.radar import AnnotationListResponse

Methods:

client.radar.annotations.list(**params) -> AnnotationListResponse

Outages

Types:

from cloudflare.types.radar.annotations import OutageGetResponse, OutageLocationsResponse

Methods:

client.radar.annotations.outages.get(**params) -> OutageGetResponse
client.radar.annotations.outages.locations(**params) -> OutageLocationsResponse

BGP

Types:

from cloudflare.types.radar import BGPTimeseriesResponse

Methods:

client.radar.bgp.timeseries(**params) -> BGPTimeseriesResponse

Leaks

Events

Types:

from cloudflare.types.radar.bgp.leaks import EventListResponse

Methods:

client.radar.bgp.leaks.events.list(**params) -> SyncV4PagePagination[EventListResponse]

Top

Types:

from cloudflare.types.radar.bgp import TopPrefixesResponse

Methods:

client.radar.bgp.top.prefixes(**params) -> TopPrefixesResponse

Ases

Types:

from cloudflare.types.radar.bgp.top import AseGetResponse, AsePrefixesResponse

Methods:

client.radar.bgp.top.ases.get(**params) -> AseGetResponse
client.radar.bgp.top.ases.prefixes(**params) -> AsePrefixesResponse

Hijacks

Events

Types:

from cloudflare.types.radar.bgp.hijacks import EventListResponse

Methods:

client.radar.bgp.hijacks.events.list(**params) -> SyncV4PagePagination[EventListResponse]

Routes

Types:

from cloudflare.types.radar.bgp import (
    RouteAsesResponse,
    RouteMoasResponse,
    RoutePfx2asResponse,
    RouteStatsResponse,
)

Methods:

client.radar.bgp.routes.ases(**params) -> RouteAsesResponse
client.radar.bgp.routes.moas(**params) -> RouteMoasResponse
client.radar.bgp.routes.pfx2as(**params) -> RoutePfx2asResponse
client.radar.bgp.routes.stats(**params) -> RouteStatsResponse

IPs

Types:

from cloudflare.types.radar.bgp import IPTimeseriesResponse

Methods:

client.radar.bgp.ips.timeseries(**params) -> IPTimeseriesResponse

Datasets

Types:

from cloudflare.types.radar import DatasetListResponse, DatasetDownloadResponse, DatasetGetResponse

Methods:

client.radar.datasets.list(**params) -> DatasetListResponse
client.radar.datasets.download(**params) -> DatasetDownloadResponse
client.radar.datasets.get(alias) -> str

DNS

Types:

from cloudflare.types.radar import DNSTimeseriesResponse

Methods:

client.radar.dns.timeseries(**params) -> DNSTimeseriesResponse

Top

Types:

from cloudflare.types.radar.dns import TopAsesResponse, TopLocationsResponse

Methods:

client.radar.dns.top.ases(**params) -> TopAsesResponse
client.radar.dns.top.locations(**params) -> TopLocationsResponse

Summary

Types:

from cloudflare.types.radar.dns import (
    SummaryCacheHitResponse,
    SummaryDNSSECResponse,
    SummaryDNSSECAwareResponse,
    SummaryDNSSECE2EResponse,
    SummaryIPVersionResponse,
    SummaryMatchingAnswerResponse,
    SummaryProtocolResponse,
    SummaryQueryTypeResponse,
    SummaryResponseCodeResponse,
    SummaryResponseTTLResponse,
)

Methods:

client.radar.dns.summary.cache_hit(**params) -> SummaryCacheHitResponse
client.radar.dns.summary.dnssec(**params) -> SummaryDNSSECResponse
client.radar.dns.summary.dnssec_aware(**params) -> SummaryDNSSECAwareResponse
client.radar.dns.summary.dnssec_e2e(**params) -> SummaryDNSSECE2EResponse
client.radar.dns.summary.ip_version(**params) -> SummaryIPVersionResponse
client.radar.dns.summary.matching_answer(**params) -> SummaryMatchingAnswerResponse
client.radar.dns.summary.protocol(**params) -> SummaryProtocolResponse
client.radar.dns.summary.query_type(**params) -> SummaryQueryTypeResponse
client.radar.dns.summary.response_code(**params) -> SummaryResponseCodeResponse
client.radar.dns.summary.response_ttl(**params) -> SummaryResponseTTLResponse

TimeseriesGroups

Types:

from cloudflare.types.radar.dns import (
    TimeseriesGroupCacheHitResponse,
    TimeseriesGroupDNSSECResponse,
    TimeseriesGroupDNSSECAwareResponse,
    TimeseriesGroupDNSSECE2EResponse,
    TimeseriesGroupIPVersionResponse,
    TimeseriesGroupMatchingAnswerResponse,
    TimeseriesGroupProtocolResponse,
    TimeseriesGroupQueryTypeResponse,
    TimeseriesGroupResponseCodeResponse,
    TimeseriesGroupResponseTTLResponse,
)

Methods:

client.radar.dns.timeseries_groups.cache_hit(**params) -> TimeseriesGroupCacheHitResponse
client.radar.dns.timeseries_groups.dnssec(**params) -> TimeseriesGroupDNSSECResponse
client.radar.dns.timeseries_groups.dnssec_aware(**params) -> TimeseriesGroupDNSSECAwareResponse
client.radar.dns.timeseries_groups.dnssec_e2e(**params) -> TimeseriesGroupDNSSECE2EResponse
client.radar.dns.timeseries_groups.ip_version(**params) -> TimeseriesGroupIPVersionResponse
client.radar.dns.timeseries_groups.matching_answer(**params) -> TimeseriesGroupMatchingAnswerResponse
client.radar.dns.timeseries_groups.protocol(**params) -> TimeseriesGroupProtocolResponse
client.radar.dns.timeseries_groups.query_type(**params) -> TimeseriesGroupQueryTypeResponse
client.radar.dns.timeseries_groups.response_code(**params) -> TimeseriesGroupResponseCodeResponse
client.radar.dns.timeseries_groups.response_ttl(**params) -> TimeseriesGroupResponseTTLResponse

Netflows

Types:

from cloudflare.types.radar import NetflowSummaryResponse, NetflowTimeseriesResponse

Methods:

client.radar.netflows.summary(**params) -> NetflowSummaryResponse
client.radar.netflows.timeseries(**params) -> NetflowTimeseriesResponse

Top

Types:

from cloudflare.types.radar.netflows import TopAsesResponse, TopLocationsResponse

Methods:

client.radar.netflows.top.ases(**params) -> TopAsesResponse
client.radar.netflows.top.locations(**params) -> TopLocationsResponse

Search

Types:

from cloudflare.types.radar import SearchGlobalResponse

Methods:

client.radar.search.global_(**params) -> SearchGlobalResponse

VerifiedBots

Top

Types:

from cloudflare.types.radar.verified_bots import TopBotsResponse, TopCategoriesResponse

Methods:

client.radar.verified_bots.top.bots(**params) -> TopBotsResponse
client.radar.verified_bots.top.categories(**params) -> TopCategoriesResponse

AS112

Types:

from cloudflare.types.radar import AS112TimeseriesResponse

Methods:

client.radar.as112.timeseries(**params) -> AS112TimeseriesResponse

Summary

Types:

from cloudflare.types.radar.as112 import (
    SummaryDNSSECResponse,
    SummaryEdnsResponse,
    SummaryIPVersionResponse,
    SummaryProtocolResponse,
    SummaryQueryTypeResponse,
    SummaryResponseCodesResponse,
)

Methods:

client.radar.as112.summary.dnssec(**params) -> SummaryDNSSECResponse
client.radar.as112.summary.edns(**params) -> SummaryEdnsResponse
client.radar.as112.summary.ip_version(**params) -> SummaryIPVersionResponse
client.radar.as112.summary.protocol(**params) -> SummaryProtocolResponse
client.radar.as112.summary.query_type(**params) -> SummaryQueryTypeResponse
client.radar.as112.summary.response_codes(**params) -> SummaryResponseCodesResponse

TimeseriesGroups

Types:

from cloudflare.types.radar.as112 import (
    TimeseriesGroupDNSSECResponse,
    TimeseriesGroupEdnsResponse,
    TimeseriesGroupIPVersionResponse,
    TimeseriesGroupProtocolResponse,
    TimeseriesGroupQueryTypeResponse,
    TimeseriesGroupResponseCodesResponse,
)

Methods:

client.radar.as112.timeseries_groups.dnssec(**params) -> TimeseriesGroupDNSSECResponse
client.radar.as112.timeseries_groups.edns(**params) -> TimeseriesGroupEdnsResponse
client.radar.as112.timeseries_groups.ip_version(**params) -> TimeseriesGroupIPVersionResponse
client.radar.as112.timeseries_groups.protocol(**params) -> TimeseriesGroupProtocolResponse
client.radar.as112.timeseries_groups.query_type(**params) -> TimeseriesGroupQueryTypeResponse
client.radar.as112.timeseries_groups.response_codes(**params) -> TimeseriesGroupResponseCodesResponse

Top

Types:

from cloudflare.types.radar.as112 import (
    TopDNSSECResponse,
    TopEdnsResponse,
    TopIPVersionResponse,
    TopLocationsResponse,
)

Methods:

client.radar.as112.top.dnssec(dnssec, **params) -> TopDNSSECResponse
client.radar.as112.top.edns(edns, **params) -> TopEdnsResponse
client.radar.as112.top.ip_version(ip_version, **params) -> TopIPVersionResponse
client.radar.as112.top.locations(**params) -> TopLocationsResponse

Email

Types:

from cloudflare.types.radar import RadarEmailSeries, RadarEmailSummary

Routing

Summary

Types:

from cloudflare.types.radar.email.routing import (
    SummaryARCResponse,
    SummaryDKIMResponse,
    SummaryDMARCResponse,
    SummaryEncryptedResponse,
    SummaryIPVersionResponse,
    SummarySPFResponse,
)

Methods:

client.radar.email.routing.summary.arc(**params) -> SummaryARCResponse
client.radar.email.routing.summary.dkim(**params) -> SummaryDKIMResponse
client.radar.email.routing.summary.dmarc(**params) -> SummaryDMARCResponse
client.radar.email.routing.summary.encrypted(**params) -> SummaryEncryptedResponse
client.radar.email.routing.summary.ip_version(**params) -> SummaryIPVersionResponse
client.radar.email.routing.summary.spf(**params) -> SummarySPFResponse

TimeseriesGroups

Types:

from cloudflare.types.radar.email.routing import (
    TimeseriesGroupARCResponse,
    TimeseriesGroupDKIMResponse,
    TimeseriesGroupDMARCResponse,
    TimeseriesGroupEncryptedResponse,
    TimeseriesGroupIPVersionResponse,
    TimeseriesGroupSPFResponse,
)

Methods:

client.radar.email.routing.timeseries_groups.arc(**params) -> TimeseriesGroupARCResponse
client.radar.email.routing.timeseries_groups.dkim(**params) -> TimeseriesGroupDKIMResponse
client.radar.email.routing.timeseries_groups.dmarc(**params) -> TimeseriesGroupDMARCResponse
client.radar.email.routing.timeseries_groups.encrypted(**params) -> TimeseriesGroupEncryptedResponse
client.radar.email.routing.timeseries_groups.ip_version(**params) -> TimeseriesGroupIPVersionResponse
client.radar.email.routing.timeseries_groups.spf(**params) -> TimeseriesGroupSPFResponse

Security

Top

Tlds

Types:

from cloudflare.types.radar.email.security.top import TldGetResponse

Methods:

client.radar.email.security.top.tlds.get(**params) -> TldGetResponse

Malicious

Types:

from cloudflare.types.radar.email.security.top.tlds import MaliciousGetResponse

Methods:

client.radar.email.security.top.tlds.malicious.get(malicious, **params) -> MaliciousGetResponse

Spam

Types:

from cloudflare.types.radar.email.security.top.tlds import SpamGetResponse

Methods:

client.radar.email.security.top.tlds.spam.get(spam, **params) -> SpamGetResponse

Spoof

Types:

from cloudflare.types.radar.email.security.top.tlds import SpoofGetResponse

Methods:

client.radar.email.security.top.tlds.spoof.get(spoof, **params) -> SpoofGetResponse

Summary

Types:

from cloudflare.types.radar.email.security import (
    SummaryARCResponse,
    SummaryDKIMResponse,
    SummaryDMARCResponse,
    SummaryMaliciousResponse,
    SummarySpamResponse,
    SummarySPFResponse,
    SummarySpoofResponse,
    SummaryThreatCategoryResponse,
    SummaryTLSVersionResponse,
)

Methods:

client.radar.email.security.summary.arc(**params) -> SummaryARCResponse
client.radar.email.security.summary.dkim(**params) -> SummaryDKIMResponse
client.radar.email.security.summary.dmarc(**params) -> SummaryDMARCResponse
client.radar.email.security.summary.malicious(**params) -> SummaryMaliciousResponse
client.radar.email.security.summary.spam(**params) -> SummarySpamResponse
client.radar.email.security.summary.spf(**params) -> SummarySPFResponse
client.radar.email.security.summary.spoof(**params) -> SummarySpoofResponse
client.radar.email.security.summary.threat_category(**params) -> SummaryThreatCategoryResponse
client.radar.email.security.summary.tls_version(**params) -> SummaryTLSVersionResponse

TimeseriesGroups

Types:

from cloudflare.types.radar.email.security import (
    TimeseriesGroupARCResponse,
    TimeseriesGroupDKIMResponse,
    TimeseriesGroupDMARCResponse,
    TimeseriesGroupMaliciousResponse,
    TimeseriesGroupSpamResponse,
    TimeseriesGroupSPFResponse,
    TimeseriesGroupSpoofResponse,
    TimeseriesGroupThreatCategoryResponse,
    TimeseriesGroupTLSVersionResponse,
)

Methods:

client.radar.email.security.timeseries_groups.arc(**params) -> TimeseriesGroupARCResponse
client.radar.email.security.timeseries_groups.dkim(**params) -> TimeseriesGroupDKIMResponse
client.radar.email.security.timeseries_groups.dmarc(**params) -> TimeseriesGroupDMARCResponse
client.radar.email.security.timeseries_groups.malicious(**params) -> TimeseriesGroupMaliciousResponse
client.radar.email.security.timeseries_groups.spam(**params) -> TimeseriesGroupSpamResponse
client.radar.email.security.timeseries_groups.spf(**params) -> TimeseriesGroupSPFResponse
client.radar.email.security.timeseries_groups.spoof(**params) -> TimeseriesGroupSpoofResponse
client.radar.email.security.timeseries_groups.threat_category(**params) -> TimeseriesGroupThreatCategoryResponse
client.radar.email.security.timeseries_groups.tls_version(**params) -> TimeseriesGroupTLSVersionResponse

Attacks

Layer3

Types:

from cloudflare.types.radar.attacks import Layer3TimeseriesResponse

Methods:

client.radar.attacks.layer3.timeseries(**params) -> Layer3TimeseriesResponse

Summary

Types:

from cloudflare.types.radar.attacks.layer3 import (
    SummaryBitrateResponse,
    SummaryDurationResponse,
    SummaryIPVersionResponse,
    SummaryProtocolResponse,
    SummaryVectorResponse,
)

Methods:

client.radar.attacks.layer3.summary.bitrate(**params) -> SummaryBitrateResponse
client.radar.attacks.layer3.summary.duration(**params) -> SummaryDurationResponse
client.radar.attacks.layer3.summary.ip_version(**params) -> SummaryIPVersionResponse
client.radar.attacks.layer3.summary.protocol(**params) -> SummaryProtocolResponse
client.radar.attacks.layer3.summary.vector(**params) -> SummaryVectorResponse

TimeseriesGroups

Types:

from cloudflare.types.radar.attacks.layer3 import (
    TimeseriesGroupBitrateResponse,
    TimeseriesGroupDurationResponse,
    TimeseriesGroupIndustryResponse,
    TimeseriesGroupIPVersionResponse,
    TimeseriesGroupProtocolResponse,
    TimeseriesGroupVectorResponse,
    TimeseriesGroupVerticalResponse,
)

Methods:

client.radar.attacks.layer3.timeseries_groups.bitrate(**params) -> TimeseriesGroupBitrateResponse
client.radar.attacks.layer3.timeseries_groups.duration(**params) -> TimeseriesGroupDurationResponse
client.radar.attacks.layer3.timeseries_groups.industry(**params) -> TimeseriesGroupIndustryResponse
client.radar.attacks.layer3.timeseries_groups.ip_version(**params) -> TimeseriesGroupIPVersionResponse
client.radar.attacks.layer3.timeseries_groups.protocol(**params) -> TimeseriesGroupProtocolResponse
client.radar.attacks.layer3.timeseries_groups.vector(**params) -> TimeseriesGroupVectorResponse
client.radar.attacks.layer3.timeseries_groups.vertical(**params) -> TimeseriesGroupVerticalResponse

Top

Types:

from cloudflare.types.radar.attacks.layer3 import (
    TopAttacksResponse,
    TopIndustryResponse,
    TopVerticalResponse,
)

Methods:

client.radar.attacks.layer3.top.attacks(**params) -> TopAttacksResponse
client.radar.attacks.layer3.top.industry(**params) -> TopIndustryResponse
client.radar.attacks.layer3.top.vertical(**params) -> TopVerticalResponse

Locations

Types:

from cloudflare.types.radar.attacks.layer3.top import LocationOriginResponse, LocationTargetResponse

Methods:

client.radar.attacks.layer3.top.locations.origin(**params) -> LocationOriginResponse
client.radar.attacks.layer3.top.locations.target(**params) -> LocationTargetResponse

Layer7

Types:

from cloudflare.types.radar.attacks import Layer7TimeseriesResponse

Methods:

client.radar.attacks.layer7.timeseries(**params) -> Layer7TimeseriesResponse

Summary

Types:

from cloudflare.types.radar.attacks.layer7 import (
    SummaryHTTPMethodResponse,
    SummaryHTTPVersionResponse,
    SummaryIPVersionResponse,
    SummaryManagedRulesResponse,
    SummaryMitigationProductResponse,
)

Methods:

client.radar.attacks.layer7.summary.http_method(**params) -> SummaryHTTPMethodResponse
client.radar.attacks.layer7.summary.http_version(**params) -> SummaryHTTPVersionResponse
client.radar.attacks.layer7.summary.ip_version(**params) -> SummaryIPVersionResponse
client.radar.attacks.layer7.summary.managed_rules(**params) -> SummaryManagedRulesResponse
client.radar.attacks.layer7.summary.mitigation_product(**params) -> SummaryMitigationProductResponse

TimeseriesGroups

Types:

from cloudflare.types.radar.attacks.layer7 import (
    TimeseriesGroupHTTPMethodResponse,
    TimeseriesGroupHTTPVersionResponse,
    TimeseriesGroupIndustryResponse,
    TimeseriesGroupIPVersionResponse,
    TimeseriesGroupManagedRulesResponse,
    TimeseriesGroupMitigationProductResponse,
    TimeseriesGroupVerticalResponse,
)

Methods:

client.radar.attacks.layer7.timeseries_groups.http_method(**params) -> TimeseriesGroupHTTPMethodResponse
client.radar.attacks.layer7.timeseries_groups.http_version(**params) -> TimeseriesGroupHTTPVersionResponse
client.radar.attacks.layer7.timeseries_groups.industry(**params) -> TimeseriesGroupIndustryResponse
client.radar.attacks.layer7.timeseries_groups.ip_version(**params) -> TimeseriesGroupIPVersionResponse
client.radar.attacks.layer7.timeseries_groups.managed_rules(**params) -> TimeseriesGroupManagedRulesResponse
client.radar.attacks.layer7.timeseries_groups.mitigation_product(**params) -> TimeseriesGroupMitigationProductResponse
client.radar.attacks.layer7.timeseries_groups.vertical(**params) -> TimeseriesGroupVerticalResponse

Top

Types:

from cloudflare.types.radar.attacks.layer7 import (
    TopAttacksResponse,
    TopIndustryResponse,
    TopVerticalResponse,
)

Methods:

client.radar.attacks.layer7.top.attacks(**params) -> TopAttacksResponse
client.radar.attacks.layer7.top.industry(**params) -> TopIndustryResponse
client.radar.attacks.layer7.top.vertical(**params) -> TopVerticalResponse

Locations

Types:

from cloudflare.types.radar.attacks.layer7.top import LocationOriginResponse, LocationTargetResponse

Methods:

client.radar.attacks.layer7.top.locations.origin(**params) -> LocationOriginResponse
client.radar.attacks.layer7.top.locations.target(**params) -> LocationTargetResponse

Ases

Types:

from cloudflare.types.radar.attacks.layer7.top import AseOriginResponse

Methods:

client.radar.attacks.layer7.top.ases.origin(**params) -> AseOriginResponse

Entities

Types:

from cloudflare.types.radar import EntityGetResponse

Methods:

client.radar.entities.get(**params) -> EntityGetResponse

ASNs

Types:

from cloudflare.types.radar.entities import (
    ASNListResponse,
    ASNGetResponse,
    ASNIPResponse,
    ASNRelResponse,
)

Methods:

client.radar.entities.asns.list(**params) -> ASNListResponse
client.radar.entities.asns.get(asn, **params) -> ASNGetResponse
client.radar.entities.asns.ip(**params) -> ASNIPResponse
client.radar.entities.asns.rel(asn, **params) -> ASNRelResponse

Locations

Types:

from cloudflare.types.radar.entities import LocationListResponse, LocationGetResponse

Methods:

client.radar.entities.locations.list(**params) -> LocationListResponse
client.radar.entities.locations.get(location, **params) -> LocationGetResponse

HTTP

Types:

from cloudflare.types.radar import HTTPTimeseriesResponse

Methods:

client.radar.http.timeseries(**params) -> HTTPTimeseriesResponse

Locations

Types:

from cloudflare.types.radar.http import LocationGetResponse

Methods:

client.radar.http.locations.get(**params) -> LocationGetResponse

BotClass

Types:

from cloudflare.types.radar.http.locations import BotClassGetResponse

Methods:

client.radar.http.locations.bot_class.get(bot_class, **params) -> BotClassGetResponse

DeviceType

Types:

from cloudflare.types.radar.http.locations import DeviceTypeGetResponse

Methods:

client.radar.http.locations.device_type.get(device_type, **params) -> DeviceTypeGetResponse

HTTPProtocol

Types:

from cloudflare.types.radar.http.locations import HTTPProtocolGetResponse

Methods:

client.radar.http.locations.http_protocol.get(http_protocol, **params) -> HTTPProtocolGetResponse

HTTPMethod

Types:

from cloudflare.types.radar.http.locations import HTTPMethodGetResponse

Methods:

client.radar.http.locations.http_method.get(http_version, **params) -> HTTPMethodGetResponse

IPVersion

Types:

from cloudflare.types.radar.http.locations import IPVersionGetResponse

Methods:

client.radar.http.locations.ip_version.get(ip_version, **params) -> IPVersionGetResponse

OS

Types:

from cloudflare.types.radar.http.locations import OSGetResponse

Methods:

client.radar.http.locations.os.get(os, **params) -> OSGetResponse

TLSVersion

Types:

from cloudflare.types.radar.http.locations import TLSVersionGetResponse

Methods:

client.radar.http.locations.tls_version.get(tls_version, **params) -> TLSVersionGetResponse

BrowserFamily

Types:

from cloudflare.types.radar.http.locations import BrowserFamilyGetResponse

Methods:

client.radar.http.locations.browser_family.get(browser_family, **params) -> BrowserFamilyGetResponse

Ases

Types:

from cloudflare.types.radar.http import AseGetResponse

Methods:

client.radar.http.ases.get(**params) -> AseGetResponse

BotClass

Types:

from cloudflare.types.radar.http.ases import BotClassGetResponse

Methods:

client.radar.http.ases.bot_class.get(bot_class, **params) -> BotClassGetResponse

DeviceType

Types:

from cloudflare.types.radar.http.ases import DeviceTypeGetResponse

Methods:

client.radar.http.ases.device_type.get(device_type, **params) -> DeviceTypeGetResponse

HTTPProtocol

Types:

from cloudflare.types.radar.http.ases import HTTPProtocolGetResponse

Methods:

client.radar.http.ases.http_protocol.get(http_protocol, **params) -> HTTPProtocolGetResponse

HTTPMethod

Types:

from cloudflare.types.radar.http.ases import HTTPMethodGetResponse

Methods:

client.radar.http.ases.http_method.get(http_version, **params) -> HTTPMethodGetResponse

IPVersion

Types:

from cloudflare.types.radar.http.ases import IPVersionGetResponse

Methods:

client.radar.http.ases.ip_version.get(ip_version, **params) -> IPVersionGetResponse

OS

Types:

from cloudflare.types.radar.http.ases import OSGetResponse

Methods:

client.radar.http.ases.os.get(os, **params) -> OSGetResponse

TLSVersion

Types:

from cloudflare.types.radar.http.ases import TLSVersionGetResponse

Methods:

client.radar.http.ases.tls_version.get(tls_version, **params) -> TLSVersionGetResponse

BrowserFamily

Types:

from cloudflare.types.radar.http.ases import BrowserFamilyGetResponse

Methods:

client.radar.http.ases.browser_family.get(browser_family, **params) -> BrowserFamilyGetResponse

Summary

Types:

from cloudflare.types.radar.http import (
    SummaryBotClassResponse,
    SummaryDeviceTypeResponse,
    SummaryHTTPProtocolResponse,
    SummaryHTTPVersionResponse,
    SummaryIPVersionResponse,
    SummaryOSResponse,
    SummaryPostQuantumResponse,
    SummaryTLSVersionResponse,
)

Methods:

client.radar.http.summary.bot_class(**params) -> SummaryBotClassResponse
client.radar.http.summary.device_type(**params) -> SummaryDeviceTypeResponse
client.radar.http.summary.http_protocol(**params) -> SummaryHTTPProtocolResponse
client.radar.http.summary.http_version(**params) -> SummaryHTTPVersionResponse
client.radar.http.summary.ip_version(**params) -> SummaryIPVersionResponse
client.radar.http.summary.os(**params) -> SummaryOSResponse
client.radar.http.summary.post_quantum(**params) -> SummaryPostQuantumResponse
client.radar.http.summary.tls_version(**params) -> SummaryTLSVersionResponse

TimeseriesGroups

Types:

from cloudflare.types.radar.http import (
    TimeseriesGroupBotClassResponse,
    TimeseriesGroupBrowserResponse,
    TimeseriesGroupBrowserFamilyResponse,
    TimeseriesGroupDeviceTypeResponse,
    TimeseriesGroupHTTPProtocolResponse,
    TimeseriesGroupHTTPVersionResponse,
    TimeseriesGroupIPVersionResponse,
    TimeseriesGroupOSResponse,
    TimeseriesGroupPostQuantumResponse,
    TimeseriesGroupTLSVersionResponse,
)

Methods:

client.radar.http.timeseries_groups.bot_class(**params) -> TimeseriesGroupBotClassResponse
client.radar.http.timeseries_groups.browser(**params) -> TimeseriesGroupBrowserResponse
client.radar.http.timeseries_groups.browser_family(**params) -> TimeseriesGroupBrowserFamilyResponse
client.radar.http.timeseries_groups.device_type(**params) -> TimeseriesGroupDeviceTypeResponse
client.radar.http.timeseries_groups.http_protocol(**params) -> TimeseriesGroupHTTPProtocolResponse
client.radar.http.timeseries_groups.http_version(**params) -> TimeseriesGroupHTTPVersionResponse
client.radar.http.timeseries_groups.ip_version(**params) -> TimeseriesGroupIPVersionResponse
client.radar.http.timeseries_groups.os(**params) -> TimeseriesGroupOSResponse
client.radar.http.timeseries_groups.post_quantum(**params) -> TimeseriesGroupPostQuantumResponse
client.radar.http.timeseries_groups.tls_version(**params) -> TimeseriesGroupTLSVersionResponse

Top

Types:

from cloudflare.types.radar.http import TopBrowserResponse, TopBrowserFamilyResponse

Methods:

client.radar.http.top.browser(**params) -> TopBrowserResponse
client.radar.http.top.browser_family(**params) -> TopBrowserFamilyResponse

Quality

IQI

Types:

from cloudflare.types.radar.quality import IQISummaryResponse, IQITimeseriesGroupsResponse

Methods:

client.radar.quality.iqi.summary(**params) -> IQISummaryResponse
client.radar.quality.iqi.timeseries_groups(**params) -> IQITimeseriesGroupsResponse

Speed

Types:

from cloudflare.types.radar.quality import SpeedHistogramResponse, SpeedSummaryResponse

Methods:

client.radar.quality.speed.histogram(**params) -> SpeedHistogramResponse
client.radar.quality.speed.summary(**params) -> SpeedSummaryResponse

Top

Types:

from cloudflare.types.radar.quality.speed import TopAsesResponse, TopLocationsResponse

Methods:

client.radar.quality.speed.top.ases(**params) -> TopAsesResponse
client.radar.quality.speed.top.locations(**params) -> TopLocationsResponse

Ranking

Types:

from cloudflare.types.radar import RankingTimeseriesGroupsResponse, RankingTopResponse

Methods:

client.radar.ranking.timeseries_groups(**params) -> RankingTimeseriesGroupsResponse
client.radar.ranking.top(**params) -> RankingTopResponse

Domain

Types:

from cloudflare.types.radar.ranking import DomainGetResponse

Methods:

client.radar.ranking.domain.get(domain, **params) -> DomainGetResponse

InternetServices

Types:

from cloudflare.types.radar.ranking import (
    InternetServiceCategoriesResponse,
    InternetServiceTimeseriesGroupsResponse,
    InternetServiceTopResponse,
)

Methods:

client.radar.ranking.internet_services.categories(**params) -> InternetServiceCategoriesResponse
client.radar.ranking.internet_services.timeseries_groups(**params) -> InternetServiceTimeseriesGroupsResponse
client.radar.ranking.internet_services.top(**params) -> InternetServiceTopResponse

TrafficAnomalies

Types:

from cloudflare.types.radar import TrafficAnomalyGetResponse

Methods:

client.radar.traffic_anomalies.get(**params) -> TrafficAnomalyGetResponse

Locations

Types:

from cloudflare.types.radar.traffic_anomalies import LocationGetResponse

Methods:

client.radar.traffic_anomalies.locations.get(**params) -> LocationGetResponse

TCPResetsTimeouts

Types:

from cloudflare.types.radar import (
    TCPResetsTimeoutSummaryResponse,
    TCPResetsTimeoutTimeseriesGroupsResponse,
)

Methods:

client.radar.tcp_resets_timeouts.summary(**params) -> TCPResetsTimeoutSummaryResponse
client.radar.tcp_resets_timeouts.timeseries_groups(**params) -> TCPResetsTimeoutTimeseriesGroupsResponse

RobotsTXT

Top

Types:

from cloudflare.types.radar.robots_txt import TopDomainCategoriesResponse

Methods:

client.radar.robots_txt.top.domain_categories(**params) -> TopDomainCategoriesResponse

UserAgents

Types:

from cloudflare.types.radar.robots_txt.top import UserAgentDirectiveResponse

Methods:

client.radar.robots_txt.top.user_agents.directive(**params) -> UserAgentDirectiveResponse

LeakedCredentials

Summary

Types:

from cloudflare.types.radar.leaked_credentials import (
    SummaryBotClassResponse,
    SummaryCompromisedResponse,
)

Methods:

client.radar.leaked_credentials.summary.bot_class(**params) -> SummaryBotClassResponse
client.radar.leaked_credentials.summary.compromised(**params) -> SummaryCompromisedResponse

TimeseriesGroups

Types:

from cloudflare.types.radar.leaked_credentials import (
    TimeseriesGroupBotClassResponse,
    TimeseriesGroupCompromisedResponse,
)

Methods:

client.radar.leaked_credentials.timeseries_groups.bot_class(**params) -> TimeseriesGroupBotClassResponse
client.radar.leaked_credentials.timeseries_groups.compromised(**params) -> TimeseriesGroupCompromisedResponse

BotManagement

Types:

from cloudflare.types.bot_management import (
    BotFightModeConfiguration,
    SubscriptionConfiguration,
    SuperBotFightModeDefinitelyConfiguration,
    SuperBotFightModeLikelyConfiguration,
    BotManagementUpdateResponse,
    BotManagementGetResponse,
)

Methods:

client.bot_management.update(*, zone_id, **params) -> Optional[BotManagementUpdateResponse]
client.bot_management.get(*, zone_id) -> Optional[BotManagementGetResponse]

OriginPostQuantumEncryption

Types:

from cloudflare.types.origin_post_quantum_encryption import (
    OriginPostQuantumEncryptionUpdateResponse,
    OriginPostQuantumEncryptionGetResponse,
)

Methods:

client.origin_post_quantum_encryption.update(*, zone_id, **params) -> Optional[OriginPostQuantumEncryptionUpdateResponse]
client.origin_post_quantum_encryption.get(*, zone_id) -> Optional[OriginPostQuantumEncryptionGetResponse]

Zaraz

Types:

from cloudflare.types.zaraz import ButtonTextTranslation, NeoEvent

Methods:

client.zaraz.update(*, zone_id, **params) -> Workflow

Config

Types:

from cloudflare.types.zaraz import Configuration

Methods:

client.zaraz.config.update(*, zone_id, **params) -> Configuration
client.zaraz.config.get(*, zone_id) -> Configuration

Default

Methods:

client.zaraz.default.get(*, zone_id) -> Configuration

Export

Methods:

client.zaraz.export.get(*, zone_id) -> Configuration

History

Types:

from cloudflare.types.zaraz import HistoryListResponse

Methods:

client.zaraz.history.update(*, zone_id, **params) -> Configuration
client.zaraz.history.list(*, zone_id, **params) -> SyncSinglePage[HistoryListResponse]

Configs

Types:

from cloudflare.types.zaraz.history import ConfigGetResponse

Methods:

client.zaraz.history.configs.get(*, zone_id, **params) -> ConfigGetResponse

Publish

Types:

from cloudflare.types.zaraz import PublishCreateResponse

Methods:

client.zaraz.publish.create(*, zone_id, **params) -> str

Workflow

Types:

from cloudflare.types.zaraz import Workflow

Methods:

client.zaraz.workflow.get(*, zone_id) -> Workflow

Speed

Types:

from cloudflare.types.speed import LabeledRegion, LighthouseReport, Trend

Schedule

Types:

from cloudflare.types.speed import Schedule, ScheduleCreateResponse, ScheduleDeleteResponse

Methods:

client.speed.schedule.create(url, *, zone_id, **params) -> Optional[ScheduleCreateResponse]
client.speed.schedule.delete(url, *, zone_id, **params) -> Optional[ScheduleDeleteResponse]
client.speed.schedule.get(url, *, zone_id, **params) -> Optional[Schedule]

Availabilities

Types:

from cloudflare.types.speed import Availability

Methods:

client.speed.availabilities.list(*, zone_id) -> Optional[Availability]

Pages

Types:

from cloudflare.types.speed import PageListResponse

Methods:

client.speed.pages.list(*, zone_id) -> SyncSinglePage[PageListResponse]
client.speed.pages.trend(url, *, zone_id, **params) -> Optional[Trend]

Tests

Types:

from cloudflare.types.speed.pages import Test, TestDeleteResponse

Methods:

client.speed.pages.tests.create(url, *, zone_id, **params) -> Optional[Test]
client.speed.pages.tests.list(url, *, zone_id, **params) -> SyncV4PagePaginationArray[Test]
client.speed.pages.tests.delete(url, *, zone_id, **params) -> Optional[TestDeleteResponse]
client.speed.pages.tests.get(test_id, *, zone_id, url) -> Optional[Test]

DCVDelegation

Types:

from cloudflare.types.dcv_delegation import DCVDelegationUUID

Methods:

client.dcv_delegation.get(*, zone_id) -> Optional[DCVDelegationUUID]

Hostnames

Settings

TLS

Types:

from cloudflare.types.hostnames.settings import (
    Setting,
    SettingValue,
    TLSDeleteResponse,
    TLSGetResponse,
)

Methods:

client.hostnames.settings.tls.update(hostname, *, zone_id, setting_id, **params) -> Optional[Setting]
client.hostnames.settings.tls.delete(hostname, *, zone_id, setting_id) -> Optional[TLSDeleteResponse]
client.hostnames.settings.tls.get(setting_id, *, zone_id) -> SyncSinglePage[TLSGetResponse]

Snippets

Types:

from cloudflare.types.snippets import Snippet, SnippetDeleteResponse

Methods:

client.snippets.update(snippet_name, *, zone_id, **params) -> Optional[Snippet]
client.snippets.list(*, zone_id) -> SyncSinglePage[Snippet]
client.snippets.delete(snippet_name, *, zone_id) -> SnippetDeleteResponse
client.snippets.get(snippet_name, *, zone_id) -> Optional[Snippet]

Content

Methods:

client.snippets.content.get(snippet_name, *, zone_id) -> BinaryAPIResponse

Rules

Types:

from cloudflare.types.snippets import RuleUpdateResponse, RuleListResponse, RuleDeleteResponse

Methods:

client.snippets.rules.update(*, zone_id, **params) -> SyncSinglePage[RuleUpdateResponse]
client.snippets.rules.list(*, zone_id) -> SyncSinglePage[RuleListResponse]
client.snippets.rules.delete(*, zone_id) -> RuleDeleteResponse

Calls

SFU

Types:

from cloudflare.types.calls import (
    SFUCreateResponse,
    SFUUpdateResponse,
    SFUListResponse,
    SFUDeleteResponse,
    SFUGetResponse,
)

Methods:

client.calls.sfu.create(*, account_id, **params) -> Optional[SFUCreateResponse]
client.calls.sfu.update(app_id, *, account_id, **params) -> Optional[SFUUpdateResponse]
client.calls.sfu.list(*, account_id) -> SyncSinglePage[SFUListResponse]
client.calls.sfu.delete(app_id, *, account_id) -> Optional[SFUDeleteResponse]
client.calls.sfu.get(app_id, *, account_id) -> Optional[SFUGetResponse]

TURN

Types:

from cloudflare.types.calls import (
    TURNCreateResponse,
    TURNUpdateResponse,
    TURNListResponse,
    TURNDeleteResponse,
    TURNGetResponse,
)

Methods:

client.calls.turn.create(*, account_id, **params) -> TURNCreateResponse
client.calls.turn.update(key_id, *, account_id, **params) -> Optional[TURNUpdateResponse]
client.calls.turn.list(*, account_id) -> SyncSinglePage[TURNListResponse]
client.calls.turn.delete(key_id, *, account_id) -> Optional[TURNDeleteResponse]
client.calls.turn.get(key_id, *, account_id) -> Optional[TURNGetResponse]

CloudforceOne

Scans

Results

Types:

from cloudflare.types.cloudforce_one.scans import ScanResult, ResultGetResponse

Methods:

client.cloudforce_one.scans.results.get(config_id, *, account_id) -> ResultGetResponse

Config

Types:

from cloudflare.types.cloudforce_one.scans import (
    ConfigCreateResponse,
    ConfigListResponse,
    ConfigDeleteResponse,
    ConfigEditResponse,
)

Methods:

client.cloudforce_one.scans.config.create(*, account_id, **params) -> Optional[ConfigCreateResponse]
client.cloudforce_one.scans.config.list(*, account_id) -> SyncSinglePage[ConfigListResponse]
client.cloudforce_one.scans.config.delete(config_id, *, account_id) -> object
client.cloudforce_one.scans.config.edit(config_id, *, account_id, **params) -> Optional[ConfigEditResponse]

Requests

Types:

from cloudflare.types.cloudforce_one import (
    Item,
    ListItem,
    Quota,
    RequestConstants,
    RequestTypes,
    RequestDeleteResponse,
    RequestTypesResponse,
)

Methods:

client.cloudforce_one.requests.create(account_identifier, **params) -> Optional[Item]
client.cloudforce_one.requests.update(request_identifier, *, account_identifier, **params) -> Optional[Item]
client.cloudforce_one.requests.list(account_identifier, **params) -> SyncSinglePage[ListItem]
client.cloudforce_one.requests.delete(request_identifier, *, account_identifier) -> RequestDeleteResponse
client.cloudforce_one.requests.constants(account_identifier) -> Optional[RequestConstants]
client.cloudforce_one.requests.get(request_identifier, *, account_identifier) -> Optional[Item]
client.cloudforce_one.requests.quota(account_identifier) -> Optional[Quota]
client.cloudforce_one.requests.types(account_identifier) -> SyncSinglePage[RequestTypesResponse]

Message

Types:

from cloudflare.types.cloudforce_one.requests import Message, MessageDeleteResponse

Methods:

client.cloudforce_one.requests.message.create(request_identifier, *, account_identifier, **params) -> Optional[Message]
client.cloudforce_one.requests.message.update(message_identifer, *, account_identifier, request_identifier, **params) -> Optional[Message]
client.cloudforce_one.requests.message.delete(message_identifer, *, account_identifier, request_identifier) -> MessageDeleteResponse
client.cloudforce_one.requests.message.get(request_identifier, *, account_identifier, **params) -> SyncSinglePage[Message]

Priority

Types:

from cloudflare.types.cloudforce_one.requests import (
    Label,
    Priority,
    PriorityEdit,
    PriorityDeleteResponse,
)

Methods:

client.cloudforce_one.requests.priority.create(account_identifier, **params) -> Optional[Priority]
client.cloudforce_one.requests.priority.update(priority_identifer, *, account_identifier, **params) -> Optional[Item]
client.cloudforce_one.requests.priority.delete(priority_identifer, *, account_identifier) -> PriorityDeleteResponse
client.cloudforce_one.requests.priority.get(priority_identifer, *, account_identifier) -> Optional[Item]
client.cloudforce_one.requests.priority.quota(account_identifier) -> Optional[Quota]

Assets

Types:

from cloudflare.types.cloudforce_one.requests import (
    AssetCreateResponse,
    AssetUpdateResponse,
    AssetDeleteResponse,
    AssetGetResponse,
)

Methods:

client.cloudforce_one.requests.assets.create(request_identifier, *, account_identifier, **params) -> SyncSinglePage[AssetCreateResponse]
client.cloudforce_one.requests.assets.update(asset_identifer, *, account_identifier, request_identifier, **params) -> Optional[AssetUpdateResponse]
client.cloudforce_one.requests.assets.delete(asset_identifer, *, account_identifier, request_identifier) -> AssetDeleteResponse
client.cloudforce_one.requests.assets.get(asset_identifer, *, account_identifier, request_identifier) -> SyncSinglePage[AssetGetResponse]

ThreatEvents

Types:

from cloudflare.types.cloudforce_one import (
    ThreatEventCreateResponse,
    ThreatEventDeleteResponse,
    ThreatEventBulkCreateResponse,
    ThreatEventEditResponse,
    ThreatEventGetResponse,
)

Methods:

client.cloudforce_one.threat_events.create(*, path_account_id, **params) -> ThreatEventCreateResponse
client.cloudforce_one.threat_events.delete(event_id, *, account_id) -> ThreatEventDeleteResponse
client.cloudforce_one.threat_events.bulk_create(*, account_id, **params) -> ThreatEventBulkCreateResponse
client.cloudforce_one.threat_events.edit(event_id, *, account_id, **params) -> ThreatEventEditResponse
client.cloudforce_one.threat_events.get(event_id, *, account_id) -> ThreatEventGetResponse

Attackers

Types:

from cloudflare.types.cloudforce_one.threat_events import AttackerListResponse

Methods:

client.cloudforce_one.threat_events.attackers.list(*, account_id) -> AttackerListResponse

Countries

Types:

from cloudflare.types.cloudforce_one.threat_events import CountryListResponse

Methods:

client.cloudforce_one.threat_events.countries.list(*, account_id) -> CountryListResponse

Crons

Types:

from cloudflare.types.cloudforce_one.threat_events import CronListResponse, CronEditResponse

Methods:

client.cloudforce_one.threat_events.crons.list(*, account_id) -> CronListResponse
client.cloudforce_one.threat_events.crons.edit(*, account_id) -> CronEditResponse

Datasets

Types:

from cloudflare.types.cloudforce_one.threat_events import (
    DatasetCreateResponse,
    DatasetListResponse,
    DatasetEditResponse,
    DatasetGetResponse,
    DatasetRawResponse,
)

Methods:

client.cloudforce_one.threat_events.datasets.create(*, account_id, **params) -> DatasetCreateResponse
client.cloudforce_one.threat_events.datasets.list(*, account_id) -> DatasetListResponse
client.cloudforce_one.threat_events.datasets.edit(dataset_id, *, account_id, **params) -> DatasetEditResponse
client.cloudforce_one.threat_events.datasets.get(dataset_id, *, account_id) -> DatasetGetResponse
client.cloudforce_one.threat_events.datasets.raw(event_id, *, account_id, dataset_id) -> DatasetRawResponse

IndicatorTypes

Types:

from cloudflare.types.cloudforce_one.threat_events import IndicatorTypeListResponse

Methods:

client.cloudforce_one.threat_events.indicator_types.list(*, account_id) -> IndicatorTypeListResponse

Raw

Types:

from cloudflare.types.cloudforce_one.threat_events import RawEditResponse, RawGetResponse

Methods:

client.cloudforce_one.threat_events.raw.edit(raw_id, *, account_id, event_id, **params) -> RawEditResponse
client.cloudforce_one.threat_events.raw.get(raw_id, *, account_id, event_id) -> RawGetResponse

Relate

Types:

from cloudflare.types.cloudforce_one.threat_events import RelateDeleteResponse

Methods:

client.cloudforce_one.threat_events.relate.delete(event_id, *, account_id) -> RelateDeleteResponse

EventTags

Types:

from cloudflare.types.cloudforce_one.threat_events import (
    EventTagCreateResponse,
    EventTagDeleteResponse,
)

Methods:

client.cloudforce_one.threat_events.event_tags.create(event_id, *, account_id, **params) -> EventTagCreateResponse
client.cloudforce_one.threat_events.event_tags.delete(event_id, *, account_id) -> EventTagDeleteResponse

TargetIndustries

Types:

from cloudflare.types.cloudforce_one.threat_events import TargetIndustryListResponse

Methods:

client.cloudforce_one.threat_events.target_industries.list(*, account_id) -> TargetIndustryListResponse

Insights

Types:

from cloudflare.types.cloudforce_one.threat_events import (
    InsightCreateResponse,
    InsightDeleteResponse,
    InsightEditResponse,
    InsightGetResponse,
)

Methods:

client.cloudforce_one.threat_events.insights.create(event_id, *, account_id, **params) -> InsightCreateResponse
client.cloudforce_one.threat_events.insights.delete(insight_id, *, account_id, event_id) -> InsightDeleteResponse
client.cloudforce_one.threat_events.insights.edit(insight_id, *, account_id, event_id, **params) -> InsightEditResponse
client.cloudforce_one.threat_events.insights.get(insight_id, *, account_id, event_id) -> InsightGetResponse

AIGateway

Types:

from cloudflare.types.ai_gateway import (
    AIGatewayCreateResponse,
    AIGatewayUpdateResponse,
    AIGatewayListResponse,
    AIGatewayDeleteResponse,
    AIGatewayGetResponse,
)

Methods:

client.ai_gateway.create(*, account_id, **params) -> AIGatewayCreateResponse
client.ai_gateway.update(id, *, account_id, **params) -> AIGatewayUpdateResponse
client.ai_gateway.list(*, account_id, **params) -> SyncV4PagePaginationArray[AIGatewayListResponse]
client.ai_gateway.delete(id, *, account_id) -> AIGatewayDeleteResponse
client.ai_gateway.get(id, *, account_id) -> AIGatewayGetResponse

EvaluationTypes

Types:

from cloudflare.types.ai_gateway import EvaluationTypeListResponse

Methods:

client.ai_gateway.evaluation_types.list(*, account_id, **params) -> SyncV4PagePaginationArray[EvaluationTypeListResponse]

Logs

Types:

from cloudflare.types.ai_gateway import (
    LogListResponse,
    LogDeleteResponse,
    LogEditResponse,
    LogGetResponse,
    LogRequestResponse,
    LogResponseResponse,
)

Methods:

client.ai_gateway.logs.list(gateway_id, *, account_id, **params) -> SyncV4PagePaginationArray[LogListResponse]
client.ai_gateway.logs.delete(gateway_id, *, account_id, **params) -> LogDeleteResponse
client.ai_gateway.logs.edit(id, *, account_id, gateway_id, **params) -> object
client.ai_gateway.logs.get(id, *, account_id, gateway_id) -> LogGetResponse
client.ai_gateway.logs.request(id, *, account_id, gateway_id) -> object
client.ai_gateway.logs.response(id, *, account_id, gateway_id) -> object

Datasets

Types:

from cloudflare.types.ai_gateway import (
    DatasetCreateResponse,
    DatasetUpdateResponse,
    DatasetListResponse,
    DatasetDeleteResponse,
    DatasetGetResponse,
)

Methods:

client.ai_gateway.datasets.create(gateway_id, *, account_id, **params) -> DatasetCreateResponse
client.ai_gateway.datasets.update(id, *, account_id, gateway_id, **params) -> DatasetUpdateResponse
client.ai_gateway.datasets.list(gateway_id, *, account_id, **params) -> SyncV4PagePaginationArray[DatasetListResponse]
client.ai_gateway.datasets.delete(id, *, account_id, gateway_id) -> DatasetDeleteResponse
client.ai_gateway.datasets.get(id, *, account_id, gateway_id) -> DatasetGetResponse

Evaluations

Types:

from cloudflare.types.ai_gateway import (
    EvaluationCreateResponse,
    EvaluationListResponse,
    EvaluationDeleteResponse,
    EvaluationGetResponse,
)

Methods:

client.ai_gateway.evaluations.create(gateway_id, *, account_id, **params) -> EvaluationCreateResponse
client.ai_gateway.evaluations.list(gateway_id, *, account_id, **params) -> SyncV4PagePaginationArray[EvaluationListResponse]
client.ai_gateway.evaluations.delete(id, *, account_id, gateway_id) -> EvaluationDeleteResponse
client.ai_gateway.evaluations.get(id, *, account_id, gateway_id) -> EvaluationGetResponse

URLs

Types:

from cloudflare.types.ai_gateway import URLGetResponse

Methods:

client.ai_gateway.urls.get(provider, *, account_id, gateway_id) -> str

IAM

PermissionGroups

Types:

from cloudflare.types.iam import PermissionGroupListResponse, PermissionGroupGetResponse

Methods:

client.iam.permission_groups.list(*, account_id, **params) -> SyncV4PagePaginationArray[PermissionGroupListResponse]
client.iam.permission_groups.get(permission_group_id, *, account_id) -> PermissionGroupGetResponse

ResourceGroups

Types:

from cloudflare.types.iam import (
    ResourceGroupCreateResponse,
    ResourceGroupUpdateResponse,
    ResourceGroupListResponse,
    ResourceGroupDeleteResponse,
    ResourceGroupGetResponse,
)

Methods:

client.iam.resource_groups.create(*, account_id, **params) -> ResourceGroupCreateResponse
client.iam.resource_groups.update(resource_group_id, *, account_id, **params) -> ResourceGroupUpdateResponse
client.iam.resource_groups.list(*, account_id, **params) -> SyncV4PagePaginationArray[ResourceGroupListResponse]
client.iam.resource_groups.delete(resource_group_id, *, account_id) -> Optional[ResourceGroupDeleteResponse]
client.iam.resource_groups.get(resource_group_id, *, account_id) -> ResourceGroupGetResponse

CloudConnector

Rules

Types:

from cloudflare.types.cloud_connector import RuleUpdateResponse, RuleListResponse

Methods:

client.cloud_connector.rules.update(*, zone_id, **params) -> SyncSinglePage[RuleUpdateResponse]
client.cloud_connector.rules.list(*, zone_id) -> SyncSinglePage[RuleListResponse]

BotnetFeed

ASN

Types:

from cloudflare.types.botnet_feed import ASNDayReportResponse, ASNFullReportResponse

Methods:

client.botnet_feed.asn.day_report(asn_id, *, account_id, **params) -> Optional[ASNDayReportResponse]
client.botnet_feed.asn.full_report(asn_id, *, account_id) -> Optional[ASNFullReportResponse]

Configs

ASN

Types:

from cloudflare.types.botnet_feed.configs import ASNDeleteResponse, ASNGetResponse

Methods:

client.botnet_feed.configs.asn.delete(asn_id, *, account_id) -> Optional[ASNDeleteResponse]
client.botnet_feed.configs.asn.get(*, account_id) -> Optional[ASNGetResponse]

SecurityTXT

Types:

from cloudflare.types.security_txt import (
    SecurityTXTUpdateResponse,
    SecurityTXTDeleteResponse,
    SecurityTXTGetResponse,
)

Methods:

client.security_txt.update(*, zone_id, **params) -> SecurityTXTUpdateResponse
client.security_txt.delete(*, zone_id) -> SecurityTXTDeleteResponse
client.security_txt.get(*, zone_id) -> Optional[SecurityTXTGetResponse]

Workflows

Types:

from cloudflare.types.workflows import (
    WorkflowUpdateResponse,
    WorkflowListResponse,
    WorkflowGetResponse,
)

Methods:

client.workflows.update(workflow_name, *, account_id, **params) -> WorkflowUpdateResponse
client.workflows.list(*, account_id, **params) -> SyncV4PagePaginationArray[WorkflowListResponse]
client.workflows.get(workflow_name, *, account_id) -> WorkflowGetResponse

Instances

Types:

from cloudflare.types.workflows import (
    InstanceCreateResponse,
    InstanceListResponse,
    InstanceBulkResponse,
    InstanceGetResponse,
)

Methods:

client.workflows.instances.create(workflow_name, *, account_id, **params) -> InstanceCreateResponse
client.workflows.instances.list(workflow_name, *, account_id, **params) -> SyncV4PagePaginationArray[InstanceListResponse]
client.workflows.instances.bulk(workflow_name, *, account_id, **params) -> SyncSinglePage[InstanceBulkResponse]
client.workflows.instances.get(instance_id, *, account_id, workflow_name) -> InstanceGetResponse

Status

Types:

from cloudflare.types.workflows.instances import StatusEditResponse

Methods:

client.workflows.instances.status.edit(instance_id, *, account_id, workflow_name, **params) -> StatusEditResponse

Versions

Types:

from cloudflare.types.workflows import VersionListResponse, VersionGetResponse

Methods:

client.workflows.versions.list(workflow_name, *, account_id, **params) -> SyncV4PagePaginationArray[VersionListResponse]
client.workflows.versions.get(version_id, *, account_id, workflow_name) -> VersionGetResponse

ResourceSharing

Types:

from cloudflare.types.resource_sharing import (
    ResourceSharingCreateResponse,
    ResourceSharingUpdateResponse,
    ResourceSharingListResponse,
    ResourceSharingDeleteResponse,
    ResourceSharingGetResponse,
)

Methods:

client.resource_sharing.create(*, account_id, **params) -> Optional[ResourceSharingCreateResponse]
client.resource_sharing.update(share_id, *, account_id, **params) -> Optional[ResourceSharingUpdateResponse]
client.resource_sharing.list(*, account_id, **params) -> SyncV4PagePaginationArray[ResourceSharingListResponse]
client.resource_sharing.delete(share_id, *, account_id) -> Optional[ResourceSharingDeleteResponse]
client.resource_sharing.get(share_id, *, account_id) -> Optional[ResourceSharingGetResponse]

Recipients

Types:

from cloudflare.types.resource_sharing import (
    RecipientCreateResponse,
    RecipientListResponse,
    RecipientDeleteResponse,
    RecipientGetResponse,
)

Methods:

client.resource_sharing.recipients.create(share_id, *, path_account_id, **params) -> Optional[RecipientCreateResponse]
client.resource_sharing.recipients.list(share_id, *, account_id, **params) -> SyncV4PagePaginationArray[RecipientListResponse]
client.resource_sharing.recipients.delete(recipient_id, *, account_id, share_id) -> Optional[RecipientDeleteResponse]
client.resource_sharing.recipients.get(recipient_id, *, account_id, share_id) -> Optional[RecipientGetResponse]

Resources

Types:

from cloudflare.types.resource_sharing import (
    ResourceCreateResponse,
    ResourceUpdateResponse,
    ResourceListResponse,
    ResourceDeleteResponse,
    ResourceGetResponse,
)

Methods:

client.resource_sharing.resources.create(share_id, *, account_id, **params) -> Optional[ResourceCreateResponse]
client.resource_sharing.resources.update(resource_id, *, account_id, share_id, **params) -> Optional[ResourceUpdateResponse]
client.resource_sharing.resources.list(share_id, *, account_id, **params) -> SyncV4PagePaginationArray[ResourceListResponse]
client.resource_sharing.resources.delete(resource_id, *, account_id, share_id) -> Optional[ResourceDeleteResponse]
client.resource_sharing.resources.get(resource_id, *, account_id, share_id) -> Optional[ResourceGetResponse]

LeakedCredentialChecks

Types:

from cloudflare.types.leaked_credential_checks import (
    LeakedCredentialCheckCreateResponse,
    LeakedCredentialCheckGetResponse,
)

Methods:

client.leaked_credential_checks.create(*, zone_id, **params) -> LeakedCredentialCheckCreateResponse
client.leaked_credential_checks.get(*, zone_id) -> LeakedCredentialCheckGetResponse

Detections

Types:

from cloudflare.types.leaked_credential_checks import (
    DetectionCreateResponse,
    DetectionUpdateResponse,
    DetectionListResponse,
    DetectionDeleteResponse,
)

Methods:

client.leaked_credential_checks.detections.create(*, zone_id, **params) -> DetectionCreateResponse
client.leaked_credential_checks.detections.update(detection_id, *, zone_id, **params) -> DetectionUpdateResponse
client.leaked_credential_checks.detections.list(*, zone_id) -> SyncSinglePage[DetectionListResponse]
client.leaked_credential_checks.detections.delete(detection_id, *, zone_id) -> object

ContentScanning

Types:

from cloudflare.types.content_scanning import (
    ContentScanningDisableResponse,
    ContentScanningEnableResponse,
)

Methods:

client.content_scanning.disable(*, zone_id) -> object
client.content_scanning.enable(*, zone_id) -> object

Payloads

Types:

from cloudflare.types.content_scanning import (
    PayloadCreateResponse,
    PayloadListResponse,
    PayloadDeleteResponse,
)

Methods:

client.content_scanning.payloads.create(*, zone_id, **params) -> SyncSinglePage[PayloadCreateResponse]
client.content_scanning.payloads.list(*, zone_id) -> SyncSinglePage[PayloadListResponse]
client.content_scanning.payloads.delete(expression_id, *, zone_id) -> SyncSinglePage[PayloadDeleteResponse]

Settings

Types:

from cloudflare.types.content_scanning import SettingGetResponse

Methods:

client.content_scanning.settings.get(*, zone_id) -> SettingGetResponse

AbuseReports

Types:

from cloudflare.types.abuse_reports import AbuseReportCreateResponse

Methods:

client.abuse_reports.create(report_type, *, account_id, **params) -> str

AI

Types:

from cloudflare.types.ai import AIRunResponse

Methods:

client.ai.run(model_name, *, account_id, **params) -> Optional[AIRunResponse]

Finetunes

Types:

from cloudflare.types.ai import FinetuneCreateResponse, FinetuneListResponse

Methods:

client.ai.finetunes.create(*, account_id, **params) -> FinetuneCreateResponse
client.ai.finetunes.list(*, account_id) -> FinetuneListResponse

Assets

Types:

from cloudflare.types.ai.finetunes import AssetCreateResponse

Methods:

client.ai.finetunes.assets.create(finetune_id, *, account_id, **params) -> AssetCreateResponse

Public

Types:

from cloudflare.types.ai.finetunes import PublicListResponse

Methods:

client.ai.finetunes.public.list(*, account_id, **params) -> SyncSinglePage[PublicListResponse]

Authors

Types:

from cloudflare.types.ai import AuthorListResponse

Methods:

client.ai.authors.list(*, account_id) -> SyncSinglePage[object]

Tasks

Types:

from cloudflare.types.ai import TaskListResponse

Methods:

client.ai.tasks.list(*, account_id) -> SyncSinglePage[object]

Models

Types:

from cloudflare.types.ai import ModelListResponse

Methods:

client.ai.models.list(*, account_id, **params) -> SyncV4PagePaginationArray[object]

Schema

Types:

from cloudflare.types.ai.models import SchemaGetResponse

Methods:

client.ai.models.schema.get(*, account_id, **params) -> object

SecurityCenter

Insights

Types:

from cloudflare.types.security_center import InsightListResponse, InsightDismissResponse

Methods:

client.security_center.insights.list(*, account_id, zone_id, **params) -> SyncV4PagePagination[Optional[InsightListResponse]]
client.security_center.insights.dismiss(issue_id, *, account_id, zone_id, **params) -> InsightDismissResponse

Class

Types:

from cloudflare.types.security_center.insights import ClassGetResponse

Methods:

client.securitycenter.insights.class.get(*, account_id, zone_id, **params) -> Optional[ClassGetResponse]

Severity

Types:

from cloudflare.types.security_center.insights import SeverityGetResponse

Methods:

client.security_center.insights.severity.get(*, account_id, zone_id, **params) -> Optional[SeverityGetResponse]

Type

Types:

from cloudflare.types.security_center.insights import TypeGetResponse

Methods:

client.security_center.insights.type.get(*, account_id, zone_id, **params) -> Optional[TypeGetResponse]

BrowserRendering

Content

Types:

from cloudflare.types.browser_rendering import ContentCreateResponse

Methods:

client.browser_rendering.content.create(*, account_id, **params) -> str

PDF

Methods:

client.browser_rendering.pdf.create(*, account_id, **params) -> BinaryAPIResponse

Scrape

Types:

from cloudflare.types.browser_rendering import ScrapeCreateResponse

Methods:

client.browser_rendering.scrape.create(*, account_id, **params) -> ScrapeCreateResponse

Screenshot

Types:

from cloudflare.types.browser_rendering import ScreenshotCreateResponse

Methods:

client.browser_rendering.screenshot.create(*, account_id, **params) -> ScreenshotCreateResponse

Snapshot

Types:

from cloudflare.types.browser_rendering import SnapshotCreateResponse

Methods:

client.browser_rendering.snapshot.create(*, account_id, **params) -> Optional[SnapshotCreateResponse]

CustomPages

Types:

from cloudflare.types.custom_pages import (
    CustomPageUpdateResponse,
    CustomPageListResponse,
    CustomPageGetResponse,
)

Methods:

client.custom_pages.update(identifier, *, account_id, zone_id, **params) -> Optional[CustomPageUpdateResponse]
client.custom_pages.list(*, account_id, zone_id) -> SyncSinglePage[object]
client.custom_pages.get(identifier, *, account_id, zone_id) -> Optional[CustomPageGetResponse]

Files

api.md

Latest commit

History

api.md

File metadata and controls

Shared Types

Accounts

Members

Roles

Subscriptions

Tokens

PermissionGroups

Value

Logs

Audit

OriginCACertificates

IPs

Memberships

User

AuditLogs

Billing

History

Profile

Invites

Organizations

Subscriptions

Tokens

PermissionGroups

Value

Zones

ActivationCheck

Settings

CustomNameservers

Holds

Subscriptions

Plans

RatePlans

LoadBalancers

Monitors

Previews

References

Pools

Health

References

Previews

Regions

Searches

Cache

CacheReserve

SmartTieredCache

Variants

RegionalTieredCache

SSL

Analyze

CertificatePacks

Quota

Recommendations

Universal

Settings

Verification

ACM

TotalTLS

Argo

SmartRouting

TieredCaching

CertificateAuthorities

HostnameAssociations

ClientCertificates

CustomCertificates

Prioritize

CustomHostnames

FallbackOrigin

CertificatePack

Certificates

CustomNameservers

DNSFirewall

Analytics

Reports

Bytimes