Types of API endpoints and how to customize a request

Your field team marks a job as complete in the scheduling app. An hour later, the client calls to ask why their portal still says "in progress." Somewhere between those two systems, a request never reached the right endpoint.

That is what API endpoints do all day: they move a status, a record, or a file from one tool to another. This guide covers the main types of API endpoints (GET, POST, PUT, PATCH, and DELETE), how to customize a request with query parameters, a request body, and headers, and what each one looks like in a real operation.

TL;DR

• An API endpoint is a specific URL where one app asks another app for data, or tells it to change something.
• The main types of API endpoints are named after their HTTP method: GET reads data, POST creates a record, PUT replaces a record, PATCH changes part of a record, and DELETE removes it.
• You customize a request in three places: query parameters in the URL (to filter and sort), the request body (the data you send), and headers (the format and your API key).
• A real example: GET /work-orders?status=open returns every open job, ready to show on a dashboard or in a client portal.
• If your data already lives in a tool like Airtable, Google Sheets, or a SQL database, you can often skip writing requests and connect that data to an app builder directly.

What Are API Endpoints?

An API (Application Programming Interface) allows two software applications to talk to each other, and API endpoints are the specific URLs where this interaction happens. Each endpoint performs a particular action, whether retrieving data, creating a new record, or deleting something from a database.

For example, a CRM might expose an endpoint like https://api.example.com/contacts to allow access to contact data, or https://api.example.com/clients/87/invoices might return the invoices for one client. These interactions are powered by HTTP methods, most commonly the following four endpoint types:

• GET – Retrieve data
  
• POST – Create new data
  
• PUT – Update existing data
• DELETE – Remove data

If you're new to the idea, our guide to understanding API endpoints covers the basics of requests and responses.

What are the Common Types of API Endpoints?

These four types of API endpoints represent the standard CRUD operations—Create, Read, Update, Delete. Here's how they work and how to use them in JavaScript with the fetch() API.

GET Endpoints

GET endpoints are used to retrieve information from an API. They are the most commonly used type of endpoint and are used to retrieve data such as user information, product details, and more.

You can call a GET endpoint as many times as you like without side effects, which makes it the safest endpoint type to start with.

For example, let's say you want to retrieve the details of a specific product from an e-commerce API using JavaScript's fetch API. You would use the following code:

fetch("https://api.example.com/products/123", { method: "GET" })
  .then((response) => response.json())
  .then((data) => {
    console.log(data);
  });

This sends a GET request to the products/123 endpoint and returns product details in JSON format.

Or let's say you want to show a client the status of their project, list this week's jobs for a technician or pull invoice totals into a report: 
‍
fetch('https://api.example.com/work-orders/1042', {
 headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
})
 .then(response => response.json())
 .then(workOrder => console.log(workOrder.status));
‍
The response comes back as JSON, for example { "id": 1042, "status": "in_progress", "technician": "Sam Ortiz" }.

POST Endpoints

POST endpoints are used to send new information to an API. They are commonly used to create new resources such as creating a new user or a new product. You send the details in the request body, and the server usually replies with the new record and its ID.

For example, let's say you want to create a new product in an e-commerce API using JavaScript's fetch API. You would use the following code:

const product = {
  name: "Product Name",
  description: "Product Description",
  price: 100,
};

fetch("https://api.example.com/products", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify(product),
})
  .then((response) => response.json())
  .then((data) => {
    console.log(data);
  });

In this example, we're using the fetch API to send a POST request to the endpoint "https://api.example.com/products" and include the product details in the request body in the form of JSON. This creates a new product and returns confirmation.

Use it when a website form creates a new lead in your CRM, or when a technician submits a site survey from their phone too.

One thing to watch: sending the same POST twice usually creates two records. If a form can be submitted twice, plan for duplicates.

PUT Endpoints

PUT endpoints are used to update existing information in an API. They are similar to POST endpoints but are used to update resources instead of creating new ones.

For example, let's say you want to update the details of a specific product in an e-commerce API using JavaScript's fetch API. You would use the following code:

const updatedProduct = {
  name: "New Product Name",
  description: "New Product Description",
  price: 120,
};

