Ukama API

Ukama API Docs

## Sections
• [Introduction](https://api.docs.ukama.com/introduction.md): Ukama API Intro here Updated
• [Health check](https://api.docs.ukama.com/health-check.md)
• [Network](https://api.docs.ukama.com/network.md): The Network API section of the Ukama API provides functionality for managing and accessing networks within the system. Networks are a core component of the Ukama platform, allowing users to connect and interact with each other. With the Network API, you can perform various actions related to networks, such as creating a new network, retrieving information about a specific network, updating network details, and deleting a network. You can also retrieve a list of all networks in the system or filter networks based on specific criteria. The Network API supports use-cases such as creating social networks, professional networking platforms, or any application that requires a network-based structure. It provides the flexibility to build custom network features and integrate them seamlessly with your application. In addition to basic network management, the Network API offers advanced features and considerations. For example, you can retrieve network statistics, manage network members, invite users to join a network, or handle network invitations and requests. These features enable you to create dynamic and interactive network experiences for your users. The Network API documentation provides detailed information on API endpoints, request parameters, and expected response formats. It also includes code examples and best practices to help you integrate the API smoothly into your application. Whether you are a developer or a non-technical role involved in the integration process, the documentation aims to make API integration straightforward and efficient.
  • [Create network](https://api.docs.ukama.com/network/create-network.md): Create a new network by sending a POST request to the /v1/networks endpoint. This API allows you to specify various parameters to customize the network creation process. The parameters include allowed countries, allowed networks, budget, network name, organization, overdraft, payment links, and traffic policy. Upon successful network creation, the API will return a response with a status code of 206. The response will include information such as the network's allowed countries, allowed networks, budget, creation timestamp, network ID, deactivation status, network name, organization ID, overdraft amount, payment links, synchronization status, and traffic policy. This API endpoint is designed to simplify the integration of the Ukama API into your applications. It provides the flexibility to customize network settings according to your specific requirements.
  • [Get network](https://api.docs.ukama.com/network/get-network.md): The Ukama API allows you to retrieve information about a specific network. This endpoint provides details such as the allowed countries, allowed networks, budget, creation date, network ID, deactivation status, name, organization ID, overdraft limit, payment links, and synchronization status. This information can be useful for various use-cases, including managing network settings, monitoring network performance, and integrating with other systems. Please note that this endpoint requires the network ID as a path parameter to retrieve the desired network information.
• [Node](https://api.docs.ukama.com/node.md): The Node section of the Ukama API allows you to perform various operations on Nodes. Nodes are key elements within the Ukama system that represent entities such as users, organizations, or resources. By utilizing the Node API, you can retrieve, create, update, and delete Nodes, enabling you to manage and manipulate data within the Ukama platform. This section provides comprehensive documentation on the available endpoints and their corresponding functionalities, ensuring seamless integration and utilization of the API. Additionally, it covers essential considerations and special features related to working with Nodes, empowering both developers and non-technical users to effectively leverage the Ukama API for their specific use-cases.
  • [Add node](https://api.docs.ukama.com/node/add-node.md): This API section allows you to add a new node to an organization using the /v1/nodes endpoint. By making a POST request to this endpoint, you can create a new node with the specified parameters. The required body parameters include the name, node_id, org_id, and state. These parameters define the details of the node being added. Upon successful execution of the API request, a response with a status code of 201 will be returned. The response will include various parameters such as attached_nodes, created_at, id, name, org_id, site.added_at, site.network_id, site.node_id, site.site_id, site, state, and type. These parameters provide additional information about the newly created node. By using this API, you can easily integrate the functionality of adding a node to an organization in your application or system.
  • [Get node](https://api.docs.ukama.com/node/get-node.md): The `get /v1/nodes/{node_id}` API endpoint allows you to retrieve information about a specific node. This functionality is part of the Ukama API project. By providing the `node_id` parameter in the path, you can retrieve detailed information about the node. The response will include various parameters such as `attached_nodes`, `created_at`, `id`, `name`, `org_id`, `site.added_at`, `site.network_id`, `site.node_id`, `site.site_id`, `site`, `state`, and `type`. This API endpoint is designed to make it easy for developers to fetch specific node details, enabling seamless integration with the Ukama API. It is suitable for a variety of use-cases, including retrieving node information for display purposes, performing data analysis, or integrating with other systems. Please refer to the other sections of the documentation for further details on the method names, response examples, and parameters associated with this API endpoint.
  • [Delete node](https://api.docs.ukama.com/node/delete-node.md): The "delete /v1/nodes/{node_id}" API endpoint in the Ukama API allows you to remove a node from your organization. This functionality is useful when you no longer need a particular node or want to clean up your organization's data. By calling this API endpoint and providing the appropriate value for the "node_id" parameter, you can delete the specified node. This action permanently removes the node from your organization, including any associated data or connections. It's important to note that this API endpoint requires the "node_id" parameter to be specified as a path parameter. This parameter indicates which node should be deleted. Make sure to replace "{node_id}" in the API endpoint with the actual ID of the node you want to delete. When integrating with the Ukama API, consider the following use-cases for this endpoint: - Removing outdated or obsolete nodes from your organization's data. - Cleaning up unused nodes to improve performance and organization. - Deleting nodes that are no longer relevant or needed. Please refer to the other sections of the documentation for more details on the parameters required, examples of responses, and any additional considerations related to this API endpoint.
  • [Attach node](https://api.docs.ukama.com/node/attach-node.md): Attach node to a project The Attach node API allows you to link a node to a specific project. This functionality is useful when you want to associate a particular node with a project for organizational or tracking purposes. To attach a node, you need to provide the ID of the node you want to attach and the ID of the project to which you want to attach it. This information should be included in the request body. By attaching a node to a project, you can easily keep track of which nodes are associated with which projects, making it easier to manage and organize your data. Please note that when attaching a node to a project, you may need to consider any dependencies or relationships that the node may have with other entities within the project. Make sure to account for any related data or actions that may be affected by attaching the node. By utilizing the Attach node API, you can seamlessly integrate the functionality of attaching nodes to projects into your application, providing a straightforward and streamlined user experience.
  • [Dettach node](https://api.docs.ukama.com/node/dettach-node.md): The "delete /v1/nodes/{node_id}/attach" API endpoint allows you to detach a node from a group in the Ukama API. This functionality is useful when you want to remove a node from its current group and have it function independently. By sending a request to this API endpoint, you can detach the specified node from its group, allowing it to be managed separately. This can be helpful when you want to reorganize your nodes or when a particular node needs to operate autonomously. To use this API endpoint, you will need to provide the unique identifier of the node you wish to detach. This identifier is passed as a path parameter called "node_id". By specifying the correct "node_id" value, you can ensure that the intended node is detached from its group. It's important to note that detaching a node will not delete the node itself; it simply removes it from its current group. This allows you to maintain the node's data, settings, and configurations while disassociating it from the group's collective management. Please refer to the relevant sections in our documentation for more information on how to integrate the Ukama API and utilize this detach node functionality effectively.
  • [Add to site](https://api.docs.ukama.com/node/add-to-site.md): The "Add to site" API endpoint allows you to add a node to a site within the Ukama project. This functionality is essential for integrating nodes into existing sites and managing site-specific data. By making a request to this endpoint, you can seamlessly connect nodes to the desired site, making them accessible and functional within the site's context. The API endpoint follows a simple structure that is designed to be user-friendly and intuitive. It requires the specification of the `node_id` in the URL path parameter, which determines the node to be added. Additionally, the request body must include the `net_id` and `site_id` as parameters, providing the necessary context for the node's integration into the site. The "Add to site" API endpoint is a powerful tool that enables developers and non-technical roles alike to easily integrate nodes into sites within the Ukama project. Its straightforward functionality and clear parameters make API integration a straightforward process, allowing users to seamlessly connect nodes to their desired sites and streamline their project workflows.
  • [Release from site](https://api.docs.ukama.com/node/release-from-site.md): API Description: The "Release from site" API endpoint allows you to release a specific node from a site. This functionality is useful when you need to remove a node from a site without deleting it entirely. By releasing a node from a site, you can free up resources and manage your site structure more efficiently. To use this API, you need to provide the ID of the node you want to release as a path parameter. Once the node is released from the site, it will no longer be associated with that particular site. However, please note that the node itself will not be deleted from the system. This API can be particularly helpful in scenarios where you need to reorganize your site's structure or make changes to the nodes assigned to specific sites. By simply releasing a node from a site, you can easily modify your site architecture without the need to recreate or delete the node. It's important to keep in mind that this API only releases the node from the site it is associated with and does not perform any other actions on the node itself. Therefore, any additional operations or modifications required for the released node must be handled separately. Please refer to the relevant sections of the documentation for more detailed information, including examples and parameters, to ensure a smooth integration with the Ukama API.
• [Package](https://api.docs.ukama.com/package.md): This section of the Ukama API documentation provides details on the Package endpoint. This endpoint allows you to retrieve information about packages available within the Ukama system. Packages are a collection of related resources or services that are offered to users. By making a GET request to this endpoint, you can obtain information such as the name, description, and pricing details of each package. This can be useful for displaying available options to users, allowing them to select a package that best suits their needs. Additionally, the Package endpoint supports filtering and sorting options to help you narrow down the results based on specific criteria. You can specify parameters such as minimum and maximum price, package type, or any other relevant filters to retrieve a subset of packages that meet your requirements. Furthermore, the Ukama API provides pagination support for the Package endpoint. If the number of packages exceeds the default page size, you can use pagination parameters to retrieve results in smaller chunks for easier handling. It is important to note that the Package endpoint requires authentication using your API key. This ensures that only authorized users can access package information. You should include your API key in the request headers for all Package endpoint calls. Overall, the Package endpoint of the Ukama API simplifies the process of retrieving and managing package information. It offers flexibility through filtering, sorting, and pagination options, allowing you to integrate the Ukama package functionality seamlessly into your application or platform.
  • [Add package](https://api.docs.ukama.com/package/add-package.md): The Add Package endpoint allows you to create a new package in the system. This endpoint accepts various parameters to define the package details, such as the package name, active status, amount, APN, baserate ID, data unit, data volume, duration, flat rate, from date, markup, owner ID, SIM type, SMS volume, to date, traffic policy, package type, voice unit, and voice volume. Upon successful creation of a package, the API will return a response with a status code of 206 and the following parameters: active status, amount, APN, baserate ID, data unit, data volume, duration, flat rate, from date, markup, package name, networks, organization ID, overdraft, owner ID, SIM type, SMS volume, sync status, to date, traffic policy, package type, UUID, voice unit, and voice volume. By utilizing this endpoint, you can easily integrate the Ukama API into your system and create packages efficiently.
  • [Get package](https://api.docs.ukama.com/package/get-package.md): The "Get package" API endpoint allows you to retrieve detailed information about a specific package. By providing the package ID as a path parameter, you can access data such as the package's active status, amount, APN, baserate ID, data unit, data volume, duration, flat rate, from date, markup, name, networks, organization ID, overdraft, owner ID, SIM type, SMS volume, synchronization status, to date, traffic policy, type, UUID, voice unit, and voice volume. This API endpoint is designed to simplify the process of retrieving package information, making integration straightforward for developers and non-technical roles alike.
• [Sim](https://api.docs.ukama.com/sim.md): The GET API endpoint "Sim" within the Ukama API allows you to retrieve specific information related to SIM cards. This functionality is essential for managing and retrieving data associated with SIM cards in the Ukama system. Through this endpoint, you can access details such as the SIM card's unique identifier, activation status, and any associated user information. Use-cases for this API section include retrieving the status of a specific SIM card, verifying if a SIM card is active or inactive, and retrieving the user details associated with a particular SIM card. By incorporating this API endpoint into your integration, you can streamline your SIM card management processes and gain real-time access to vital information. It is particularly useful for applications that require instant access to SIM card data, such as mobile network providers, IoT device management systems, and SIM card inventory management platforms. When working with the "Sim" API endpoint, it is important to note that you will need to provide the necessary authentication and authorization credentials to ensure secure access to the data. Additionally, take into consideration any rate limits or usage restrictions that may apply to prevent excessive requests or unauthorized usage of the API. With the intuitive design of the Ukama API, you can easily integrate the Sim endpoint into your existing systems, allowing you to effortlessly manage and retrieve data related to SIM cards within the Ukama ecosystem.
  • [Configure sim](https://api.docs.ukama.com/sim/configure-sim.md): The Ukama API allows users to configure a new sim by making a POST request to the /v1/sims endpoint. This API endpoint is designed to simplify the integration process and streamline the configuration of new sims. To configure a new sim, you need to provide the necessary information in the request body. This includes details such as the sim's address, date of birth, email, first name, ID serial, last name, network ID, organization ID, package ID, phone number, proof of identification, sim token, sim type, subscriber ID, and traffic policy. These parameters ensure that the sim is properly configured and associated with the correct user and network settings. Upon successful configuration, the API will return a response with a status code of 206. The response will include various parameters related to the sim, such as the date it was allocated, the ICCID (Integrated Circuit Card Identifier), a unique ID for the sim, the IMSI (International Mobile Subscriber Identity), information about whether the sim is physical, the MSISDN (Mobile Station International Subscriber Directory Number), the network ID, the sim type, the status of the sim, the subscriber ID, the sync status, and the traffic policy. By leveraging the Ukama API's configure sim endpoint, developers and non-technical users alike can easily integrate their systems with the Ukama platform and seamlessly configure new sims. This straightforward integration process allows for efficient management of sims and enables users to quickly get their devices connected to the network.
  • [Get sim](https://api.docs.ukama.com/sim/get-sim.md): The Ukama API allows you to retrieve information about a specific sim. This endpoint provides the functionality to retrieve detailed data for a sim based on its unique identifier. By making a request to the `/v1/sims/{id}` endpoint, you can obtain various details about the sim, including its allocated date and time, ICCID, IMSI, physical status, MSISDN, network ID, sim type, status, subscriber ID, sync status, and traffic policy. This API is designed to make sim information easily accessible, enabling you to efficiently retrieve specific data for integration into your applications or systems. Whether you are a developer or a non-technical user, the Ukama API's straightforward functionality ensures a seamless integration process.