What exactly is an API ❓

API is an abbreviation for "Application Programming Interface" It is a collection of protocols, processes, and tools used to create software applications.

An API is a mechanism used by software developers to allow various applications to communicate with one another. These are the means via which various software components may communicate and exchange information with one another.

APIs can be used to get access to a variety of services, including web services, databases, operating systems, hardware devices, and others.

Web APIs 🌐🕸️

These APIs are available through the internet and communicate via HTTP/HTTPS protocols. RESTful (Representational State Transfer), SOAP (Simple Object Access Protocol), GraphQL, and other protocols are examples of web APIs.

1. Internal APIs: 📥

   Internal APIs sometimes referred to as private or local APIs, are intended for communication within an organization or between various components of a single program. Internal APIs are used within a company to build software applications that work together. They can expose data or functionality between teams, departments, or services, allowing for better collaboration and efficiency.

   Examples

   Examples include the Employee Directory API, which allows HR and IT teams to access employee data, and the Employee Data API, which allows marketing teams to pull data for newsletters and communications.

   Implementation of the mock Employee Directory API and Employee Data API using JavaScript with Node.js and Express:

   First, make sure you have Node.js and NPM installed. Then create a new folder for your project and run the following command to initialize a new Node.js project and install Express:

    bashCopy codenpm init -y
    npm install express
   

   Now, create a new file named app.js and add the following code:

    const express = require('express');
    const app = express();
    const port = 3000; // You can change this port as needed
   
    // Mock data for employee directory
    const employeeDirectory = [
      { id: 1, name: 'John Doe', department: 'HR' },
      { id: 2, name: 'Jane Smith', department: 'IT' },
      // Add more employee data as needed
    ];
   
    // Mock data for employee data
    const employeeData = [
      { id: 1, email: 'john.doe@example.com', phone: '123-456-7890' },
      { id: 2, email: 'jane.smith@example.com', phone: '987-654-3210' },
      // Add more employee data as needed
    ];
   
    // Employee Directory API endpoint
    app.get('/employee-directory', (req, res) => {
      res.json(employeeDirectory);
    });
   
    // Employee Data API endpoint
    app.get('/employee-data', (req, res) => {
      const department = req.query.department;
      if (department) {
        const filteredData = employeeData.filter(emp => emp.id === parseInt(department));
        res.json(filteredData);
      } else {
        res.json(employeeData);
      }
    });
   
    // Start the server
    app.listen(port, () => {
      console.log(`Server running on http://localhost:${port}`);
    });
   

   To run the server, execute the following command in your project folder:

    node app.js
   

   The server will start, and you can access the Employee Directory API at localhost:3000/employee-directory and the Employee Data API at localhost:3000/employee-data.

   Note: However, internal APIs are not as well-documented or stable as external APIs, making them more flexible and adaptable to the organization's needs.

2. External APIs 📤

   External APIs are publicly available interfaces provided by companies or organizations for third-party developers. They allow developers to integrate specific services or platforms into their applications.

   Examples

   Third-party APIs are APIs supplied by third-party services or platforms that developers may utilize to interface their apps with these services. Google Maps API, Twitter API, and other services are examples.

   The Advantages of External APIs 📤

   These APIs are valuable as they accelerate development, lower expenses, and enhance application quality by leveraging existing services.

   Additionally, external APIs open up new business prospects for service providers, as third-party developers can create innovative applications on top of their offerings.

RESTful Services 🫂

RESTful Services: REST (Representational State Transfer) is an architectural design approach for networked systems, notably web services. It is a collection of limitations that, when applied to the design of APIs, transform them into RESTful APIs.

Example:

Online Store RESTful Web API 🕸️🌐

Suppose we have an online store that sells products, and we want to create a RESTful Web API to provide access to product information and manage orders.