fetch("https://api.example.com/products/123", {
  method: "PUT",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify(updatedProduct),
})
  .then((response) => response.json())
  .then((data) => {
    console.log(data);
  });

This updates product 123 with new information.

DELETE Endpoints

DELETE endpoints are used to remove resources from the system.

For example, let's say you want to delete a specific product from an e-commerce API using JavaScript's fetch API. You would use the following code:

fetch("https://api.example.com/products/123", { method: "DELETE" })
  .then((response) => response.json())
  .then((data) => {
    console.log(data);
  });

This sends a DELETE request to remove the product with ID 123.

How do you customize a request with query parameters, a request body, and headers?

Every request to an endpoint can be shaped in three places. Query parameters narrow down what you get back, the request body carries the data you send, and headers describe the request and prove who you are.

So in addition to understanding the different types of API endpoints, it’s equally important to know how to customize your requests using them. They give you more control over how data is fetched or sent, allowing you to filter results, send structured data, or update only what’s necessary.

Query Parameters

These are appended to the URL to filter or sort results, often used with GET requests.

fetch(`https://api.example.com/products?category=books&price=50-100`, {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => {
    console.log(data);
  });

• ? starts the query
• & separates multiple parameters

Request Body

Used with POST and PUT endpoints to send structured data (often JSON). This data is passed via the body key in your fetch configuration.

Headers

Headers are labels attached to the request. Two show up in almost every call:

• Content-Type: application/json tells the server the body is JSON.
• Authorization: Bearer YOUR_API_KEY proves you are allowed to make the request. Our guide to API authentication methods explains API keys, tokens, and OAuth.

How are API Endpoints used in Real Business Operations?

How do you pull work order status into a custom dashboard?

This is one of the most common reasons operations teams start looking at API endpoints. The steps are the same whether you use a field service tool, a project management tool, or a CRM.

1. Find the endpoint. Search the tool's API documentation for "work orders," "jobs," or "tasks." Docs are not always complete: in the Postman 2025 report, 55% of respondents named documentation gaps as a problem, so be ready to ask the vendor's support team.
2. Get an API key. It is usually under admin or developer settings. Send it in the Authorization header, and store it somewhere safe, not in a spreadsheet.
3. Call a GET endpoint with filters. For example: /work-orders?status=in_progress&updated_since=2026-10-01.
4. Decide how often to refresh. Most APIs limit how many requests you can make per minute, so pulling every few minutes is usually safer than every few seconds.
5. Decide who sees what. A manager sees every job; a client should only see their own sites. That rule has to live somewhere, either in your code or in the tool that displays the data.

If your work orders already live in Airtable, Google Sheets, HubSpot, or a SQL database, you may not need the endpoint at all. You can connect that data to a dashboard builder and skip the code. Our step-by-step guide on how to build a dashboard covers that route.

How Noloco Helps You Work with APIs?

Noloco makes it easy to integrate and interact with APIs, no backend or advanced technical skills required. Whether you're a business analyst or operations manager, you can connect to external APIs and trigger actions directly from your custom apps.

Here’s what you get with Noloco:

• API Workflows – Trigger GET, POST, PUT, DELETE actions via our AI-powered workflow builder
  
• Permissions & Access Control – Secure your API access with our advanced permissions system
  
• Customizable Interface – Use our point-and-click app builder to design the perfect frontend for your internal or external API use case
  
• Integrated Data Sources – Pull data from Airtable, SQL, or our own Noloco Tables

Need help building your API-connected app? Hire a Noloco Expert

FAQs About the Types of API Endpoints

What are the different types of API endpoints?

The most common types are:

• GET – Retrieve data
  
• POST – Create data
  
• PUT – Update existing data
  
• DELETE – Remove data
  

What’s the difference between query parameters and request body?

• Query parameters are used in the URL (usually for filtering GET requests).
  
• Request bodies contain the data being sent (used in POST and PUT).
  

Can I use API endpoints without a backend?

Yes. With platforms like Noloco, you can trigger API calls directly from the frontend via workflows, ideal for teams without in-house developers.

What is the difference between query parameters and a request body?

Query parameters are added to the end of the URL to filter or sort results, mostly on GET requests. The request body carries the data you send, usually as JSON, on POST, PUT, and PATCH requests.

What are some other resources related to API endpoint types?