Ukama Systems

Ukama Systems Doc

## Sections
• [Introduction](https://system.docs.ukama.com/introduction.md): Ukama Systems is a collection of software components and services developed by Ukama Inc. These systems are designed to provide various functionalities and capabilities for server-side applications. They are built with a focus on simplicity, flexibility, and modularity, allowing developers to easily integrate them into their projects. The Ukama Systems include components such as API Gateway, Base Rate, Package Management, Subscriber Management, and SIM Manager. Each of these components serves a specific purpose in managing and controlling data flows, communication between services, and handling subscriber-related operations. The systems are built on top of the Ukama Common codebase, which provides shared functionality and utilities that are used across all Ukama projects. This common codebase ensures consistency and reduces code duplication across the systems. To use Ukama Systems, developers can import the required packages and libraries into their projects. The systems are designed to be easily integrated into existing applications and can be customized as per the specific requirements of the project. Overall, Ukama Systems provide a lightweight and simple service mesh and proxy control/data plane for server-side applications. They offer a range of functionalities and capabilities that can enhance the performance, scalability, and reliability of applications.
• [Init System](https://system.docs.ukama.com/init-system.md): The Ukama Init system is a lightweight and simple service mesh and proxy control/data plane for server-side applications. It provides functionality for registering systems, querying system information, sending health updates, restarts, and updates to the init system. The system includes various sub-systems, such as the Sim Pool sub-system, Subscriber sub-system, and Sim Manager sub-system. Each sub-system has its own specific functionality and purpose within the Ukama Init system. The initClient is a client used for registering a system to the local Init and global Init systems. It also handles GRPC communication from services within the system. The initClient can register the system using a unique identifier (UUID) and can query the init system for specific system information. The Ukama Init system supports maintaining URLs as well, in addition to system registration. Overall, the Ukama Init system provides a central control and management point for server-side applications, allowing for easy registration, querying, and communication between systems.
  • [Orgs](https://system.docs.ukama.com/init-system/orgs-1.md): API Section: Orgs The Orgs API section provides functionality to retrieve information about organizations within the Ukama Systems project. This API endpoint allows you to access data related to organizations, such as their names, addresses, and contact information. By making a GET request to this endpoint, you can retrieve a list of all organizations within Ukama Systems. This can be useful for generating reports, displaying a directory of organizations, or performing data analysis. The Orgs API supports pagination, allowing you to fetch the data in smaller chunks if needed. You can specify the number of results per page and navigate through the pages using the pagination links provided in the response. Additionally, the API supports filtering and searching capabilities. You can filter the organizations based on specific criteria, such as location or industry. This allows you to retrieve a subset of organizations that meet your requirements. The Orgs API is designed to be user-friendly, even for non-technical roles. It provides a straightforward way to retrieve organization data without the need for complex queries or programming knowledge. Please refer to the corresponding sections in the documentation for more detailed information on how to use this API endpoint, including examples and parameters.
    • [Get orgs credential](https://system.docs.ukama.com/init-system/orgs-1/get-orgs-credential.md): The "Get orgs credential" API endpoint allows you to retrieve the credentials for a specific organization in the Ukama Systems project. By making a request to this endpoint with the appropriate parameters, you will receive the necessary credentials for the requested organization. This API section is crucial for retrieving credentials that are required for various tasks within the project. Whether you are a developer looking to integrate the Ukama Systems API into your application or a non-technical user who needs access to the organization's credentials, this endpoint provides a straightforward and efficient way to obtain the required information.
    • [Add org and credential](https://system.docs.ukama.com/init-system/orgs-1/add-org-and-credential.md): This API endpoint allows you to add an organization and its associated credentials to the Ukama Systems project. By making a request to this endpoint, you can seamlessly integrate a new organization into the system. The primary use-case for this API is to enable the creation of organizational profiles within Ukama Systems. This functionality is particularly useful for businesses or teams that need to manage multiple entities under a single umbrella. To add an organization, you will need to provide the relevant details and credentials required for authentication and access. These details may include the organization's name, contact information, and any other necessary identifiers. It is important to note that the integration process requires proper authorization and validation. Please ensure that you have the necessary permissions and credentials before making a request to this endpoint. Once an organization is successfully added, it will become part of the Ukama Systems project, allowing you to perform various actions and operations on behalf of that organization. This includes managing data, accessing resources, and utilizing the project's features and functionalities. Please refer to the appropriate sections of the documentation for more detailed information on the request format, required parameters, and possible response codes. Additionally, make sure to review the authentication and authorization guidelines to ensure a secure and seamless integration process. By utilizing the "Add org and credential" API endpoint, you can easily incorporate new organizations into the Ukama Systems project, streamlining your workflow and enhancing collaboration within your business or team.
    • [Update orgs credential](https://system.docs.ukama.com/init-system/orgs-1/update-orgs-credential.md): Update Orgs Credential API This API endpoint allows you to update the credentials of an organization in the Ukama Systems project. By making a PATCH request to /init/v1/orgs/{org}, you can modify the credentials associated with a specific organization. Use this API when you need to update the authentication or authorization details for an organization in Ukama Systems. The API accepts the necessary parameters to make the required changes to the organization's credentials. This API is particularly useful in scenarios where organizations need to update their access credentials due to changes in personnel, security requirements, or other factors. It provides a straightforward way to ensure that the organization's access remains up-to-date and secure. Keep in mind that you will need to provide the appropriate authorization and authentication details to access this API endpoint. Make sure you have the necessary permissions before attempting to update an organization's credentials. Please refer to the relevant sections in the documentation for detailed examples, parameter explanations, and response details to successfully integrate this API into your application.
  • [Nodes](https://system.docs.ukama.com/init-system/nodes-1.md)
    • [Get orgs credential for node](https://system.docs.ukama.com/init-system/nodes-1/get-orgs-credential-for-node.md): This API endpoint allows you to retrieve the organization's credential for a specific node in the Ukama Systems project. By making a request to this endpoint, you will receive the necessary information to authenticate and access the node's resources within the organization. This functionality is particularly useful for developers who need to integrate their applications or systems with the Ukama Systems platform and require secure access to specific nodes. The information returned by this API will enable seamless integration and smooth communication between your application and the targeted node.
    • [Add node to org](https://system.docs.ukama.com/init-system/nodes-1/add-node-to-org.md): This API endpoint allows you to add a node to an organization. By making a PUT request to /init/v1/orgs/{org}/nodes/{node}, you can associate a node with a specific organization in the Ukama Systems project. This functionality is useful when you want to assign a node to a particular organization within the project. It enables you to organize and manage nodes by connecting them to the appropriate organization. To use this API endpoint, you should include the organization ID ({org}) and the node ID ({node}) in the URL. The request body should contain any additional information or data required for the node to be associated with the organization. Please note that this API endpoint only supports the PUT method, indicating that it updates the existing relationship between the node and the organization. It does not create a new node or organization. Take into consideration that integrating this API endpoint requires understanding the structure and conventions of the Ukama Systems project. It is recommended to familiarize yourself with the overall documentation to ensure successful integration and alignment with the project's goals. By utilizing this API endpoint, you can easily connect nodes to organizations within the Ukama Systems project, facilitating efficient organization and management of resources.
    • [Delete node from org](https://system.docs.ukama.com/init-system/nodes-1/delete-node-from-org.md): This API endpoint allows you to delete a node from an organization in the Ukama Systems project. By using this functionality, you can remove a specific node from an organization, which can be useful in managing the nodes within your organization. This endpoint is designed to be straightforward and user-friendly, making it easy for developers and non-technical roles to integrate and utilize the API effectively. Additionally, there aren't any special features or considerations to keep in mind when using this API endpoint.
  • [Systems](https://system.docs.ukama.com/init-system/systems.md): This section of the Ukama Systems API allows you to retrieve information about various systems within the Ukama platform. By making a GET request to the Systems endpoint, you can access details such as system names, unique identifiers, and additional metadata. This API section is particularly useful for developers who need to programmatically access and retrieve system information for various purposes. For example, you can use this endpoint to gather data for system monitoring, reporting, or integration with other applications. When making a GET request to the Systems endpoint, you will receive a response containing the relevant system data in a structured format. This data can be used to populate user interfaces, generate reports, or perform any necessary operations based on the retrieved system information. It's important to note that this endpoint does not require any parameters in the request, as it provides a comprehensive list of all available systems. However, please ensure that you have the necessary authentication credentials to access this data. The Ukama Systems API also includes other sections and endpoints that allow you to interact with different aspects of the platform. Feel free to explore the documentation to learn more about the capabilities and integrations that can be achieved using the Ukama Systems API.
    • [Get system credential for org](https://system.docs.ukama.com/init-system/systems/get-system-credential-for-org.md): This API endpoint allows you to retrieve the system credential for a specific organization and system. By making a request to this endpoint, you will receive the system credential associated with the provided organization and system. This credential is necessary for authenticating and authorizing access to the system's resources and functionalities. This endpoint is particularly useful when you need to programmatically access the system's data or perform actions on behalf of the organization. To use this endpoint, you need to provide the organization and system parameters in the URL. Once the request is successful, you will receive the system credential in the response. It's important to note that the system credential should be kept secure and not shared with unauthorized individuals or applications. This credential grants access to the system's sensitive information and actions, so it should be handled with care. If you encounter any issues or have questions related to this API endpoint, please refer to the other sections of this documentation for more detailed information on how to use it effectively.
    • [Add or update system credential for org](https://system.docs.ukama.com/init-system/systems/add-or-update-system-credential-for-org.md): This API endpoint allows you to add or update a system credential for an organization in the Ukama Systems project. By using this endpoint, you can easily integrate your systems with Ukama Systems and securely authenticate them. With this API, you can manage and maintain system credentials for different organizations within the project. This allows you to easily keep track of the systems authorized to access and interact with the project. By adding or updating system credentials, you can ensure seamless integration between your systems and Ukama Systems. This enables efficient data exchange and collaboration across various platforms and applications. To use this API, you need to provide the necessary information for the organization and system you want to add or update credentials for. The API will then handle the authentication and authorization process, ensuring secure and reliable access to Ukama Systems. It's important to note that the credentials you provide should be valid and authorized by the organization. This ensures that only authorized systems can access and interact with the project. By following the guidelines and requirements provided in the documentation, you can successfully add or update system credentials for your organization within the Ukama Systems project.
    • [Delete system credential for org](https://system.docs.ukama.com/init-system/systems/delete-system-credential-for-org.md): This API section allows you to delete system credentials for a specific organization and system within the Ukama Systems project. By making a request to this API endpoint, you can remove the credentials associated with a particular system, ensuring that access to sensitive information is revoked. This functionality is particularly useful when a system is no longer in use or when there is a need to revoke access for security reasons. Please note that this API endpoint requires you to provide the organization and system identifiers as part of the URL path.
    • [Update system credential](https://system.docs.ukama.com/init-system/systems/update-system-credential.md): This API endpoint allows you to update the credential for a system in the Ukama Systems project. With this functionality, you can easily manage and modify the credentials associated with a specific system. This API is particularly useful for developers and administrators who need to regularly update and maintain system credentials. By utilizing this endpoint, you can ensure that the system credentials within the Ukama Systems project are always up-to-date and accurate.
• [Registry System](https://system.docs.ukama.com/registry-system.md): The Ukama Registry system is a comprehensive platform that manages various aspects of an organisation's operations. It consists of three main components: Invitation, Member, and Node. The Invitation component allows organizations to send invitations to individuals, inviting them to join the organisation. This can include inviting new members, partners, or collaborators. The Invitation service handles the creation, retrieval, and management of invitations. It enables organizations to track the status of invitations, update their status, and delete invitations when necessary. This component streamlines the process of onboarding new members and facilitates communication and collaboration within organisations. The Member component focuses on managing the members within an organisation. It provides functionality to add new members, update member information, and remove members if needed. The Member service ensures that member data is stored securely and can be accessed when required. Organizations can retrieve information about individual members, such as their role within the organization, contact details, and other relevant data. This component plays a crucial role in maintaining an up-to-date and accurate record of an organization's members. The Node component handles the management of nodes within the registry system. Nodes represent different entities or elements within the organization, such as servers, devices, or endpoints. The Node service allows organisations to add new nodes, update node information, and delete nodes as necessary. It provides functionalities to attach nodes to specific networks or detach them from networks. This component enables organizations to keep track of their network infrastructure and manage the relationships between different nodes and networks. Overall, the Ukama Registry system provides a comprehensive solution for organizations to manage invitations, members, and nodes efficiently. It streamlines processes, enhances collaboration, and ensures that organisations have accurate and up-to-date information about their members and network infrastructure.
  • [Invitations](https://system.docs.ukama.com/registry-system/invitations.md): Ukama Systems API - Invitations The Invitations API endpoint allows you to manage invitations within the Ukama Systems platform. With this API, you can create, retrieve, update, and delete invitations. Use the Invitations API to seamlessly integrate invitation functionality into your application. This feature is particularly useful for applications that require user onboarding or invitation-based access control. When creating invitations, you can specify the recipient's email address, a personalized message, and any additional information required for the invitation. The API will generate a unique invitation code that can be sent to the recipient via email or other communication channels. Retrieving invitations enables you to access detailed information about existing invitations in the system. This includes the invitation code, status (pending, accepted, or declined), and any associated metadata. Updating invitations allows you to modify invitation details such as the recipient's email address or the personalized message. You can also change the status of an invitation, for example, marking it as accepted or declined. Deleting invitations removes an invitation from the system. This can be useful when invitations are no longer valid or when you need to revoke access for a specific recipient. In addition to these basic functionalities, the Invitations API provides several advanced features. You can retrieve a list of all invitations, filter invitations based on specific criteria, or sort them based on different parameters. This allows for easy management and organization of invitations within your application. Please note that the Invitations API requires authentication for all requests. You will need to include your API key in the headers of each request to ensure secure and authorized access. Overall, the Invitations API simplifies the process of managing invitations within the Ukama Systems platform. Whether you need to create, retrieve, update, or delete invitations, this API provides all the necessary functionality to seamlessly integrate invitation management into your application.
    • [Get invitation](https://system.docs.ukama.com/registry-system/invitations/get-invitation.md): Get Invitation: This API endpoint allows you to retrieve a specific invitation from the registry. By providing the unique identifier (invitation_id) of the invitation as a parameter, you can access all the relevant details associated with it. This functionality is particularly useful when you need to retrieve specific information about an invitation, such as the sender, recipient, date of creation, and any additional custom data associated with the invitation. Use-cases for this API include scenarios where you want to display the details of a particular invitation to a user interface, retrieve invitation data for analytical purposes, or perform any other actions that require access to invitation information. Please note that the invitation_id parameter is essential for targeting a specific invitation. Make sure to provide the correct invitation_id value to retrieve the desired invitation.
    • [Remove invitation](https://system.docs.ukama.com/registry-system/invitations/remove-invitation.md): Remove invitation: This API endpoint allows you to remove an invitation from an organization. By using this functionality, you can easily manage your organization's invitations and ensure that only the intended recipients have access. This feature is particularly useful when invitations need to be revoked or when there are changes in the organization's structure. Whether you are a developer integrating our API into your application or a non-technical user responsible for managing invitations, this endpoint provides a straightforward method to remove invitations and maintain control over your organization's access.
    • [Update invitation](https://system.docs.ukama.com/registry-system/invitations/update-invitation.md): Update Invitation This API endpoint allows you to update a specific invitation in the Ukama Systems registry. It provides a convenient way to modify invitation details without the need for manual edits in the system. By making a PATCH request to this endpoint with the specific invitation ID, you can update various attributes associated with the invitation. This includes fields such as the invitee's name, email address, and any additional custom information that may be relevant to your use-case. This API functionality is particularly useful in scenarios where you need to make changes to an existing invitation, such as correcting a misspelled name or updating contact information. Instead of creating a new invitation from scratch, you can efficiently update the relevant fields using this API. It's important to note that this endpoint adheres to RESTful principles and follows the PATCH method semantics. This means that you only need to provide the fields you want to update in the request payload, rather than sending the entire invitation object. This helps minimize data transfer and simplifies the integration process. When using this API endpoint, keep in mind the security considerations associated with updating invitation information. Ensure that appropriate authorization mechanisms are in place to authenticate the API requests and restrict access to authorized personnel only. The Update Invitation API provides a powerful tool for managing and maintaining the accuracy of invitation details within the Ukama Systems registry. Use it to streamline your workflow and ensure that invitation information stays up-to-date with minimal effort.
    • [Add invitation](https://system.docs.ukama.com/registry-system/invitations/add-invitation.md): Add a new invitation to an organization's registry.
    • [Get invitation by org](https://system.docs.ukama.com/registry-system/invitations/get-invitation-by-org.md): This API endpoint allows you to retrieve all invitations associated with a specific organization. By specifying the organization in the request, you will receive a list of invitations that have been sent by the organization. This information can be useful for tracking and managing invitations within your application.
  • [Members](https://system.docs.ukama.com/registry-system/members.md): API Section Description: The Members API section provides functionality for retrieving information about members in the Ukama Systems project. This API endpoint allows you to access details such as member name, contact information, and membership status. You can use this API section to retrieve a specific member's information by providing their unique identifier. Additionally, you can retrieve a list of all members or filter the results based on specific criteria, such as membership status or date of registration. The Members API section is particularly useful for integrating member data into various systems and applications. By using this API, you can display member information on your website or application, automate member-related processes, or synchronize member data with other systems. Please note that when making requests to this API endpoint, you may need to include authentication credentials to ensure the security and integrity of member data. Refer to the authentication section for more information on how to securely access the Members API. Overall, the Members API section simplifies the process of retrieving and managing member information within the Ukama Systems project. Whether you need to retrieve specific member data or work with a larger set of members, this API provides the necessary functionality to streamline your integration efforts.
    • [Get members](https://system.docs.ukama.com/registry-system/members/get-members.md): This API endpoint allows you to retrieve all members of an organization. By making a request to this endpoint, you will receive a response that includes the details of all members associated with the specified organization. This can be useful for various use cases, such as displaying a list of members within an application or performing analytics on member data. Please note that this endpoint specifically returns information related to members only, and not any other entities within the organization. If you need to retrieve information about other aspects of the organization, you will need to use different API endpoints. When integrating this API endpoint into your application, ensure that you have the necessary authentication credentials and permissions to access the organization's member data. Additionally, consider any rate limits or quotas that may apply to your API calls, as outlined in the overall API documentation. Keep in mind that the response from this API endpoint may include a large amount of data, depending on the size of the organization and the number of members it has. Make sure to handle the response appropriately in your application to avoid any performance or data processing issues. To learn more about the specific parameters, response format, and examples related to this API endpoint, please refer to the corresponding sections in the documentation.
    • [Add member](https://system.docs.ukama.com/registry-system/members/add-member.md): This API endpoint allows you to add a new member to an organization in the Ukama Systems project. By utilizing this functionality, you can easily integrate member registration into your application or platform. Whether you are a developer or a non-technical user, this API makes it straightforward to handle member addition seamlessly. Additionally, the endpoint includes special features and considerations that can enhance your integration process.
    • [Get member](https://system.docs.ukama.com/registry-system/members/get-member.md): This API endpoint allows you to retrieve information about a specific member within an organization. By providing the unique identifier (UUID) of the member, you can access details such as their name, contact information, and role within the organization. This functionality is particularly useful when you need to retrieve specific information about a member for tasks such as updating their profile, managing their permissions, or generating reports. The API endpoint is designed to make integration with the Ukama Systems platform straightforward, allowing you to easily access and manipulate member data to meet the needs of your organization.
    • [Remove member](https://system.docs.ukama.com/registry-system/members/remove-member.md): Remove member from an organization: This API endpoint allows you to remove a member from an organization in the Ukama Systems project. By utilizing this functionality, you can easily manage the members within your organization. Use Cases: - Remove an inactive or former member from the organization to maintain accurate records. - Restrict access to sensitive information by removing a member who no longer requires access. Special Features/Considerations: - This action cannot be undone, so ensure you have the appropriate authorization and confirmation before proceeding with the removal. - When a member is removed, their access privileges, including permissions and roles, will be revoked. - Any data associated with the removed member will be retained, but they will no longer be able to access or modify it. - It is recommended to communicate with the member before removing them to avoid any disruption or confusion. Note: This description assumes familiarity with the Ukama Systems project and the concept of organizations and members within it. If you are unsure about any terminology used, please refer to the corresponding sections in the documentation.
    • [Update member](https://system.docs.ukama.com/registry-system/members/update-member.md): Update Member This API endpoint allows you to update a member of an organization. With this feature, you can modify various attributes of a member's profile, such as their name, email address, and role within the organization. By using this API, you can seamlessly manage your organization's members and keep their information up to date. Whether you need to change a member's role, update their contact details, or make any other necessary adjustments, this API provides a straightforward way to do it. Additionally, this API supports batch updates, enabling you to update multiple members at once. This can be especially useful when you need to make a large number of changes across your organization. Please note that only authorized users with the necessary permissions can make use of this API to update members. Make sure you have the appropriate credentials and permissions before attempting to use this endpoint. Integrating this API into your application will help you maintain accurate and current member information within your organization, streamlining your operations and ensuring that your member data is always up to date.
    • [Add a member of other org](https://system.docs.ukama.com/registry-system/members/add-a-member-of-other-org.md): The post /registry/v1/members/others API endpoint allows you to add a member to an organization who is already an existing member of another organization. This functionality streamlines the process of integrating members from multiple organizations into your system. By using this API endpoint, you can effortlessly manage and track the memberships of individuals who belong to more than one organization. This feature is particularly useful when dealing with complex organizational structures or when working with individuals who have affiliations with multiple organizations. Plus, with the straightforward nature of this API, developers and non-technical roles alike can easily understand and implement the necessary steps for adding members to your system.
  • [Networks](https://system.docs.ukama.com/registry-system/networks.md): The Networks API endpoint provides access to information about networks within the Ukama Systems project. This API allows you to retrieve details such as network name, status, and associated devices. It also enables you to perform actions on networks, such as adding or removing devices, updating network settings, and monitoring network performance. By using the Networks API endpoint, developers can integrate network management functionality into their applications or systems. This can be particularly useful for organizations that need to automate network provisioning, monitor network health, or perform network-related tasks programmatically. Non-technical roles can also benefit from the Networks API documentation as it provides an overview of the available network management capabilities. This can help them understand how networks can be managed within the Ukama Systems project and what actions can be performed on them. When working with the Networks API, it's important to consider the security of the network-related operations. Proper authentication and authorization mechanisms should be implemented to ensure that only authorized users can access and modify network information. Overall, the Networks API endpoint simplifies the integration of network management functionality, making it straightforward for developers to work with networks within the Ukama Systems project.
    • [Get networks](https://system.docs.ukama.com/registry-system/networks/get-networks.md): The Get Networks API endpoint allows you to retrieve a list of all the networks associated with an organization in the Ukama Systems project. This endpoint is especially useful for obtaining an overview of the networks within an organization. By making a request to this endpoint, you will receive a response containing detailed information about each network, including its unique identifier, name, and any other relevant attributes. This information can be valuable for various purposes, such as managing and monitoring networks, analyzing network patterns, or generating reports. Additionally, this API endpoint supports pagination, allowing you to retrieve networks in smaller, manageable chunks if the organization has an extensive network structure. You can specify the number of networks per page and navigate through the pages using the appropriate pagination parameters. It is important to note that this API endpoint requires proper authentication and authorization, ensuring that only authorized users can access the organization's networks. Make sure to include the necessary authentication credentials in your API requests to avoid any unauthorized access issues. In summary, the Get Networks API endpoint provides a straightforward way to retrieve a list of networks associated with an organization in the Ukama Systems project. The response includes detailed information about each network and supports pagination for easier data retrieval. Proper authentication and authorization are required to access this endpoint.
    • [Add network](https://system.docs.ukama.com/registry-system/networks/add-network.md): Add a new network to an organization
    • [Get network](https://system.docs.ukama.com/registry-system/networks/get-network.md): This API endpoint allows you to retrieve information about a specific network within the Ukama Systems. By providing the unique identifier of the network (net_id) as a parameter in the request, you can access detailed information about that network. This functionality is particularly useful for developers and non-technical roles who need to gather specific information about a network within the Ukama Systems. By making use of this API, you can easily retrieve relevant details without the need for complex manual processes. Additionally, this API supports integration with other systems or applications by providing a straightforward way to retrieve network information programmatically. This enables seamless integration between Ukama Systems and your existing systems or applications, enhancing efficiency and productivity. Please note that when using this API endpoint, you should ensure that you have the necessary authorization and access rights. Security measures are in place to protect the confidentiality and integrity of the network data. Detailed instructions on authentication and authorization can be found in the relevant sections of the documentation. To retrieve a specific network, simply include the network's unique identifier (net_id) as a parameter in your API request. The response will provide comprehensive information about the network, including its attributes, configuration, and related data. By leveraging the capabilities of this API endpoint, you can easily access and utilize network information within the Ukama Systems, streamlining your workflows and enabling better decision-making.
    • [Get sites](https://system.docs.ukama.com/registry-system/networks/get-sites.md): This API endpoint allows you to retrieve all the sites associated with a specific network. By providing the network ID as a parameter, you can easily access information about the various sites within that network. This functionality is particularly useful for managing and monitoring multiple sites within a larger network. Whether you need to retrieve site information for reporting purposes or for performing specific actions on individual sites, this API endpoint simplifies the process by providing a straightforward way to access site data.
    • [Add site](https://system.docs.ukama.com/registry-system/networks/add-site.md): Add a new site to a network. This API endpoint allows you to add a site to a specific network in the Ukama Systems project. By making a request to this endpoint, you can create a new site with the necessary information, such as the site name, location, and other relevant details. This functionality is useful when you need to expand the network and include additional sites. Please note that the network ID parameter must be provided in the request URL to specify the target network.
    • [Get site](https://system.docs.ukama.com/registry-system/networks/get-site.md): This API endpoint allows you to retrieve the details of a specific site within a network. By providing the network ID and site ID as path parameters, you can access the desired information. Use Cases: Obtain site information: Retrieve detailed information about a specific site in a network by specifying the network ID and site ID. Special Features/Considerations: Path Parameters: The API requires the network ID and site ID as path parameters in order to fetch the desired site information. Accurate site details: This endpoint provides accurate and up-to-date information regarding the specified site, ensuring the data retrieved is reliable for further use. Please note that additional sections of the documentation provide further details on the available response examples, parameters, and any other relevant information necessary for successful integration with the Ukama Systems API.
  • [Nodes](https://system.docs.ukama.com/registry-system/nodes.md): The Nodes API section provides functionality for retrieving information about nodes within the Ukama Systems project. Nodes represent various entities or components within the system, such as users, devices, or applications. This API endpoint allows you to retrieve detailed information about a specific node or a list of nodes based on certain criteria. The response includes essential details about each node, such as its unique identifier, name, type, and any associated metadata. Use the Nodes API to retrieve information about specific nodes or to gather data for further analysis or processing. For example, you can use this API to fetch details about a user's devices or to retrieve a list of applications associated with a particular node type. Keep in mind that the Nodes API requires authentication using a valid API key. Make sure to include the necessary authorization headers in your requests to ensure a successful integration. Additionally, certain parameters may be available to narrow down your search, such as filtering nodes based on their type or specific attributes. Please refer to the other sections of the documentation for more detailed information on how to construct API requests, handle responses, and explore additional features of the Nodes API.
    • [Get nodes](https://system.docs.ukama.com/registry-system/nodes/get-nodes.md): This API endpoint allows you to retrieve information about nodes within the Ukama Systems registry. With this functionality, you can access details about all nodes or filter the results to retrieve only free nodes. This information can be useful for various use-cases, such as managing and monitoring the nodes within the system. Additionally, there may be special features or considerations related to this API section that will be covered in detail in the documentation.
    • [Add node](https://system.docs.ukama.com/registry-system/nodes/add-node.md): To add a new node to an organization, use the "Add node" API endpoint. This functionality allows you to easily integrate Ukama Systems into your organization's infrastructure. By calling this endpoint, you can effortlessly create and manage nodes within your organization's registry. The "Add node" API endpoint is designed to streamline the process of adding a node to your organization. It provides a straightforward and efficient way to expand your registry and enhance your organization's capabilities. This functionality is not limited to technical roles but is also relevant to non-technical roles within your organization. Whether you are a developer looking to integrate Ukama Systems into your application or a non-technical team member responsible for managing the organization's registry, this API endpoint simplifies the process for both parties. Furthermore, the "Add node" API endpoint offers additional features and considerations to ensure a seamless integration experience. These features include handling of error responses, secure authentication mechanisms, and the ability to manage and update node information. By leveraging this API endpoint, you can easily add new nodes to your organization, enhancing the functionality and flexibility of Ukama Systems within your infrastructure.
    • [Get node](https://system.docs.ukama.com/registry-system/nodes/get-node.md): Get Node: The "Get Node" API endpoint allows you to retrieve detailed information about a specific node in the Ukama Systems registry. By providing the {node_id} parameter in the API request, you can access the desired node's data. This API call provides a comprehensive overview of the node, including its attributes, relationships, and other relevant information. This endpoint is particularly useful for developers working on integrations with Ukama Systems or for non-technical roles needing to gather specific details about a node within the registry. Please note that to access this API endpoint, appropriate authentication and authorization credentials are required. Make sure to include the necessary authentication headers in your requests. With the "Get Node" API endpoint, you can effortlessly retrieve all the essential information about the desired node, facilitating seamless integration and empowering non-technical stakeholders to extract the data they need.
    • [Update node](https://system.docs.ukama.com/registry-system/nodes/update-node.md): **Update Node** The Update Node API endpoint allows you to modify the name or state of a specific node in the Ukama Systems registry. By making a request to this endpoint, you can update the information associated with a particular node. This API is particularly useful when you need to change the name or state of a node in the registry. For example, if a node's name needs to be corrected or if the state of a node needs to be updated to reflect a change in its status, you can use this endpoint to make those modifications. It's important to note that this API endpoint requires the `node_id` parameter, which specifies the ID of the node you want to update. Make sure to include this parameter in your request to ensure that the changes are made to the correct node. Additionally, when using this endpoint, consider the following: 1. Only authorized users with the appropriate permissions can update nodes through this API. 2. Take note of the expected format for the `node_id` parameter to ensure accurate data retrieval. 3. Carefully construct your request payload to include the updated name or state of the node you want to modify. By following these guidelines, you can easily integrate the Update Node API endpoint into your application and streamline the process of updating node information in the Ukama Systems registry.
    • [Delete node](https://system.docs.ukama.com/registry-system/nodes/delete-node.md): Delete Node The Delete Node API endpoint allows you to remove a node from the organization. This functionality is particularly useful when you want to remove a node that is no longer needed or has been deprecated. By using this API, you can easily delete a specific node identified by its unique node ID. This action will permanently remove the node from the organization's registry. Deleting a node can have significant implications, so it is important to consider the following before proceeding: 1. Be aware that deleting a node will result in the loss of all associated data and configurations. Make sure to back up any important information before performing this action. 2. Deleting a node cannot be undone. Once a node is deleted, it cannot be recovered. Take caution and double-check that you are deleting the correct node. 3. Deleting a node might affect other parts of the system that rely on its functionality or data. Ensure that you have considered any dependencies before proceeding with the deletion. Use cases for the Delete Node API endpoint include: - Removing nodes that are no longer required or have become obsolete. - Cleaning up the organization's registry by deleting unused or redundant nodes. - Performing system maintenance or housekeeping tasks. To use the Delete Node API endpoint, you need to provide the node ID of the node you wish to delete as a parameter in the API call. This will ensure that the correct node is targeted for deletion. Please note that the Delete Node API endpoint does not support any additional parameters or options. It is a simple and straightforward method for removing nodes from the organization's registry. Before using this API, make sure to understand the implications and consider any potential impact on the system.
    • [Update node state](https://system.docs.ukama.com/registry-system/nodes/update-node-state.md): The update node state endpoint allows you to modify the state of a specific node in the Ukama Systems registry. This functionality enables you to change the status or condition of a node based on your specific requirements. By making a request to this endpoint with the appropriate parameters, you can easily update the state of a node to reflect its current state accurately. This API endpoint is useful for managing and controlling the state of nodes within the Ukama Systems registry, providing flexibility and control over your system's functionality.
    • [Attach node](https://system.docs.ukama.com/registry-system/nodes/attach-node.md): The Attach node API endpoint allows you to attach a node within the Ukama Systems registry. This functionality is part of the Group nodes feature, which enables you to organize and manage nodes within the registry. With the Attach node API, you can easily associate a specific node with a parent node identified by its unique ID. This association establishes a hierarchical relationship between the nodes, allowing you to organize and structure your data effectively. By attaching nodes, you can create a nested structure within the registry, reflecting the relationships and dependencies between different elements of your system. This can be particularly useful when organizing complex datasets or representing hierarchical data models. The Attach node API endpoint provides a straightforward and efficient way for developers to integrate this functionality into their applications. By making use of this endpoint, you can easily manage and manipulate the structure of your Ukama Systems registry, ensuring that it accurately represents the relationships between the nodes in your system. Please refer to the other sections of the documentation for more detailed information on the specific parameters, response examples, and usage considerations related to the Attach node API endpoint.
    • [Dettach node](https://system.docs.ukama.com/registry-system/nodes/dettach-node.md): API endpoint: Detach node The "Detach node" API endpoint allows you to remove a node from a group within the Ukama Systems project. This functionality is particularly useful when you need to reorganize your nodes or if a node is no longer relevant to a specific group. By using this API endpoint, you can easily detach a node from its current group without affecting its overall configuration or data. This action will not delete the node from the system; it simply moves the node out of the group it was previously associated with. Whether you are a developer or a non-technical user, integrating this API endpoint into your workflow is straightforward. Simply specify the unique identifier of the node you wish to detach, and the API will handle the rest. This allows you to easily manage and manipulate your node groups in a way that suits your needs. Please note that detaching a node may affect any processes or systems that rely on the node's previous group association. Make sure to assess the potential impact before detaching a node to ensure a smooth transition. The "Detach node" API endpoint in the Ukama Systems project provides a seamless way to reorganize and manage your nodes within different groups, allowing for greater flexibility and control over your system's structure.
    • [Add to site](https://system.docs.ukama.com/registry-system/nodes/add-to-site.md): Add to site This API endpoint allows you to add a node to a site. By making a POST request to this endpoint with the specific node ID, you can associate the node with the desired site. This functionality is particularly useful when you want to link a node to a specific location or category within a site. Using this API, you can seamlessly integrate nodes into your existing sites. Whether you are creating a complex web application or a simple blog, this endpoint provides a straightforward way to add nodes to the desired location within your site structure. Please note that when making a request to this endpoint, you need to ensure that the node ID and site information are correctly provided. Failing to include the necessary details may result in errors or incomplete data association. By leveraging the power of this API endpoint, you can easily and efficiently manage the placement of nodes within your sites, enhancing the overall functionality and user experience of your application.
    • [Release from site](https://system.docs.ukama.com/registry-system/nodes/release-from-site.md): This API section allows you to release a node from a site in the Ukama Systems project. By using this API endpoint, you can easily remove a node from its current site. This functionality is particularly useful when you want to reassign a node to a different site within the project. The release process is straightforward and can be executed with a single HTTP request. This API section provides the necessary functionality to ensure smooth integration and efficient management of nodes within the Ukama Systems project.
    • [Get nodes for network](https://system.docs.ukama.com/registry-system/nodes/get-nodes-for-network.md): This API endpoint allows you to retrieve all nodes associated with a specific network. By making a request to this endpoint with the network ID parameter, you can obtain a list of nodes that belong to that network. This information can be useful for various purposes, such as analyzing network connectivity or managing network resources. Whether you are a developer looking to integrate this functionality into your application or a non-technical user interested in gaining insights from network data, this API endpoint provides a straightforward way to retrieve the desired information. Please refer to the accompanying sections for detailed examples and parameters related to this API endpoint.
    • [Get nodes for site](https://system.docs.ukama.com/registry-system/nodes/get-nodes-for-site.md): This API endpoint allows you to retrieve all the nodes associated with a specific site. Nodes can represent various elements of a site, such as pages, posts, or categories. By using this endpoint, you can easily obtain a list of all the nodes belonging to a particular site for further processing or analysis. Whether you are a developer building an application that requires access to site nodes or a non-technical user wanting to gather information about a site's structure, this API endpoint simplifies the task of retrieving the necessary data. Additionally, this endpoint offers the flexibility to retrieve nodes belonging to a specific site by providing the site ID as a parameter. This feature allows for targeted data retrieval, making it easier to work with larger datasets and ensuring efficient integration with other systems or applications.
• [Data Plan System](https://system.docs.ukama.com/data-plan-system.md): The Ukama Data Plan system is a comprehensive system that manages all the sim packages and base rates functionality. It consists of three sub-systems: the API Gateway, the Base Rate sub-system, and the Package sub-system. The API Gateway acts as a central entry point for all the requests made to the Data Plan system. It handles the authentication and routing of requests to the appropriate sub-systems. It provides a unified interface for clients to interact with the system. The Base Rate sub-system is responsible for managing the base rates for different services such as SMS, data, and voice. It provides functionalities to retrieve base rates based on various parameters like country, provider, and SIM type. It also allows the upload of new base rates. The Package sub-system manages the sim packages offered by Ukama. It provides functionalities to add, delete, update, and retrieve sim packages. Each package has associated rates for SMS, data, and voice services. The Package sub-system also allows the retrieval of packages based on the organization ID. Overall, the Ukama Data Plan system ensures efficient management of sim packages and base rates. It provides a seamless experience for both clients and administrators by offering a unified interface and robust functionalities for managing packages and rates.
  • [Baserates](https://system.docs.ukama.com/data-plan-system/baserates.md): The Baserates API section provides access to the base rates for different currencies used in the Ukama Systems project. This API endpoint allows you to retrieve the current base rates for currencies such as USD, EUR, GBP, and more. The base rates are updated regularly to ensure accurate currency conversions. This API section is particularly useful for developers who need to retrieve the latest base rates for their applications or services. By integrating with this endpoint, you can easily access the base rates without the need for manual data entry or updates. To use this API section, you will need to make a GET request to the specified endpoint. The response will include the base rates for the requested currencies, providing you with the necessary information for currency conversions. It's important to note that the base rates returned by this API are subject to change based on market fluctuations. Therefore, it is recommended to regularly update and refresh the base rates in your application to ensure accurate currency conversions. Overall, the Baserates API section simplifies the process of retrieving and using base rates for currency conversions in the Ukama Systems project.
    • [Get baserates](https://system.docs.ukama.com/data-plan-system/baserates/get-baserates.md): This API section allows you to retrieve baserates from the Ukama Systems platform. Baserates serve as a reference point for pricing calculations and are used to determine the cost of various services offered by Ukama Systems. By making a request to this endpoint, you can obtain the current baserates that are applicable for your specific use-case. This information can be useful for developers who need to programmatically access and utilize baserates within their applications. Additionally, non-technical roles can benefit from understanding the concept of baserates and how they are utilized in the Ukama Systems platform. The API provides a straightforward way to retrieve the most up-to-date baserates, enabling seamless integration with Ukama Systems.
    • [Get baserate](https://system.docs.ukama.com/data-plan-system/baserates/get-baserate.md): This API section allows you to retrieve the historical baserate data for Ukama Systems. By making a request to the specified endpoint, you will receive the relevant information for the desired time period. This functionality is particularly useful for tracking and analyzing changes in baserates over time. Whether you are a developer looking to integrate this data into your application or a non-technical user interested in understanding the historical trends of Ukama Systems' baserates, this API section provides a straightforward way to access the required information. Keep in mind that the response examples and parameters for this API endpoint will be covered in other sections of the documentation.
    • [Get baserate](https://system.docs.ukama.com/data-plan-system/baserates/get-baserate-1.md)
    • [Get baserate for package](https://system.docs.ukama.com/data-plan-system/baserates/get-baserate-for-package.md): The 'get /dataplan/v1/baserates/package' API endpoint allows you to retrieve the baserate for a specific package in the Ukama Systems project. This functionality is essential for obtaining the base pricing information associated with different packages offered by Ukama Systems. By making a request to this API endpoint, you will receive the baserate for the specified package. This information is crucial for various use-cases, such as calculating the total cost of a package and making informed decisions based on pricing. It's important to note that this API endpoint is designed to provide a straightforward and efficient way to access the baserate for a package. With this information, developers and non-technical roles can easily integrate the Ukama Systems API into their applications, ensuring accurate pricing and a seamless user experience. When using this API endpoint, please consider that the response will only include the baserate information for the specified package. Additional details or parameters may be required to complete other operations related to the Ukama Systems project.
    • [Get baserate](https://system.docs.ukama.com/data-plan-system/baserates/get-baserate-2.md)
    • [Upload baserates](https://system.docs.ukama.com/data-plan-system/baserates/upload-baserates.md): This API endpoint allows you to upload baserates in the Ukama Systems project. By making a POST request to this endpoint, you can upload baserates data to the system. This functionality is useful for updating or adding baserates information within the project. It is particularly helpful for organizations that need to manage and track baserates for various purposes. The API endpoint is designed to handle the upload of baserates securely, ensuring the integrity of the data. This feature simplifies the process of integrating baserates into your system and enables seamless data synchronization between the Ukama Systems project and your application.
  • [Packages](https://system.docs.ukama.com/data-plan-system/packages.md): API Section: Packages This API section provides access to information about packages within the Ukama Systems project. Packages are a central feature of the system and allow users to group related items together for easier management and organization. With this API, you can retrieve detailed information about individual packages, including their name, description, pricing, and availability. This allows you to programmatically access and display package details on your own platform or integrate them into your application. The Packages API also supports searching for packages based on various criteria such as keywords, categories, or price ranges. This enables you to offer advanced filtering options to your users, helping them find the packages that best suit their needs. Additionally, the API provides the ability to create, update, and delete packages. This makes it possible to automate package management tasks and keep your systems in sync with the latest package information. Please note that some package information, such as pricing or availability, may be subject to change over time. It's recommended to regularly check for updates and synchronize your data accordingly to ensure accurate and up-to-date information for your users. Whether you're building a custom storefront, managing package subscriptions, or integrating package information into your application, the Packages API offers a comprehensive set of endpoints and features to streamline your integration process and enhance the overall user experience.
    • [Add package](https://system.docs.ukama.com/data-plan-system/packages/add-package.md): This section of the Ukama Systems API allows you to add a new package to the system. Packages are a way to group related data and define access and usage limits. By making a POST request to the '/dataplan/v1/packages' endpoint, you can create a new package with the desired settings. The endpoint expects the necessary parameters to be included in the request body. This API functionality is particularly useful for managing and organizing data in your system. It enables you to define different packages with specific access and usage limits, which can be beneficial for various use-cases. When integrating this API endpoint, it is important to ensure that you provide all the required parameters in the request body and follow the defined data format. Additionally, you should consider any special features or considerations specific to your implementation. Overall, the ability to add packages through this API endpoint simplifies the process of managing data and access restrictions in the Ukama Systems platform, making integration straightforward and efficient.
    • [Get package](https://system.docs.ukama.com/data-plan-system/packages/get-package.md): This API section allows you to retrieve information about a specific data package. By providing the UUID of the package, you can access details such as the package name, price, and data allowance. This endpoint is useful for developers who need to retrieve package information for various use cases, such as displaying available packages to users or managing package subscriptions. Additionally, this API section offers functionalities that cater to non-technical roles, such as customer support representatives who may need to access package details to assist users with their data plans. The documentation provides clear instructions on how to make the API call and interpret the response, ensuring a straightforward integration process for both technical and non-technical users.
    • [Delete package](https://system.docs.ukama.com/data-plan-system/packages/delete-package.md): The `Delete package` API endpoint allows you to delete a package in Ukama Systems. This endpoint is used to remove a specific package identified by its UUID. By making a request to this endpoint with the appropriate UUID, you can delete the package from the system. Deleting a package can have various use-cases, such as removing outdated or unused packages from the system. This API allows you to easily manage and maintain your packages in Ukama Systems, ensuring that only relevant and up-to-date packages are available. It's important to note that once a package is deleted, it cannot be recovered. Therefore, make sure to double-check the UUID of the package you wish to delete before making the request. Additionally, this API requires proper authentication and authorization to ensure the security of your data. Integrating with this API is straightforward. Simply make a DELETE request to the `/dataplan/v1/packages/{uuid}` endpoint, replacing `{uuid}` with the UUID of the package you want to delete. The request should include the necessary authentication credentials. Upon successful deletion, the API will return an appropriate response indicating the successful removal of the package. Please refer to the relevant sections of the documentation for more details on authentication, error handling, and response examples.
    • [Update package](https://system.docs.ukama.com/data-plan-system/packages/update-package.md): This API endpoint allows you to update the details of a package in the Ukama Systems platform. By making a PATCH request to /dataplan/v1/packages/{uuid}, you can modify the existing attributes of a specific package identified by its unique UUID. With this API, you can conveniently update various package details, such as the package name, description, pricing, and any other relevant information. This flexibility empowers you to easily adapt your packages to meet the evolving needs of your users. By utilizing this API endpoint, you can effortlessly integrate your systems with the Ukama Systems platform and ensure that your package information remains up to date. Whether you want to make minor adjustments or completely overhaul a package, this API provides a straightforward way to accomplish these updates. It's worth noting that when making a PATCH request, you only need to include the attributes that you want to update. Any attributes not included in the request will remain unchanged. This allows you to modify specific aspects of a package without affecting other details. Remember to provide the UUID of the package you want to update in the endpoint URL (/dataplan/v1/packages/{uuid}). This ensures that the API endpoint knows which package you are referring to and applies the modifications accordingly. Please refer to the documentation for specific examples and parameters related to this API endpoint to ensure seamless integration and successful updates to your packages.
    • [Get package details](https://system.docs.ukama.com/data-plan-system/packages/get-package-details.md): This API endpoint allows you to retrieve the details of a specific package by providing its unique identifier (UUID). The response will provide comprehensive details about the package, including its name, price, duration, and any additional features or restrictions that may apply. This functionality can be particularly useful in scenarios where you need to display detailed information about a specific package to users, such as on a pricing page or during the checkout process. By making use of this API, you can seamlessly integrate the package details into your application, ensuring a smooth and intuitive user experience. It is important to note that the provided UUID must correspond to an existing package in the system. If an invalid or non-existent UUID is provided, the API will return an appropriate error message. Additionally, keep in mind that this API endpoint only retrieves package details and does not support any modifications or updates to the package. If you need to make changes to a package, you will need to utilize other API endpoints specifically designed for those purposes. By leveraging this API endpoint effectively, you can effortlessly access and display package details within your application, enhancing the overall user experience and simplifying the integration process.
    • [Get packages of org](https://system.docs.ukama.com/data-plan-system/packages/get-packages-of-org.md): This API endpoint allows you to retrieve the packages associated with a specific organization. By providing the organization ID as a parameter in the API call, you can access all the relevant package information. This includes details such as package name, pricing, data limits, and any other pertinent information about the packages offered by the organization. This API is especially useful for applications that need to display available packages to users or automate the package selection process. It simplifies the integration process by providing a straightforward way to retrieve package information for a specific organization.
  • [Rates](https://system.docs.ukama.com/data-plan-system/rates.md): The Rates API section provides functionality for retrieving rates information in the Ukama Systems project. This API endpoint allows you to retrieve rates data related to various aspects of the system. It can be used to access information such as exchange rates, interest rates, or pricing rates for different services or products within the system. The Rates API is a valuable resource for developers and non-technical roles alike, as it provides essential data for calculating costs, making financial decisions, or generating reports. Its straightforward integration and comprehensive documentation ensure that users can easily access and utilize rates information for their specific needs.
    • [Set default markup percentage](https://system.docs.ukama.com/data-plan-system/rates/set-default-markup-percentage.md): This API section allows you to set the default markup percentage for the Ukama Systems data plan. By specifying the desired markup percentage in the API request, you can easily configure the default markup for your data plan. This functionality is especially useful for businesses that want to apply a consistent markup percentage across all their data plan pricing. With this API, you can streamline the process of setting and maintaining the default markup, ensuring accurate pricing for your customers.
    • [Set markup percentage for user](https://system.docs.ukama.com/data-plan-system/rates/set-markup-percentage-for-user.md): This section of the API allows you to set the markup percentage for a specific user in the Ukama Systems project. By setting the markup percentage, you can customize the pricing for this user based on your business needs. This API endpoint is designed to make it straightforward for you to integrate the markup functionality into your system. By making a POST request to this endpoint, you can easily update the markup percentage for a specific user. When using this API, keep in mind that the markup percentage should be specified as a decimal value. For example, a markup percentage of 10% should be provided as 0.1. By utilizing this API endpoint, you can easily customize the pricing for individual users in the Ukama Systems project, ensuring that your markup strategy aligns with your business goals.
    • [Get default markup percentage](https://system.docs.ukama.com/data-plan-system/rates/get-default-markup-percentage.md): The "Get default markup percentage" API endpoint allows you to retrieve the default markup percentage for Ukama Systems. This functionality is useful for various use-cases, such as determining the default markup percentage to apply to products or services offered by Ukama Systems. By using this API, you can easily integrate the default markup percentage into your own systems, making it straightforward to calculate and apply the correct pricing for your offerings. Additionally, there are no special features or considerations associated with this API endpoint.
    • [Get default markup percentage history](https://system.docs.ukama.com/data-plan-system/rates/get-default-markup-percentage-history.md): This API endpoint allows you to retrieve the default markup percentage history for the Ukama Systems project. By making a request to this endpoint, you will receive information about the markup percentage that has been set as the default over time. This can be useful for tracking changes and understanding the pricing structure of the project. The returned data includes the timestamp for when each change to the default markup percentage was made. The history can be accessed by making a GET request to /dataplan/v1/markup/default/history.
    • [Get markup percentage for user](https://system.docs.ukama.com/data-plan-system/rates/get-markup-percentage-for-user.md): This API endpoint allows you to retrieve the markup percentage for a specific user in the Ukama Systems project. The markup percentage represents the additional amount added to the base cost for a user's services or products. By making a request to this endpoint, you will receive the markup percentage value associated with the provided user ID. This information can be useful for various purposes, such as calculating the final price for a user's offerings or analyzing pricing strategies. To use this endpoint, you need to specify the user ID as a path parameter in the API URL. The user ID uniquely identifies the user for whom you want to retrieve the markup percentage. Please note that the markup percentage is returned as a numeric value, representing the additional percentage to be applied to the base cost. Integrating this API endpoint into your application can help streamline the process of retrieving and applying markup percentages for users in the Ukama Systems project.
    • [Delete markup percentage for user](https://system.docs.ukama.com/data-plan-system/rates/delete-markup-percentage-for-user.md): This API endpoint allows you to delete the markup percentage for a specific user in the Ukama Systems platform. The markup percentage is used to adjust the pricing for services provided to the user. By using this API, you can remove the markup percentage for a user, which will result in the service prices being displayed without any additional markup. This can be useful in scenarios where you want to provide special pricing or discounts to a specific user, or if you want to temporarily disable the markup for a user. To delete the markup percentage for a user, you need to specify the user ID in the API endpoint. Once the API call is made, the markup percentage for the user will be removed. It's important to note that removing the markup percentage will affect the pricing of all services provided to the user. Therefore, make sure to consider the impact on the user's pricing and communicate any changes to them if necessary. Please note that this API endpoint does not support any additional parameters or options. The user ID is the only required input for deleting the markup percentage.
    • [Get markup percentage history](https://system.docs.ukama.com/data-plan-system/rates/get-markup-percentage-history.md): This API endpoint allows you to retrieve the markup percentage history for a specific user within Ukama Systems. By making a GET request to this endpoint with the user's ID, you can obtain the historical data for the markup percentage applied to the user's transactions. This functionality is particularly useful for analyzing and tracking changes in the markup percentage over time. It provides valuable insights into how the pricing strategy has evolved and enables you to make informed decisions based on historical data. Keep in mind that this endpoint requires the user's ID as a parameter in the URL. Make sure to provide the correct user ID to retrieve the desired markup percentage history. Please note that this API endpoint does not include any summaries of response examples or parameters. These details can be found in other sections of the documentation for the sake of clarity and organization.
    • [Get rate for user](https://system.docs.ukama.com/data-plan-system/rates/get-rate-for-user.md): This API endpoint allows you to retrieve the rate for a specific user in the Ukama Systems platform. By providing the user ID as a parameter in the request, you can obtain the rate associated with that particular user. This functionality is helpful for various use-cases, such as determining the pricing plan for a user, calculating costs, or displaying rate information in the user interface. When using this API, it is important to ensure that the user ID provided is valid and corresponds to an existing user in the system. If the user ID is not valid, the API will return an error indicating that the user was not found. Note that the rate returned by this API is specific to the user and may vary based on factors such as subscription plan, usage, or any special offers. It is recommended to fetch the rate for a user periodically or whenever the rate information needs to be updated. To integrate this API into your application, you can make a GET request to the specified endpoint, including the user ID as a path parameter. The response will contain the rate information for the user in a structured format that you can process and display as needed. By leveraging this API endpoint, you can seamlessly incorporate the rate functionality into your application, providing accurate and up-to-date rate information for the users of Ukama Systems.
• [Subscriber System](https://system.docs.ukama.com/subscriber-system.md): The Subscriber System API section is a crucial part of the Ukama Systems platform, offering developers access to a range of services. These services include the Registry, Sim Pool, Sim Manager, and Test Agent. By utilizing this API, developers can interact with and manage subscribers, SIM cards, and testing capabilities effectively. With the Subscriber System API, developers can perform various operations on subscriber information. They can create new subscribers, retrieve existing subscriber details, update subscriber information, and even delete subscribers if needed. This functionality provides developers with complete control over managing subscriber data within the Ukama Systems platform. Additionally, the API also allows developers to allocate SIM cards to subscribers. They can request SIM cards from the Sim Pool, which is responsible for managing and providing SIM cards. This feature enables developers to seamlessly allocate SIM cards to subscribers, ensuring a smooth user experience. Furthermore, the Subscriber System API section includes the Test Agent service, which allows developers to monitor testing activities. They can track and manage the testing capabilities within the Ukama Systems platform, ensuring efficient testing processes and accurate results. Overall, the Subscriber System API section aims to simplify the integration process for developers and provide comprehensive access to the services offered by the Ukama Systems platform. It empowers developers to manage subscribers, allocate SIM cards, and monitor testing activities effectively, ultimately enhancing the functionality and usability of the Ukama Systems platform.
  • [Subscriber](https://system.docs.ukama.com/subscriber-system/subscriber.md): The Subscriber API section enables you to retrieve information about subscribers in the Ukama Systems project. This API endpoint provides access to various details related to subscribers, offering a comprehensive view of their profiles. With this functionality, you can easily retrieve subscriber information for a wide range of use-cases, such as displaying subscriber data in a user interface, generating reports, or performing data analysis. Additionally, the Subscriber API endpoint offers special features that allow you to filter and sort the returned results based on specific criteria, enabling you to tailor the data retrieval to your unique requirements. By leveraging the Subscriber API, you can seamlessly integrate subscriber information into your applications, providing a straightforward way to access and utilize this vital data.
    • [Add a new subscriber](https://system.docs.ukama.com/subscriber-system/subscriber/add-a-new-subscriber.md): This API endpoint allows you to add a new subscriber to the Ukama Systems platform. With this functionality, you can easily integrate your systems with Ukama Systems and seamlessly add new subscribers to your account. This API endpoint is designed to make the process straightforward and hassle-free, ensuring a smooth integration experience for both developers and non-technical roles. Additionally, please refer to the other sections of the documentation for specific method names, response examples, and parameters related to this API endpoint.
    • [Get subscriber by id](https://system.docs.ukama.com/subscriber-system/subscriber/get-subscriber-by-id.md): This API endpoint allows you to retrieve a specific subscriber by their unique subscriber ID. By making a request to this endpoint with the correct subscriber ID, you will receive detailed information about the subscriber, including their name, contact information, and any other relevant data associated with their profile. This functionality is particularly useful in scenarios where you need to retrieve specific subscriber information for various purposes, such as updating their details, managing subscriptions, or generating reports. It's important to note that the subscriber ID parameter must be provided in the request URL to ensure the API can identify and retrieve the correct subscriber. Additionally, please ensure that you have the necessary permissions and access rights to retrieve subscriber information before making a request to this endpoint. Feel free to explore the various response examples and parameters in the corresponding sections of the documentation to better understand how to construct requests and handle different scenarios when using this API endpoint.
    • [Delete a subscriber](https://system.docs.ukama.com/subscriber-system/subscriber/delete-a-subscriber.md): This API endpoint allows you to delete a subscriber from the Ukama Systems platform. By providing the unique identifier of the subscriber, you can efficiently remove their information from the system. Deleting a subscriber can be useful in various scenarios, such as when a user wishes to unsubscribe from notifications, cancel their subscription, or no longer wishes to be a part of the Ukama Systems platform. It is important to note that once a subscriber is deleted, their information will be permanently removed from the system and cannot be recovered. Therefore, exercise caution when using this endpoint to ensure the accuracy of the deletion. To delete a subscriber, you need to include the subscriber's unique identifier as a parameter in the API request. This identifier uniquely identifies the subscriber within the Ukama Systems platform and can be obtained through other API endpoints or the backend system. Upon successful deletion, the API will not return any data. Instead, it will provide a response code indicating the successful deletion of the subscriber. Please make sure to handle any error responses appropriately and provide necessary error handling mechanisms in your integration to ensure a smooth deletion process for subscribers.
    • [Update a subscriber](https://system.docs.ukama.com/subscriber-system/subscriber/update-a-subscriber.md): Update a subscriber: Use this API endpoint to update the details of a specific subscriber in the Ukama Systems database. This functionality allows you to modify various attributes of the subscriber, such as their name, contact information, or subscription plan. By making a PATCH request to this endpoint, you can conveniently update the desired fields without the need to send the entire subscriber object. This API is particularly useful when you want to keep subscriber records up-to-date or when subscribers need to make changes to their information. For example, you can use this endpoint to update a subscriber's mailing address after they have moved or to change their email address if they have switched providers. When making a request to update a subscriber, ensure that you include the subscriber ID in the API endpoint URL. This allows the system to identify the correct subscriber record to update. Additionally, provide the necessary parameters in the request body to specify the changes you want to apply. Keep in mind that this API is secure and requires appropriate authentication credentials to access. Make sure to include the necessary authentication headers in your request for successful integration. Note: It is important to handle error responses gracefully and provide appropriate feedback to users in case of any issues during the update process.
  • [Sim](https://system.docs.ukama.com/subscriber-system/sim.md): The GET Sim API section allows you to retrieve information about the UKAMA systems. This API endpoint retrieves the information related to the SIM cards used by the UKAMA systems. With this API, you can retrieve details such as the SIM card number, activation status, and network provider. This API is particularly useful for developers who need to gather information about the SIM cards used in the UKAMA systems. By retrieving this information, developers can easily manage and monitor the SIM cards and ensure their proper functioning. Some possible use-cases for this API include: - Verifying the activation status of a SIM card: By making a GET request to this API, you can check if a particular SIM card is activated or not. This can be useful for troubleshooting connectivity issues or verifying the status of a SIM card before starting a new project. - Retrieving SIM card details for reporting purposes: This API allows you to fetch the SIM card details, such as the SIM card number and network provider. Developers can use this information to generate reports or gather statistics on the usage of SIM cards within the UKAMA systems. It is important to note that this API requires proper authentication credentials to ensure the security of the data. Please refer to the Authentication section for more information on how to authenticate your requests. Additionally, this API supports pagination, allowing you to retrieve the SIM card information in manageable chunks. The response will include pagination information, such as the total number of SIM cards and the available pages. Overall, the GET Sim API section provides a straightforward way to retrieve information about the SIM cards used in the UKAMA systems, enabling developers to manage and monitor the SIM cards effectively.
    • [Allocate a new sim to subscriber](https://system.docs.ukama.com/subscriber-system/sim/allocate-a-new-sim-to-subscriber.md): This section of the API allows you to allocate a new SIM card to a subscriber in the Ukama Systems project. By making a POST request to the `/subscriber/v1/sim/` endpoint, you can easily assign a SIM card to a specific subscriber. This functionality streamlines the process of managing SIM cards and ensures a smooth integration with the Ukama Systems platform.
    • [Get sim by id](https://system.docs.ukama.com/subscriber-system/sim/get-sim-by-id.md): This API endpoint allows you to retrieve information about a specific SIM card by its ID. The response will provide details about the SIM's status, activation date, and other relevant information. This functionality is particularly useful for managing SIM cards within the Ukama Systems platform. For example, you can use this endpoint to retrieve real-time data about a SIM's current status, whether it is active or inactive, and the date it was activated. Please note that the SIM ID is a unique identifier assigned to each SIM card within the system. Make sure to provide the correct SIM ID in the request to get accurate information about the desired SIM card.
    • [Delete the sim for the subscriber](https://system.docs.ukama.com/subscriber-system/sim/delete-the-sim-for-the-subscriber.md): This section of the API documentation provides instructions on how to delete a SIM (Subscriber Identity Module) for a subscriber in the Ukama Systems project. By using this API endpoint, you can remove a specific SIM from the system. Deleting a SIM is a permanent action and cannot be undone, so it is important to ensure that you have the correct SIM ID before making the delete request. This API is designed to support the integration of the Ukama Systems platform with external applications or systems. The delete /subscriber/v1/sim/{sim_id} API endpoint allows you to delete a SIM by specifying the SIM ID in the URL. The SIM ID is a unique identifier assigned to each SIM in the system. Once the request is processed, the SIM will be permanently removed from the subscriber's account. This API endpoint can be useful in various scenarios, such as when a subscriber cancels their service or requests to deactivate a specific SIM. By integrating this functionality into your application, you can easily manage and update SIM information within the Ukama Systems platform. It is important to note that once a SIM is deleted, all associated data and settings will be lost. This includes any usage history, billing information, and configuration settings. Therefore, it is recommended to back up any important data before performing a delete operation. Please refer to the other sections of the API documentation for information on how to retrieve SIM details, update SIM information, and perform other related operations.
    • [Activate/deactivate sim of subscriber](https://system.docs.ukama.com/subscriber-system/sim/activate-deactivate-sim-of-subscriber.md): This section of the Ukama Systems API allows you to activate or deactivate a SIM card for a subscriber. By making a PATCH request to the endpoint "/subscriber/v1/sim/{sim_id}", you can update the status of a specific SIM card. This functionality is useful in scenarios where you need to remotely control the activation or deactivation of a subscriber's SIM card. For example, if a subscriber has lost their device or if there is a need to temporarily suspend their service, you can use this API to handle the SIM card status accordingly. Please note that the {sim_id} parameter should be replaced with the actual ID of the SIM card you want to activate or deactivate. The API will return a response indicating the success or failure of the operation, allowing you to handle any errors or exceptions gracefully. Keep in mind that proper authorization and authentication should be implemented to ensure that only authorized users can access and modify SIM card status. Additionally, it's important to handle any potential errors or exceptions that may occur during the API call, providing clear and actionable error messages to help developers troubleshoot and resolve issues quickly. With this straightforward API integration, you can easily manage the activation and deactivation of SIM cards for subscribers in your Ukama Systems application.
    • [Delete a package from subscriber's sim](https://system.docs.ukama.com/subscriber-system/sim/delete-a-package-from-subscriber-s-sim.md): This API endpoint allows you to delete a package from a subscriber's SIM. By specifying the SIM ID and the package ID in the URL parameters, you can easily remove a package from the subscriber's account. This functionality is useful if you need to update or modify the packages associated with a subscriber's SIM. Simply make a request to this endpoint, and the specified package will be removed from the subscriber's account. This API provides a straightforward way to manage packages for subscribers in the Ukama Systems project.
    • [Set active package for sim](https://system.docs.ukama.com/subscriber-system/sim/set-active-package-for-sim.md): This API endpoint allows you to set the active package for a specific SIM card. By providing the SIM ID and the package ID, you can update the active package for that SIM. This functionality is useful when you want to change the package associated with a SIM card, such as upgrading or downgrading the package level. To use this API, make a PATCH request to the specified endpoint, providing the SIM ID and the package ID in the URL. The request body should include any additional parameters or data required for the package activation. Please note that this API endpoint only supports updating the active package for a SIM card. If you need to retrieve information about SIM packages or perform other operations related to SIM cards, please refer to the appropriate API sections. Remember to handle any potential errors or exceptions that may occur during the package activation process. Detailed information about error codes and error handling can be found in the error handling section of the documentation. By using this API endpoint, you can easily integrate the functionality of setting the active package for a SIM card into your application or system. This allows you to manage and control the packages associated with SIM cards in a straightforward manner, ensuring seamless integration and efficient package management.
    • [Add a new package to the subscriber's sim](https://system.docs.ukama.com/subscriber-system/sim/add-a-new-package-to-the-subscriber-s-sim.md): This API endpoint allows you to add a new package to the subscriber's sim in the Ukama Systems project. By making a request to this endpoint, you can seamlessly integrate new packages into the system. This functionality is essential for managing subscriber packages and ensuring a smooth experience for users. The API's design and structure follow industry best practices to make integration straightforward for both developers and non-technical roles.
    • [Get packages for sim](https://system.docs.ukama.com/subscriber-system/sim/get-packages-for-sim.md): This API endpoint allows you to retrieve the packages available for a specific SIM card. By providing the SIM ID as a parameter, you can access information about the packages associated with that SIM. This includes details such as package names, pricing, and data limits. This can be useful for managing subscription plans or presenting package options to users. Additionally, this endpoint supports pagination, allowing you to retrieve packages in chunks if needed. Please note that this endpoint requires authentication to ensure security and restrict unauthorized access.
    • [Get a sims of the subscriber by subscriber id](https://system.docs.ukama.com/subscriber-system/sim/get-a-sims-of-the-subscriber-by-subscriber-id.md): This API endpoint allows you to retrieve the SIM cards associated with a specific subscriber ID. By providing the unique identifier for the subscriber, you can access the relevant SIM card information and associated data. This functionality is useful for managing and tracking SIM cards within the Ukama Systems platform. The response will provide detailed information about each SIM card, including its status, activation date, and any additional attributes or configurations. This API endpoint simplifies the task of retrieving SIM card details, making integration with the Ukama Systems platform seamless and efficient.
  • [Sim Pool](https://system.docs.ukama.com/subscriber-system/sim-pool.md): API endpoint: Sim Pool The Sim Pool API endpoint allows you to retrieve information about the available SIM cards in the system. This API is designed to provide you with a comprehensive overview of the SIM card inventory, including details such as the SIM card number, status, and associated user information. By making a GET request to this endpoint, you can access a list of all the SIM cards currently stored in the system. This information can be useful for various use-cases, such as managing SIM card inventory, tracking SIM card activation, and identifying available SIM cards for new activations. The response from this endpoint will provide you with a JSON array containing detailed information about each SIM card, including its unique identifier, status, and any associated user information. This can help you easily retrieve the necessary details for each SIM card, allowing you to integrate this information into your own systems or applications. It's important to note that this endpoint does not support any modification or deletion of SIM cards. Its primary purpose is to provide read-only access to the SIM card information in the system. If you need to update or delete SIM card data, you will need to use the appropriate API endpoints specifically designed for those actions. Overall, the Sim Pool API endpoint simplifies the process of retrieving and managing SIM card information, making it easier for you to integrate and utilize this data in your own applications.
    • [Add new sim to sim pool](https://system.docs.ukama.com/subscriber-system/sim-pool/add-new-sim-to-sim-pool.md): This section of the API documentation outlines the functionality for adding a new SIM card to the SIM pool in the Ukama Systems project. The API endpoint for this action is "put /subscriber/v1/simpool." By utilizing this endpoint, you can easily add a new SIM card to the existing SIM pool. This functionality is useful when you want to expand your SIM pool and enable more devices to connect to the system. Please refer to the other sections of the documentation for detailed information on the method names, response examples, and parameters associated with this API endpoint.
    • [Get sim by iccid](https://system.docs.ukama.com/subscriber-system/sim-pool/get-sim-by-iccid.md): This API endpoint allows you to retrieve SIM card information by providing the ICCID (Integrated Circuit Card Identifier). The ICCID uniquely identifies each SIM card and is printed on the card itself. Using this endpoint, you can fetch the details of a specific SIM card by passing its ICCID as a parameter. The returned information will include relevant data such as the SIM card's status, subscription details, and associated device information. This endpoint is particularly useful for applications that need to access information related to a specific SIM card within the Ukama Systems platform. Whether you are building a monitoring system, a customer support tool, or any other application that requires SIM card data, this API endpoint simplifies the process of retrieving the necessary information. Please note that the ICCID must be provided as a parameter in the API request to successfully retrieve the corresponding SIM card data. Make sure to include the ICCID in the request URL or body, depending on your preferred HTTP method. If you encounter any issues or have further questions regarding the usage of this API endpoint, please refer to the relevant documentation or reach out to our support team for assistance.
    • [Remove sim from sim pool](https://system.docs.ukama.com/subscriber-system/sim-pool/remove-sim-from-sim-pool.md): This API endpoint allows you to remove a SIM card from a SIM pool in the Ukama Systems project. By making a request to this endpoint with the SIM ID specified, you can effectively remove the SIM card from the SIM pool. This functionality is useful for managing SIM cards within a pool and ensuring that only active SIM cards are included. Please note that this API endpoint does not require any additional parameters or special considerations.
    • [Get sims by type](https://system.docs.ukama.com/subscriber-system/sim-pool/get-sims-by-type.md): This API endpoint allows you to retrieve SIM cards of a specific type in the Ukama Systems platform. By specifying the SIM type in the request, you will receive a list of SIM cards that match the specified type. This functionality is particularly useful when you need to filter and work with SIM cards based on their type. For example, if you are developing a mobile application that requires different configurations or capabilities depending on the type of SIM card, you can use this API endpoint to retrieve only the SIM cards that meet your requirements. In addition to developers, non-technical roles can also benefit from this API endpoint. For instance, if you are a product manager or a customer support representative, you can use this endpoint to quickly gather information about the available SIM cards and their types without diving into complex technical details. Keep in mind that when using this API endpoint, you should provide the specific SIM type in the request to ensure accurate results. It is important to note that the response will only include the SIM cards of the specified type and may vary depending on the availability and configuration settings within the Ukama Systems platform. By integrating this API endpoint into your application or system, you can streamline the process of retrieving SIM cards by type, making it easier to manage and utilize SIM cards within your project.
    • [Get sim pool stats](https://system.docs.ukama.com/subscriber-system/sim-pool/get-sim-pool-stats.md): This API endpoint allows you to retrieve the statistics for a specific type of SIM pool in the Ukama Systems subscriber API. The statistics provide valuable insights into the performance and usage of the SIM cards within the pool. By making a request to this endpoint, you will receive comprehensive information about the sim pool, including the number of active SIM cards, the total number of SIM cards, and the current usage statistics. This data can be used to monitor the health of your SIM pool and make informed decisions regarding resource allocation and management. The get /subscriber/v1/simpool/stats/{sim_type} API endpoint is particularly useful for tracking the usage patterns of different types of SIM cards within the pool. This can be beneficial for identifying trends, analyzing customer behavior, and optimizing your SIM card inventory. It is important to note that this endpoint requires the specification of a sim_type parameter, which determines the type of SIM pool for which you want to retrieve the statistics. This allows you to obtain specific information for different SIM pool configurations, such as data-only or voice-enabled SIM cards. The retrieved statistics can be utilized by both technical and non-technical roles within your organization. Developers can leverage the data to enhance the functionality and performance of your applications, while non-technical personnel can utilize the insights to gain a better understanding of the SIM pool's usage and make informed business decisions. Overall, the get /subscriber/v1/simpool/stats/{sim_type} API endpoint provides a straightforward and efficient way to access and analyze the statistics for a specific type of SIM pool in the Ukama Systems subscriber API.
    • [Upload csv file to add new sim to sim pool](https://system.docs.ukama.com/subscriber-system/sim-pool/upload-csv-file-to-add-new-sim-to-sim-pool.md): This API endpoint allows you to upload a CSV file to add new SIM cards to the SIM pool. The SIM pool is a repository of SIM cards that can be allocated to subscribers for various use cases. By uploading a CSV file, you can quickly and easily add multiple SIM cards to the SIM pool in bulk. This functionality is especially useful for organizations that need to manage a large number of SIM cards and efficiently provision them for subscribers. The CSV file should contain the necessary information for each SIM card, such as the SIM card number, subscriber details, and any other relevant attributes. Once the upload is successful, the SIM cards will be added to the SIM pool and ready for allocation. This API endpoint simplifies the process of integrating your application with the Ukama Systems platform and managing SIM cards for your subscribers.
• [Notification System](https://system.docs.ukama.com/notification-system.md): The Ukama Notification system is a comprehensive solution that provides developers with the ability to send notifications through various channels such as email. It consists of three main components: mailer, notify, and API gateway. The mailer component is responsible for sending email notifications. It utilizes a messaging system and follows the protocol defined in the "validator.proto" file. Developers can use the mailer to send notifications to specific recipients by providing relevant information such as the notification ID, description, severity, type, status, and additional details. The mailer component is implemented as a service and can be easily integrated into existing applications. The notify component is the core of the Ukama Notification system. It provides a set of APIs that developers can use to manage notifications. With the notify component, developers can add, retrieve, list, delete, and purge notifications. The notifications are represented by the Notification message defined in the "notify.proto" file. This message contains information such as the notification ID, node ID, node type, description, severity, type, service name, status, epoch time, and details. The notify component also provides an EventNotificationService that allows developers to receive event notifications. The API gateway component acts as a proxy and control plane for the mailer and notify components. It provides a unified interface for developers to interact with the notification system. Developers can send requests to the API gateway to perform operations on notifications, such as adding a new notification or retrieving existing ones. The API gateway is implemented using the Gin framework and follows the RESTful architecture style. It also supports cross-origin resource sharing (CORS) to enable communication with clients from different domains. In summary, the Ukama Notification system offers developers a powerful and flexible solution for sending notifications. The mailer component handles the delivery of notifications via email, while the notify component provides APIs for managing notifications. The API gateway component acts as a central point of entry for developers to interact with the notification system. By leveraging these components, developers can easily integrate notification functionality into their applications and improve their overall user experience.
  • [Mailer](https://system.docs.ukama.com/notification-system/mailer.md): The GET Mailer API section provides functionality for retrieving information related to the mailer service in Ukama Systems. This API endpoint allows you to fetch various details and data associated with the mailer service. It is designed to facilitate easy integration of the mailer functionality into your applications. By using the GET Mailer API, you can retrieve information such as the status of the mailer service, the number of emails sent, the success rate of email deliveries, and any error messages or logs associated with the mailer service. This information can be helpful for monitoring and troubleshooting purposes. Additionally, the GET Mailer API allows you to fetch details about specific email campaigns, including the number of recipients, the delivery status of each email, and any error messages associated with failed deliveries. This feature enables you to track the performance and effectiveness of your email campaigns. The GET Mailer API is user-friendly and can be easily integrated into your applications, whether you are a developer or a non-technical user. It provides a straightforward method for retrieving essential information about the mailer service, allowing you to seamlessly incorporate this functionality into your workflows. Please refer to the remaining sections of the documentation for method names, parameter details, response examples, and other information necessary for implementing and utilizing the GET Mailer API effectively.
    • [Get email by id](https://system.docs.ukama.com/notification-system/mailer/get-email-by-id.md): This API endpoint allows you to retrieve an email by its unique identifier. By specifying the mailer_id in the request, you will receive the details of the corresponding email. This functionality is useful for retrieving specific emails within the Ukama Systems platform. Non-technical roles can benefit from this API by using it to access and review specific emails sent through the system. For example, customer support representatives can easily retrieve and analyze the content of an email to better understand customer inquiries or resolve any issues. Developers can utilize this endpoint to integrate email retrieval functionality directly into their applications or systems. By leveraging the API, developers can programmatically access and display email content to users, automate email analysis processes, or perform further actions based on the retrieved email data. It is important to note that the mailer_id parameter is required in the request to retrieve the email. This parameter represents the unique identifier assigned to each email within the system. Make sure to include this parameter in your API calls to ensure successful retrieval of the desired email. By utilizing this API endpoint, you can easily retrieve emails by their unique identifiers, enabling efficient integration and access to email content within the Ukama Systems platform.
    • [Send email notification](https://system.docs.ukama.com/notification-system/mailer/send-email-notification.md): This API endpoint allows you to send email notifications through the Ukama Systems platform. With this functionality, you can easily integrate email notifications into your application. By making a POST request to this endpoint, you can provide the necessary information for sending the email, such as the recipient's email address, the subject, and the content of the email. This API section provides a straightforward way to incorporate email notifications into your application, enabling you to keep your users informed and engaged.
  • [Notification](https://system.docs.ukama.com/notification-system/notification.md): The GET Notification API endpoint allows you to retrieve notifications from the Ukama Systems project. This API section provides functionality to retrieve various types of notifications, including updates, alerts, and messages. The GET Notification API can be used in various use-cases, such as displaying notifications in a user interface, sending notifications to external systems, or integrating notifications into your own application. When using this API, keep in mind that notifications can be filtered based on various parameters, such as date range, type, or recipient. This allows you to retrieve specific subsets of notifications based on your requirements. Additionally, the GET Notification API supports pagination, allowing you to retrieve notifications in smaller chunks if you have a large number of notifications. This can improve performance and reduce the amount of data transferred. Overall, the GET Notification API provides a straightforward way to retrieve notifications from the Ukama Systems project, making API integration seamless and easy.
    • [Get notifications](https://system.docs.ukama.com/notification-system/notification/get-notifications.md): This API endpoint allows you to retrieve a list of notifications from the Ukama Systems platform. Notifications are updates or alerts that provide information about specific events or actions within the system. By accessing this endpoint, you can access a comprehensive overview of all notifications relevant to your account. This functionality can be particularly useful for developers looking to integrate notifications into their applications or for non-technical roles who need to stay updated on important events within the system. By retrieving the list of notifications, you can ensure that you are aware of any critical information or actions that need your attention. It is important to note that the retrieved list of notifications may vary depending on your specific account settings and permissions. Some notifications may only be visible to certain roles or individuals within the system. Therefore, it is crucial to review your account settings and permissions to ensure you have the necessary access to retrieve the desired notifications. Additionally, the response from this API endpoint may contain additional details or metadata related to each notification, such as timestamps, event types, or associated resources. This information can provide valuable context and allow you to further process or filter the notifications based on your specific requirements. By leveraging the functionality provided by this API endpoint, you can seamlessly integrate notifications into your applications or workflows, ensuring that you and your team are always up to date with the latest events and information within the Ukama Systems platform.
    • [Insert notification](https://system.docs.ukama.com/notification-system/notification/insert-notification.md): This API endpoint allows you to insert a new notification into the system. By calling this endpoint, you can easily add relevant information for the notification, such as the type, recipient, and message content. This functionality is especially useful for sending important updates or alerts to users within the system. With the ability to customize the notification content, you can tailor the messages according to specific use-cases or events. Keep in mind that this endpoint follows a POST method, meaning that you will need to provide the necessary parameters in the request body. Make sure to include all required fields to ensure successful integration and delivery of notifications.
    • [Delete notifications](https://system.docs.ukama.com/notification-system/notification/delete-notifications.md): This API section allows you to delete notifications that match specific criteria within the Ukama Systems project. By using this endpoint, you can easily remove notifications from the system.
    • [Get notification](https://system.docs.ukama.com/notification-system/notification/get-notification.md): API Endpoint: Get Notification This API endpoint allows you to retrieve a specific notification from the Ukama Systems platform. Notifications provide important information and updates related to various events and activities within the system. By using this API, you can fetch a specific notification by providing its unique notification ID. The response will provide detailed information about the notification, including the sender, recipient, timestamp, and the content of the notification itself. This API can be useful in various scenarios, such as: 1. Notification History: Retrieving past notifications for auditing or reference purposes. You can search for a specific notification based on its ID and access its details. 2. Notification Processing: Building automated processes that depend on specific notification types. By fetching the details of a particular notification, you can trigger further actions or perform custom logic based on the content or metadata associated with the notification. 3. User Interactions: Enhancing user experiences by displaying notifications in a customized manner. By using this API, developers can fetch and display notifications in their application's user interface, ensuring that users stay informed about important updates and events. It's important to note that the notification ID must be provided as a parameter in the API request. Ensure that you have the necessary permissions and authentication credentials to access the notifications. For a more detailed understanding of the API parameters, response structure, and examples of usage, please refer to the relevant sections in this documentation.
    • [Delete notification](https://system.docs.ukama.com/notification-system/notification/delete-notification.md): This API endpoint allows you to delete a specific notification. By providing the notification ID in the request, you can easily remove the notification from the system. This functionality is useful for managing notifications and keeping your system organized. Please note that once a notification is deleted, it cannot be retrieved, so ensure that you no longer need the notification before using this endpoint.
• [Metrics System](https://system.docs.ukama.com/metrics-system.md): The Metrics System API endpoint in the Ukama Systems project provides access to the exporter service. This service allows users to retrieve various metrics data from the system. The Metrics System API can be utilised to gather information on system performance, user activity, and other relevant metrics. This endpoint is designed to support integrations with other applications and services, making it easy to retrieve and analyze metrics data for both technical and non-technical users.
  • [Live metric handler-fm](https://system.docs.ukama.com/metrics-system/live-metric-handler-fm.md): The get /metrics/v1/live/metrics API endpoint allows you to retrieve a data stream of metrics from the Ukama Systems project. This API returns data in the Prometheus data format, which is a widely used format for storing and querying time series data. The metrics data stream can be used to monitor and analyze various aspects of the project's performance and health. It provides valuable insights into resource utilization, system behavior, and other important metrics. By integrating with this API, you can gather real-time metrics and leverage them to make informed decisions and optimize your application's performance.
  • [Get metrics](https://system.docs.ukama.com/metrics-system/get-metrics.md): The get /metrics/v1/metrics endpoint allows you to retrieve metrics data from the Ukama Systems project. This API section provides access to various metrics related to the project's performance and usage. By making a request to this endpoint, you can retrieve data such as the number of users, active sessions, average response time, and other important metrics. This information can be valuable for monitoring and analyzing the project's overall health and performance. The get /metrics/v1/metrics endpoint is designed to provide developers and non-technical roles with a straightforward way to access and leverage metrics data for informed decision-making and performance optimization.
  • [Metric handler-fm](https://system.docs.ukama.com/metrics-system/metric-handler-fm.md): API Endpoint: Metric handler-fm The Metric handler-fm API endpoint allows you to retrieve metrics for the specified metric. This API follows the GET method. The response of this API is in the Prometheus data format, which is a widely adopted format for time-series data. You can refer to the Prometheus documentation on querying for more details on working with this format. By making a request to this endpoint with the appropriate metric parameter, you will receive the desired metric data. This can be useful for analyzing and monitoring various aspects of your system. Please note that the metric parameter should be specified in the URL as part of the request. Make sure to replace `{metric}` with the actual metric name you are interested in. Integrating this API into your application allows you to seamlessly retrieve the metrics you need for your monitoring and analysis purposes. Whether you are a developer looking for performance insights or a non-technical user interested in system health, this API provides a straightforward way to obtain the desired metric data.
  • [Network metric handler-fm](https://system.docs.ukama.com/metrics-system/network-metric-handler-fm.md): This API endpoint, "get /metrics/v1/networks/{network}/metrics/{metric}", is a network metric handler for Ukama Systems. It allows you to retrieve metrics for a specific network. The response you receive will be in the Prometheus data format, which is a popular format for time series data. This format is well-documented and widely supported, making it easy for developers to work with the data. By using this API, you can access a wide range of network metrics, such as latency, packet loss, and throughput. These metrics can provide valuable insights into the performance and health of your network. Whether you are a developer looking to optimize network performance or a non-technical user interested in monitoring network health, this API can help you retrieve relevant and actionable metrics. To make integration straightforward, we have designed this API endpoint to be intuitive and easy to use. You simply need to specify the network and metric you are interested in retrieving data for. The API will then return the requested metrics in the Prometheus data format. It's worth noting that the Prometheus data format is flexible and allows for powerful querying capabilities. This means that you can perform complex queries to filter, aggregate, and analyze the network metrics according to your specific needs. The Prometheus documentation provides comprehensive guidance on how to leverage the full potential of this data format. Overall, this API endpoint provides a convenient and efficient way to obtain network metrics for analysis and optimization purposes. Whether you are a developer or a non-technical user, you can easily integrate this API into your workflow to gain valuable insights into your network's performance and health.
  • [Node metric handler-fm](https://system.docs.ukama.com/metrics-system/node-metric-handler-fm.md): This API endpoint allows you to retrieve metrics for a specific node. The response data is in Prometheus format, which is a popular format for querying and analyzing metrics. By using this endpoint, you can easily access important metrics data for your node, making it simple to monitor and analyze its performance.
  • [Org metric handler-fm](https://system.docs.ukama.com/metrics-system/org-metric-handler-fm.md): This API endpoint allows you to retrieve metrics for a specific organization. The response will be in Prometheus data format, which is commonly used for querying and analyzing time series data. The returned metrics can provide valuable insights into various aspects of the organization's performance and activity. By using this endpoint, you can access and utilize the metrics data to track the organization's progress, monitor key performance indicators, and make informed decisions.
  • [Metric range handler-fm](https://system.docs.ukama.com/metrics-system/metric-range-handler-fm.md): This API endpoint allows you to retrieve metrics for a specified time period. The response will be in Prometheus data format, following the standards outlined in the Prometheus documentation for range vectors. This endpoint is a part of the Metric range handler-fm in the Ukama Systems project. By using this endpoint, you can easily access and analyze metrics data within a specific timeframe. Whether you are a developer or non-technical user, integrating this API into your system will enable you to retrieve the desired metrics for further analysis and decision-making.
  • [Sim metric handler-fm](https://system.docs.ukama.com/metrics-system/sim-metric-handler-fm.md): This section of the Ukama Systems API allows you to retrieve metrics for a specific SIM card. The response for this request is in Prometheus data format, which follows the standard defined by Prometheus for querying and retrieving time series data. By making a request to this API endpoint, you will be able to fetch metrics related to a particular SIM card. The metrics include various data points that can be used to monitor and analyze the performance and usage of the SIM card. To retrieve the metrics, you need to provide the necessary parameters in the URL path. These parameters include the SIM ID, organization ID, network ID, subscriber ID, and the specific metric you are interested in. The response will provide the requested metrics in the Prometheus data format. This format is widely used and supported in the industry, making it easy to integrate the retrieved data into your existing monitoring and analysis systems. It's important to note that the metrics returned by this API endpoint are time series data, meaning they represent values over a specific period of time. This allows you to track the changes and trends in the SIM card's performance and usage over time. By leveraging the capabilities of this API endpoint, you can gain valuable insights into the behavior and performance of your SIM cards. This information can be used to optimize and improve your organization's overall network management and subscriber experience. Please refer to the appropriate sections of the documentation for additional details on the specific parameters, response examples, and any special considerations or requirements for using this API endpoint effectively.
  • [Subscriber metric handler-fm](https://system.docs.ukama.com/metrics-system/subscriber-metric-handler-fm.md): This API endpoint allows you to retrieve metrics for a specific subscriber within the Ukama Systems platform. The response will be in Prometheus data format, which follows the structure outlined in the Prometheus documentation for querying and working with time series data. By accessing this endpoint, you will be able to obtain important insights and measurements related to the subscriber's activity within their organization and network. The metrics provided can be used to analyze trends, monitor performance, and make informed decisions based on the data. Please refer to the Prometheus documentation for more details on how to work with the returned data format.
• [Messaging System](https://system.docs.ukama.com/messaging-system.md)
  • [Prometheus Target](https://system.docs.ukama.com/messaging-system/prometheus-target.md): The Prometheus Target API endpoint allows you to retrieve information about the targets monitored by Prometheus in your Ukama Systems project. This API provides a simple and straightforward way to access essential information about the targets, such as their current status, health, and performance metrics. By accessing this API, you can easily integrate the target information into your own applications or systems and take appropriate actions based on the retrieved data. Whether you are a developer or a non-technical user, this API section will provide you with all the necessary details and considerations to effectively utilize and leverage the Prometheus Target API endpoint for your integration needs.
    • [Get target to scrape](https://system.docs.ukama.com/messaging-system/prometheus-target/get-target-to-scrape.md): The "get /messaging/v1/prometheus" API endpoint in the Ukama Systems project allows you to retrieve the target that needs to be scraped. This API section provides functionality to access information related to Prometheus monitoring tool. It enables you to fetch the target URL which needs to be crawled for metrics collection. This endpoint is especially useful for integrating with monitoring systems and extracting data from the target specified. By utilizing this API, you can easily retrieve the necessary information for scraping purposes.
  • [Nns](https://system.docs.ukama.com/messaging-system/nns.md): This section of the Ukama Systems API documentation provides information on utilizing the GET method with the Nns endpoint. By making a GET request to this endpoint, you can retrieve specific data from the Ukama Systems platform. This functionality is particularly useful for retrieving information such as user details, account information, or any other relevant data stored within the Ukama Systems ecosystem. To use this API endpoint, you need to provide the necessary parameters in the request, such as authentication credentials or any specific identifiers required to retrieve the desired data. Please note that the response from this endpoint will depend on the parameters provided in the request, and it will typically be in a structured format such as JSON. By integrating with the Ukama Systems API and utilizing the GET method with the Nns endpoint, you can easily access the data you need to enhance your applications or systems.
    • [Get all ip's](https://system.docs.ukama.com/messaging-system/nns/get-all-ip-s.md): This API section allows you to retrieve a list of all IP addresses associated with the Ukama Systems messaging feature. By making a request to this endpoint, you will receive the complete list of IP addresses used for the messaging service. This information can be useful for various purposes, such as monitoring and managing network traffic, security measures, or any other application that requires knowledge of these IP addresses. Please note that no additional parameters are required for this API call.
    • [Node to org map](https://system.docs.ukama.com/messaging-system/nns/node-to-org-map.md): This API section allows you to retrieve the mapping between nodes and organizations in the Ukama Systems messaging system. By making a request to this endpoint, you can obtain the direct mapping information, which will help you understand the relationships between nodes and their respective organizations. This information is useful for various use-cases, such as analyzing communication patterns, generating reports, and managing permissions within the messaging system. Additionally, this API section includes some special features and considerations that you should be aware of to ensure a smooth integration.
    • [Get node ip](https://system.docs.ukama.com/messaging-system/nns/get-node-ip.md): This API endpoint allows you to retrieve the IP address of a specific node in the Ukama Systems messaging module. By making a GET request to this endpoint with the node ID as a path parameter, you can obtain the IP address for that particular node. This information can be useful for various purposes, such as establishing direct communication with the node or monitoring its network connectivity. Whether you are a developer looking to integrate this functionality into your application or a non-technical user seeking to understand the capabilities of Ukama Systems, this API endpoint provides a straightforward way to retrieve the IP address of a node in the messaging module.
    • [Add node ip](https://system.docs.ukama.com/messaging-system/nns/add-node-ip.md): This API endpoint allows you to add the IP address of a node to the Ukama Systems messaging system. By making a PUT request to this endpoint with the node ID as a parameter, you can associate the specified IP address with the node. This functionality is useful in scenarios where you need to update or change the IP address of a node within the messaging system.
    • [Remove node from dns](https://system.docs.ukama.com/messaging-system/nns/remove-node-from-dns.md): Remove node from dns. This API endpoint allows you to remove a node from the DNS (Domain Name System). By using this endpoint, you can delete a specific node identified by its node ID. This functionality is useful when you no longer need a particular node to be associated with a domain or when you want to clean up your DNS records. To use this endpoint, you need to provide the node ID of the node you want to remove. Once the node is removed, it will no longer be accessible through the DNS. It is important to note that removing a node from the DNS can have implications on the accessibility and functionality of your domain or application. Make sure you understand the impact before using this endpoint. Note that this endpoint does not support any specific method (e.g., GET, POST) as the functionality solely revolves around removing a node from the DNS.
• [Nucleus System](https://system.docs.ukama.com/nucleus-system.md): Nucleus system include Org and User services
  • [Orgs](https://system.docs.ukama.com/nucleus-system/orgs.md): Operations on Orgs
    • [Get orgs](https://system.docs.ukama.com/nucleus-system/orgs/get-orgs.md): Get all organization owned by a user
    • [Add org](https://system.docs.ukama.com/nucleus-system/orgs/add-org.md): Add a new organization
    • [Get org by name](https://system.docs.ukama.com/nucleus-system/orgs/get-org-by-name.md): Get organization by name
  • [Users](https://system.docs.ukama.com/nucleus-system/users.md): Operations on Users
    • [Add user](https://system.docs.ukama.com/nucleus-system/users/add-user.md): Add a new User to the registry
    • [Get user by authid](https://system.docs.ukama.com/nucleus-system/users/get-user-by-authid.md): Get a specific user by authId
    • [Get user by email](https://system.docs.ukama.com/nucleus-system/users/get-user-by-email.md): Get a specific user by email
    • [Get detailed user](https://system.docs.ukama.com/nucleus-system/users/get-detailed-user.md): Get a specific user details with all linked orgs
    • [Get user](https://system.docs.ukama.com/nucleus-system/users/get-user.md): Get a specific user