1. Retrieve Product Information (GET request): 📦🧑‍💻

   • Endpoint: /products

   • Description: This endpoint allows clients to retrieve a list of all available products in the online store.

   • Request: GET example-online-store-api.com/products

   • Response: JSON representation of product data.

2. Retrieve Specific Product (GET request): 📦📦🔁

   • Endpoint: /products/{id}

   • Description: This endpoint allows clients to retrieve detailed information about a specific product based on its unique ID.

   • Request: GET example-online-store-api.com/products/123

   • Response: JSON representation of the product with ID 123.

3. Create New Order (POST request): 📭📪📬

   • Endpoint: /orders

   • Description: This endpoint allows clients to create a new order for products in the online store.

   • Request:

       POST https://example-online-store-api.com/orders
       Body: 
       {
         "customer_name": "John Doe",
         "products": [
           {
             "product_id": 123,
             "quantity": 2
           },
           {
             "product_id": 456,
             "quantity": 1
           }
         ]
       }
     

   • Response: JSON representation of the newly created order.

4. Update Order (PUT request): 🗃️

   • Endpoint: /orders/{order_id}

   • Description: This endpoint allows clients to update an existing order based on its ID.

   • Request:

       PUT https://example-online-store-api.com/orders/789
       Body: 
       {
         "products": [
           {
             "product_id": 123,
             "quantity": 3
           }
         ]
       }
     

   • Response: JSON representation of the updated order with ID 789.

5. Delete Order (DELETE request): 🗑️

   • Endpoint: /orders/{order_id}

   • Description: This endpoint allows clients to delete an order based on its ID.

   • Request: DELETE example-online-store-api.com/orders/789

   • Response: Status code indicating the success or failure of the deletion.

Key Principles of RESTful Services 🔐🗝️

Stateless: Each request sent by a client to a server must provide all of the information required to interpret and process the request. Between requests, the server should not keep any client state.

Resource-based: APIs should be resource-based, with resources (e.g., people, goods) defined by unique URLs (Uniform Resource Locators).

Uniform Interface: RESTful APIs use a standardized set of methods (HTTP verbs) to conduct resource activities, such as GET (retrieve data), POST (create a new resource), PUT (update an existing resource), DELETE (delete a resource), and so on.

Resources can have several formats (e.g., JSON, XML), and the client can specify the preferred representation in the request.

Building APIs: 🏗️👷

To create an API, follow these general steps:

Define the Purpose: Determine the precise functionality and data that your API will provide.

Choose a Protocol and Data Format: HTTP/HTTPS is the standard protocol for web APIs, and JSON is a common data format, while XML and other formats are also used.

Create Endpoints: Define the URLs and HTTP methods that customers will use to connect with the resources of your API.

Implement Business Logic: Create the code that will process requests to your API endpoints and conduct the necessary data operations.

Authentication and Authorization: Determine how clients will authenticate to use the API and put any appropriate security mechanisms in place.

Testing and Documentation: Thoroughly test your API and write clear and detailed documentation to assist developers in understanding how to use it.

API Consumption: 📥📥

To use an API in your web application, typically do the following steps:

Examine the documentation: Examine the service's API documentation to learn about the accessible endpoints, data types, authentication methods, and use rules.

Obtain an API Key or Token: If necessary, sign up for an API key or token to authenticate your API queries.

Select an HTTP Client: Make HTTP requests using a programming language or library that supports it. Python's requests, JavaScript's fetch, and frameworks like "axios" are also popular options.

Make Requests: To interact with the API's endpoints, use the HTTP methods (GET, POST, PUT, DELETE), giving any necessary arguments in the request.

Process Responses: Receive API answers, often in JSON or XML format, and parse the data to extract the important information for your application.

Handle Errors: Implement error handling if the API produces problems or there are connectivity difficulties.

Thank you for reading our blog. Our top priority is your success and satisfaction. We are ready to assist with any questions or additional help.

Warm regards,

ByteScrum Blog Team,

ByteScrum Technologies Private Limited! 🙏