This section provides a structured reference card for each of the six most critical TM Forum Open APIs in a BSS/OSS architecture. For each API, the card specifies its purpose, domain ownership, correct use cases, anti-patterns (when NOT to use it), and the most common implementation mistakes observed in real-world deployments.
Use these cards during architecture reviews, vendor evaluations, and integration design to ensure each API is being applied correctly. Misuse of TM Forum APIs is one of the most common causes of integration failure — not because the APIs are flawed, but because they are used in the wrong context or with incorrect assumptions.
💡How to Read These Cards
Each card follows the same structure: Purpose (what the API does), Domain (BSS/OSS ownership and SID alignment), When to Use (correct application scenarios), When NOT to Use (anti-patterns and misapplications), and Common Misuses (mistakes observed in production). The "When NOT to Use" and "Common Misuses" sections are the most architecturally valuable — they prevent the errors that cause integration projects to fail.
TMF620 — Product Catalog Management
📖Purpose
TMF620 provides a standardised API for managing the Product Catalog — the design-time repository of everything a telco can sell. It covers Product Offerings (the sellable packages), Product Specifications (the structural definitions), Categories (navigation), and Pricing (price components and rules). TMF620 is the entry point for all catalog-driven processes.
TMF620 — Reference Card
Dimension
Detail
Domain
BSS — Product Management. Aligns with TM Forum SID Product domain. Typically exposed by the Product Catalog component in ODA.
Product Catalog Manager. TMF620 should ONLY be exposed by the system that is the System of Record for product definitions.
When to Use TMF620
CPQ reading the catalog: CPQ queries TMF620 to retrieve available Product Offerings, their characteristics, pricing rules, and eligibility constraints for a given customer and channel.
Self-service portal browsing products: Digital channels use TMF620 to present the product catalog to customers, including category navigation, product comparison, and pricing display.
COM validating orders: COM queries TMF620 to validate that an ordered product exists, is in an active lifecycle state, and that the configured characteristics are within allowed values.
SOM resolving decomposition rules: SOM queries TMF620 to find the Product Specification's linked CFS specifications, which drive the product-to-service decomposition.
Billing loading pricing rules: Billing reads pricing components from TMF620 to apply the correct tariffs and discounts when rating usage or generating invoices.
Product lifecycle management: Product managers use TMF620 to create, modify, retire, and obsolete Product Offerings through formal lifecycle state transitions.
When NOT to Use TMF620
Do NOT use TMF620 for product instances — TMF620 is design-time (what CAN be sold). For runtime records of what a customer HAS, use TMF637 (Product Inventory). Confusing catalog with inventory is the single most common TMF API mistake.
Do NOT use TMF620 for service or resource catalogs — Product Catalog is commercial. Use TMF633 for Service Catalog and TMF634 for Resource Catalog. Each catalog has distinct semantics and ownership.
Do NOT use TMF620 for order capture — TMF620 is a read-mostly API for catalog queries. To create orders, use TMF622 (Product Ordering). Do not extend TMF620 with order-like operations.
Do NOT use TMF620 as a master data hub — TMF620 manages product definitions, not customer data, account data, or pricing engine logic. It should not become a catch-all for non-product commercial data.
Common TMF620 Misuses
⚠️Misuse: Multiple Catalogs Without Governance
Organisations deploy multiple TMF620 instances (one per channel, one per region) without a single master. Product definitions diverge, and the same product is defined differently in each catalog. The fix: maintain one canonical TMF620 source and syndicate to channel-specific caches.
⚠️Misuse: Embedding Business Logic in Catalog Queries
Channels build complex eligibility logic by chaining TMF620 queries instead of using the catalog's built-in eligibility rules. This creates brittle, slow integrations. The catalog should expose eligibility as part of the ProductOffering resource, not require the consumer to calculate it.
⚠️Misuse: Ignoring Lifecycle States
Product Offerings have lifecycle states (In Design, Active, Retired, Obsoleted). Consumers that do not filter by lifecycle state will expose retired products to customers or allow orders for products that are no longer available. Every TMF620 query should include a lifecycle state filter.
TMF622 — Product Ordering
📖Purpose
TMF622 provides the standardised API for creating, managing, and tracking Product Orders — the formal commercial instructions to deliver, modify, or cease products and services. TMF622 is the primary integration API at the BSS-to-OSS boundary. It is how COM submits customer orders for fulfilment.
TMF622 — Reference Card
Dimension
Detail
Domain
BSS — Commercial Order Management. Aligns with TM Forum SID Product Ordering domain. Exposed by the COM component in ODA.
Key Resources
ProductOrder, ProductOrderItem, CancelProductOrder. Items support actions: add, modify, delete, noChange.
SoR Owner
COM (Commercial Order Management). TMF622 is exposed by COM and consumed by SOM for downstream fulfilment.
When to Use TMF622
Channel-to-COM order submission: All channels (web, mobile, retail, partner, B2B) submit Product Orders to COM via TMF622. This is the standard inbound interface for order capture.
COM-to-SOM handoff: COM uses TMF622 events or a derived TMF641 call to pass validated orders to SOM for service-level fulfilment. TMF622 represents the commercial intent that SOM must decompose.
Order status tracking: Channels and CRM query TMF622 to track order progress, retrieve current state, and display fulfilment updates to customers and agents.
Order amendment and cancellation: TMF622 supports in-flight order modification via the CancelProductOrder resource and order item updates. This is used for customer-requested changes before fulfilment completes.
B2B partner ordering: Wholesale and partner channels use TMF622 as a machine-to-machine interface for automated order submission, following the same payload structure as internal channels.
When NOT to Use TMF622
Do NOT use TMF622 for service-level ordering — TMF622 operates at the Product (commercial) level. For service-level fulfilment, use TMF641 (Service Ordering). Sending TMF622 payloads directly to SOM bypasses the decomposition step.
Do NOT use TMF622 for resource provisioning — TMF622 is commercial, not technical. For resource-level ordering, use TMF652 (Resource Ordering). Sending product orders directly to ROM violates the three-layer model.
Do NOT use TMF622 for quoting — TMF622 creates orders that trigger fulfilment. For quotes (non-binding proposals), use TMF648 (Quote Management). Creating TMF622 orders as "draft quotes" pollutes the order pipeline.
Do NOT use TMF622 for product browsing — TMF622 is a transactional API for order creation. For catalog browsing and product discovery, use TMF620 (Product Catalog).
Common TMF622 Misuses
⚠️Misuse: Monolithic Order Items
Submitting an entire product bundle as a single ProductOrderItem with all characteristics in one blob. This prevents granular tracking, partial fulfilment, and per-item status reporting. Each independently deliverable product should be a separate ProductOrderItem.
⚠️Misuse: Synchronous Fulfilment Expectation
Treating TMF622 POST as a synchronous call that returns a completed order. TMF622 is asynchronous by design: POST creates the order (returns "acknowledged"), and fulfilment progresses via state change events. Channels that block waiting for completion will timeout on any non-trivial order.
⚠️Misuse: Skipping the Service Layer
Embedding service-level and resource-level details directly in TMF622 ProductOrderItems (e.g., specifying VLAN IDs and port numbers in the product order). This violates separation of concerns — commercial orders should reference product characteristics, not technical implementation details. Let SOM and ROM handle the technical mapping.
TMF633 — Service Catalog Management
📖Purpose
TMF633 provides the standardised API for managing the Service Catalog — the design-time repository of CFS (Customer-Facing Service) and RFS (Resource-Facing Service) specifications. It defines how commercial products decompose into technical services and how those services map to resource requirements. TMF633 is the architectural backbone of catalog-driven fulfilment.
TMF633 — Reference Card
Dimension
Detail
Domain
OSS — Service Management. Aligns with TM Forum SID Service domain. Exposed by the Service Catalog component in ODA.
Key Resources
ServiceSpecification, ServiceCandidate, ServiceCategory, ServiceCatalog. ServiceSpecification carries CFS/RFS type via @type polymorphism.
SoR Owner
Service Catalog Manager. TMF633 is the definitive source for all service decomposition rules and CFS/RFS relationships.
When to Use TMF633
SOM resolving decomposition rules: SOM queries TMF633 to determine how a ProductSpecification decomposes into CFS instances, and how each CFS further decomposes into RFS instances and resource requirements.
Service design and onboarding: Service architects use TMF633 to publish new CFS and RFS specifications, including their characteristics, relationships, dependencies, and lifecycle states.
Product-to-service linkage: TMF633 ServiceSpecifications are linked from TMF620 ProductSpecifications, creating the catalog chain that drives automated decomposition.
Service qualification: Service qualification systems query TMF633 to determine which services are available at a given location by checking CFS specifications against coverage and capability data.
When NOT to Use TMF633
Do NOT use TMF633 for service instances — TMF633 is design-time (service definitions). For runtime instances of active services, use TMF638 (Service Inventory). This is the service-layer equivalent of the TMF620/TMF637 distinction.
Do NOT use TMF633 for product definitions — Service specifications describe technical service types, not commercial products. Use TMF620 for product offerings and specifications.
Do NOT use TMF633 for resource specifications — Resource types (equipment models, port types, VLAN ranges) belong in TMF634 (Resource Catalog), not TMF633.
Do NOT use TMF633 for orchestration logic — TMF633 defines WHAT services exist and HOW they decompose. It does not define the orchestration SEQUENCE (which tasks run in parallel vs sequentially). Orchestration sequencing is a SOM concern.
Common TMF633 Misuses
⚠️Misuse: Flat Service Catalog
Defining all services as CFS without the RFS layer. This makes the catalog simpler but eliminates technology abstraction. When a new access technology is introduced (e.g., FWA alongside GPON), the entire CFS definition must be duplicated instead of adding a new RFS that maps to the same CFS.
⚠️Misuse: Disconnected Catalogs
Maintaining TMF633 (Service Catalog) without formal linkage to TMF620 (Product Catalog). This means product-to-service decomposition cannot be automated — someone must manually determine which services are needed for each product order. This defeats the purpose of catalog-driven architecture.
⚠️Misuse: Over-Granular CFS Definitions
Creating a separate CFS for every minor variation (e.g., "Internet-100Mbps", "Internet-200Mbps", "Internet-500Mbps" as separate CFS types). CFS should be parameterised: one "Internet Access" CFS with a "bandwidth" characteristic. Over-granularity causes catalog explosion and makes reuse impossible.
TMF637 — Product Inventory Management
📖Purpose
TMF637 provides the standardised API for managing Product Inventory — the runtime repository of active product instances (subscriptions) that track what each customer currently has. Product Inventory is the commercial truth that bridges the catalog (what was offered) and billing (what is charged). TMF637 is the BSS-side answer to "what does this customer have right now?"
TMF637 — Reference Card
Dimension
Detail
Domain
BSS — Product Inventory / Subscription Lifecycle Management. Aligns with TM Forum SID Product domain (instances). Exposed by the Product Inventory component in ODA.
Key Resources
Product (instance). Each Product instance references its ProductSpecification (from TMF620) and carries characteristics, status, and relationships.
SoR Owner
Product Inventory / SLM. TMF637 is the definitive source for what each customer currently has — active, suspended, or pending products.
When to Use TMF637
CRM displaying "what the customer has": Agent desktops and self-service portals query TMF637 to show the customer's active products, subscriptions, and their current characteristics.
COM handling modify/cease orders: Before processing a modification or cessation order, COM queries TMF637 to retrieve the current product instance and calculate the delta between current and target state.
Billing reconciliation: Billing queries TMF637 to verify that charges align with active products. Revenue assurance uses TMF637 as the reference for what should be billed.
COM updating on fulfilment completion: When fulfilment completes, COM creates or updates product instances in TMF637 to reflect the new subscription state.
Cross-sell/up-sell analysis: Analytics systems query TMF637 to identify product holdings, enabling targeted cross-sell and up-sell recommendations.
When NOT to Use TMF637
Do NOT use TMF637 for product definitions — TMF637 manages product INSTANCES (what a customer has). For product DEFINITIONS (what can be sold), use TMF620 (Product Catalog).
Do NOT use TMF637 for service or resource instances — Product Inventory is commercial. For service instances (CFS/RFS), use TMF638. For resource instances, use TMF639. These are separate inventories with different ownership.
Do NOT use TMF637 for order tracking — TMF637 tracks the current state of products, not the order that created them. For order lifecycle tracking, use TMF622.
Do NOT use TMF637 as a billing system — Product Inventory tracks what exists; billing tracks what is charged. They should be separate systems with TMF637 informing billing, not replacing it.
Common TMF637 Misuses
⚠️Misuse: Product Inventory as Billing Driver
Using TMF637 as the direct input for invoice generation without a separate rating/billing step. Product Inventory tracks what exists; billing must independently rate and charge based on its own pricing logic. Tight coupling means product changes immediately affect billing without validation.
⚠️Misuse: Not Updating on State Changes
Failing to update Product Inventory when services are suspended, resumed, or terminated. This causes CRM to show active products that are actually suspended, and billing to continue charging for products that have been ceased. TMF637 must be updated at every lifecycle state transition.
⚠️Misuse: Orphaned Product Instances
Product instances remain in "active" state after the underlying services have been decommissioned. This happens when the fulfilment completion callback fails to update TMF637. Regular reconciliation between Product Inventory (TMF637) and Service Inventory (TMF638) is essential to detect orphans.
TMF638 — Service Inventory Management
📖Purpose
TMF638 provides the standardised API for managing Service Inventory — the runtime repository of active CFS and RFS instances. Service Inventory is the critical bridge between the commercial world (Product Inventory) and the infrastructure world (Resource Inventory). It answers the question: "what services are currently running, and what resources support them?"
TMF638 — Reference Card
Dimension
Detail
Domain
OSS — Service Management. Aligns with TM Forum SID Service domain (instances). Exposed by the Service Inventory component in ODA.
Key Resources
Service (instance). Uses @type polymorphism for CFS vs RFS. Carries serviceCharacteristic, serviceRelationship, supportingService, and supportingResource links.
SoR Owner
Service Inventory. TMF638 is the definitive source for all active service instances, their configuration, and their relationships to products and resources.
When to Use TMF638
SOM creating service instances on activation: When fulfilment completes, SOM creates CFS and RFS instances in TMF638 to record the active service configuration.
Fault correlation (resource → service → customer): Assurance systems query TMF638 to determine which CFS instances are affected by a resource fault, and then trace from CFS to Product Inventory to identify affected customers.
Service qualification: Pre-order feasibility checks query TMF638 to determine if existing service instances can be reused or upgraded, or if a new service instance is required.
Capacity planning: Planning systems query TMF638 to understand service utilisation patterns and forecast future capacity needs.
Modify/cease flow delta calculation: SOM queries TMF638 to retrieve the current service configuration and calculate what changes are needed for a modification order.
When NOT to Use TMF638
Do NOT use TMF638 for service definitions — TMF638 manages service INSTANCES (what is running). For service DEFINITIONS (CFS/RFS specifications), use TMF633 (Service Catalog).
Do NOT use TMF638 for resource instances — Service Inventory tracks services, not resources. For physical and logical resource instances, use TMF639 (Resource Inventory). TMF638 links TO resources via supportingResource, but does not manage them.
Do NOT use TMF638 for product instances — Service instances are technical (OSS). For commercial product instances (subscriptions), use TMF637 (Product Inventory).
Do NOT use TMF638 for network monitoring — TMF638 holds the inventory record of services, not real-time performance data. For service quality monitoring, use TMF656 (Service Problem) or dedicated monitoring tools.
Common TMF638 Misuses
⚠️Misuse: No CFS-to-Resource Linkage
Service instances are created in TMF638 but without the supportingResource relationships to TMF639. This makes fault correlation impossible — when a resource fails, there is no path from the resource to the affected service to the affected customer. Always populate supportingService and supportingResource relationships.
⚠️Misuse: Treating Service Inventory as Optional
Some architectures skip Service Inventory entirely, going directly from Product Inventory to Resource Inventory. This creates the "service layer gap" — the organisation knows what was sold and what is on the network, but not which services connect the two. Fault impact analysis, service qualification, and capacity planning all require Service Inventory.
⚠️Misuse: Stale Service State
Service instances not updated when resources are changed outside the normal order flow (e.g., emergency network maintenance). This causes TMF638 to show services as "active" when their underlying resources have been reconfigured or decommissioned. Reconciliation processes must detect and resolve state drift.
TMF640 / TMF641 — Service Activation & Service Ordering
📖Purpose
TMF641 (Service Ordering) provides the standardised API for creating, managing, and tracking Service Orders — the instructions to create, modify, or delete service instances at the CFS and RFS layers. TMF640 (Service Activation and Configuration) provides the API for the actual activation step — pushing configuration to service platforms. Together, they cover the full service fulfilment lifecycle from order receipt to activation.
TMF640/641 — Reference Card
Dimension
Detail
Domain
OSS — Service Order Management / Service Activation. Aligns with TM Forum SID Service domain (ordering and activation). TMF641 exposed by SOM; TMF640 exposed by the Activation component.
Key Resources
TMF641: ServiceOrder, ServiceOrderItem (with actions: add, modify, delete, noChange). TMF640: Service (activation payload with configuration parameters).
SoR Owner
SOM owns the Service Order lifecycle (TMF641). The Activation component manages the activation state (TMF640). Service Inventory (TMF638) holds the resulting service instances.
When to Use TMF641 / TMF640
COM-to-SOM order handoff (TMF641): COM submits service orders to SOM via TMF641 after decomposing the product order into CFS-level items. This is the primary BSS-to-OSS integration point for fulfilment.
SOM orchestrating fulfilment (TMF641): SOM uses TMF641 internally to manage the service order lifecycle, track item states, and coordinate dependencies between service order items.
SOM-to-ROM decomposition (TMF641 → TMF652): SOM decomposes service order items into resource order items and submits them to ROM via TMF652. TMF641 events report service-level progress back to COM.
Pushing service configuration (TMF640): The activation component uses TMF640 to push service-specific configuration to service platforms (e.g., policy controllers, DNS servers, authentication systems).
Service modification flows (TMF641): For modify orders, SOM creates TMF641 service orders with "modify" action items, specifying the delta between current and target service configuration.
When NOT to Use TMF641 / TMF640
Do NOT use TMF641 for commercial order capture — TMF641 is for service-level fulfilment, not commercial order capture. Use TMF622 (Product Ordering) for customer-facing order submission.
Do NOT use TMF641 for resource provisioning — TMF641 operates at the service layer. For resource-level provisioning (port allocation, VLAN assignment, device configuration), use TMF652 (Resource Ordering).
Do NOT use TMF640 for network element configuration — TMF640 is for service-platform-level activation. For direct network element configuration (router, switch, OLT), use NETCONF, CLI adapters, or TMF652 with activation adapters.
Do NOT use TMF641 for trouble ticket creation — Even though service problems may trigger automated remediation, trouble tickets should be created via TMF621 (Trouble Ticket), not as TMF641 service orders.
Common TMF641/640 Misuses
⚠️Misuse: Synchronous Order Chain
Calling TMF641 synchronously from TMF622 and waiting for a response before returning to the channel. Service fulfilment is inherently asynchronous (it may take hours or days). TMF641 should be called asynchronously, with state change events (ServiceOrderStateChangeEvent) propagating status back to COM.
⚠️Misuse: No Service Inventory Update
Completing service orders in TMF641 without creating or updating service instances in TMF638. This means fulfilment "succeeds" but there is no record of what was activated. SOM must update TMF638 as part of every successful service order completion.
⚠️Misuse: Confusing TMF641 and TMF640
TMF641 is for ordering (lifecycle management of service orders). TMF640 is for activation (pushing configuration). Using TMF641 to push configuration or TMF640 to track order state mixes two distinct concerns. SOM uses TMF641 for orchestration and calls TMF640 for the activation step within the orchestration flow.
Cross-API Quick Reference
The following table summarises the design-time vs runtime distinction and the ownership boundaries across all six key APIs. This is the most common source of confusion in TMF API adoption.
Design-Time vs Runtime API Mapping
Layer
Design-Time (Catalog)
Runtime (Inventory)
Ordering
Domain
Product
TMF620 (Product Catalog)
TMF637 (Product Inventory)
TMF622 (Product Ordering)
BSS
Service
TMF633 (Service Catalog)
TMF638 (Service Inventory)
TMF641 (Service Ordering)
OSS
Resource
TMF634 (Resource Catalog)
TMF639 (Resource Inventory)
TMF652 (Resource Ordering)
OSS
📋The Golden Rule of TMF API Selection
If you are defining WHAT something is → use the Catalog API (TMF620/633/634). If you are tracking an INSTANCE of something that exists → use the Inventory API (TMF637/638/639). If you are requesting something to be CREATED, CHANGED, or DELETED → use the Ordering API (TMF622/641/652). Every API call should fall into exactly one of these three categories. If it does not, you are likely using the wrong API.
TMF API Reference Cards — Key Points
TMF620 is for product DEFINITIONS (design-time catalog) — never for instances or orders
TMF622 is for commercial ORDERS (BSS→OSS handoff) — never for service or resource ordering
TMF633 is for service DEFINITIONS (CFS/RFS specifications) — never for service instances
TMF637 is for product INSTANCES (what the customer has) — never for what can be sold
TMF638 is for service INSTANCES (what is running) — critical for fault correlation
TMF641 is for service ORDERING (fulfilment orchestration) — always asynchronous, never synchronous
TMF640 is for service ACTIVATION (pushing configuration) — distinct from ordering
The most common mistake across all APIs: confusing design-time (catalog) with runtime (inventory)
Every API has a clear SoR owner — only the owning system should expose the API
The Design-Time / Runtime / Ordering distinction applies identically across Product, Service, and Resource layers