What Is an Open API?

An open (or public) API is a set of API calls a company publishes for its customers. Instead of logging in and clicking buttons, your own app, spreadsheet, or automation tool sends a request and the product does the work — pulling a report, updating a record, or changing a setting.

It's still up to the company. Every company decides which API calls to offer. One may let you read and change almost everything; another may only let you pull a few reports. Before building anything, read that company's API documentation to see exactly what's allowed.

The Anatomy of a Single API Call

Every standard API call is made up of five core components. Once you can spot them, any company's API documentation starts to make sense.

1HTTP Method
POST

One verb that says the job — GET to read, POST to create, PUT / PATCH to change, DELETE to remove.

2URL / Endpoint
https://company.com/api/v2/customers

URL / Endpoint

?region=Europe&interest=hiking

Query Parameters

3Headers
Content-Type: application/json
Accept: application/json
X-API-Version: 2

The hidden envelope paperwork — what kind of data you're sending, what you'd like back, and which version of the API you're built for.

4Authorization
Authorization: Bearer eyJhbGci…
x-api-key: sk_live_51H8f…

Your secure digital passport — proof that the call is allowed. It usually rides along in the headers (older APIs sometimes tuck it into the address), and without it the answer is 401 Unauthorized.

5Body / Payload
{ "name": "Alex", "email": "alex@email.com" }

The information you're actually handing over — only used by POST, PUT and PATCH calls. A GET call usually has no body: the verb, the address and your login details are enough.

Read a company's API documentation and every call you find is these same five parts, written out in full.

1. What Type of API Do They Offer?

REST is the most common for business APIs, but companies choose from four main styles depending on their needs.

RESTThe current "gold standard" for the web. Built on normal web addresses (URLs) and standard commands like GET to read data and POST to send data.Why companies use it: Predictable, easy to learn, and works with web browsers and tools like Postman.Looks like: GET /​api/​v2/​customers?​region=​EuropeExamples: Stripe, Twilio, Pelican Wireless and most modern software
SOAPAn older, stricter standard that wraps everything in XML (a tag-based data format) instead of simple URLs.Why companies use it: Built-in, bank-grade security and formal contracts. Still common at banks, airlines and large enterprises established before 2010.Looks like: <soap:​Body><m:​GetTemperature /​></​soap:​Body>Examples: Older banking networks, Salesforce's legacy integrations
GraphQLCreated by Facebook. Instead of visiting many URLs, you send one "shopping list" to a single URL and get back exactly what you asked for — nothing more, nothing less.Why companies use it: Avoids fetching extra data, so apps and heavy websites load fast.Looks like: POST /​graphql → { profiles(region:​"Europe") { name } }Examples: GitHub, Shopify, Facebook
gRPC / WebSocketsStreaming APIs. Instead of ask-and-answer, they keep a constant open "pipe" between your computer and their server.Why companies use it: For live, real-time data where waiting even a second is too slow.Looks like: POST /​ThermostatService/​GetTemperaturewss:​/​/​live.​company.​com/​thermostatsExamples: Crypto price tickers, ride-share GPS tracking, chat apps
So what does the same job look like in each style? Every row below asks one thermostat for its temperature — the same job, four different shapes.
RESTReadable text

GET /​thermostats/​TestThermostat?​value=​temperature comes back as 200 OK · {"temperature":​ 21}. The verb and the thing you want both sit in the address, and the answer is plain enough to read straight off the screen.

SOAPXML envelope

One POST carries the whole request as tags: <soap:​Body><m:​GetTemperature><m:​Name>TestThermostat</​m:​Name></​m:​GetTemperature></​soap:​Body>. The reply is more XML, so your code has to open the envelope before it can find the number inside.

GraphQLOne address, a shopping list

POST /​graphql with {"query":​ "{ thermostat(name:​ 'TestThermostat') { temperature } }"} returns exactly {"data":​{"thermostat":​{"temperature":​21}}} — the one field you asked for, nothing extra.

gRPC / WebSocketsFast, not readable

gRPC runs the named procedure /​ThermostatService/​GetTemperature with the data as compact binary instead of text. A WebSocket opens a live pipe at wss:​/​/​live.​company.​com/​thermostats: you send {"type":​"getTemp"} once, and new readings are pushed to you as they change.

The short version: REST, GraphQL and SOAP all send text you can read; gRPC and WebSockets go binary to be fast. And the four verbs and the many-doors rules in the next two sections are REST's way of doing things, not every style's.

2. Which Method Does Each Call Use?

The method is the verb at the start of a request — it tells the API what you want to do. These four verbs are how REST works. The other styles hide the action inside the message, so the verb stops carrying meaning.

GETRead data — "show me my thermostats" or "list my orders".
POSTCreate something new or send data — "add a customer" or "set the temperature".
PUT / PATCHUpdate something that already exists — "change this customer's email".
DELETERemove something — "cancel this appointment".
So does every style use GET, POST, PUT and DELETE? No — only REST does. Here is where each style actually puts the instruction.
RESTYes — all four

The verb is the instruction. GET reads, POST creates, PUT / PATCH changes, DELETE removes.

SOAPNo — always POST

Nearly every call is sent as a POST. The action you want is named inside the XML message instead.

GraphQLRarely — one POST

One address, one POST. The message body says query to read or mutation to change.

gRPCNo

Its own fast binary language. The call names the method directly, like ThermostatService / SetTemperature.

WebSocketsOnly at the door

One GET opens the pipe. After that there are no verbs — each message carries its own type, like "type": "setTemp".

The short version: REST puts the verb in the address line, the others put it inside the message. That's one reason REST is the easiest style to read in a company's API documentation — you can often tell what a call does before you open it.

3. Where Is the Endpoint?

The endpoint is the exact web address a call is sent to — the door you knock on. A method only tells the API what to do; the endpoint tells it where to do it. Every company puts its doors in different places, and some give you many while others give you only one, so the address always comes from their documentation.

The base addressWhere the company's API lives — usually their web address with /api or /api.cgi added on. You find it in the first page of their documentation.Looks like: https:​/​/​demo.​officeclimatecontrol.​net/​api.​cgi
The resourceThe thing you want to work with — the thermostat, the customer, the order, the event. Some companies put it in the address, others name it inside the request.Looks like: object=​Thermostat,​ or /​v2/​customers
The filtersNarrow it down to the one record or report you actually want, instead of everything the company has.Looks like: ?​region=​Europe&​interest=​hiking,​ or selection=​name:​TestThermostat
What you want backWhich fields to return, so you aren't sent columns you'll never look at.Looks like: &​value=​heatSetting;​coolSetting;​temperature
Put together, it's one address. Pelican Wireless' real example reads https:​/​/​demo.​officeclimatecontrol.​net/​api.​cgi?​username=​…&​password=​…&​request=​get&​object=​Thermostat&​selection=​name:​TestThermostat&​value=​heatSetting;​coolSetting;​temperature — the base address, the login, the method, the resource and the fields you want back, all in one line. A REST API splits the same idea across the address and the request body instead of cramming it into the URL.
So does every style have endpoints? Yes — a call always has to go somewhere. What changes is how many addresses you're handed.
RESTMany doors

One address per thing — /customers, /customers/42, /orders. The address itself tells you what the call touches.

SOAPUsually one door

A single address serves the whole service. Which operation runs is written inside the XML message.

GraphQLUsually one door

One address for everything. The message body decides what comes back.

gRPCA door per method

The address names a procedure to run, like ThermostatService / SetTemperature — usually written in code rather than typed into a browser.

WebSocketsOne door, used once

One address opens the pipe. After that the messages just flow, with no address on each one.

WebhooksYour door, not theirs

The company sends calls to an address you publish, so their endpoint list is your address.

The short version: only REST gives you a long list of addresses. With GraphQL, SOAP or WebSockets, one address can hide thousands of possible actions — so the list of operations in the documentation tells you more than the address does.

4. How Do You Prove Who You Are?

How you log in (authenticate) depends entirely on how the company built its system. These are the four most common ways.

Username & Password (Basic Authentication)Some APIs simply ask for your normal login, like signing into a website.Where it goes: In the web address (as ?username=...&password=...) or hidden in the headers.Looks like: ?​username=​demo&​password=​thermostatExample: Pelican Wireless puts your username and password right in the URL — no key or token.
API KeysA long, unique string of random letters and numbers made just for you (e.g. sk_live_51Nx...). Think of it as a permanent digital valet key — don't share it.Where it goes: Usually in a header like x-api-key: your_key_here (most secure). Some allow it in the URL, which is less safe because others can see it in logs.Looks like: x-api-key:​ sk_live_51H8f7aD2eP9x…Example: Weather services, Stripe, SendGrid
Bearer Tokens / JWTsA temporary security badge. You log in first, and the API hands back a token that works for an hour or a day.Where it goes: Almost always in the headers: Authorization: Bearer your_token_here.Looks like: Authorization:​ Bearer eyJhbGciOiJIUzI1NiIs…Example: Most modern apps after a login step
OAuth 2.0 ("Connect with Google" style)You click a button, a popup asks you to log in and "Allow Access". The two systems then trade a secure token so one can act on your behalf without ever knowing your password.Where it goes: The token is stored by the connecting tool and sent hidden in the headers on every call.Looks like: Authorization:​ Bearer ya29.​a0ARrdaM…Example: Zapier connecting to HubSpot, Google, Slack
So which login style will you actually run into? The company decides — their documentation names it on the first page. Here's what each one looks like in a real call.
Username & PasswordOldest, simplest

The login travels with every single call. Pelican Wireless writes it straight into the address — ?​username=​demo&​password=​thermostat. The other way is a header: Authorization:​ Basic ZGVtbzp0aGVybW9zdGF0 — and that long string is only demo:thermostat scrambled, not encrypted, which is why it must always travel over https://.

API KeysUsual starting point

You sign into the company's own dashboard, press "Create key", and paste it into your calls: x-api-key:​ sk_live_51H8f7aD2eP9x…. It keeps working until you delete it, so guard it like a password — and send it in a header, never the address, because addresses get logged and pasted around.

Bearer Token / JWTExpires by itself

You send your login once to a POST /​login address, it hands back a token, and you attach that to every later call: Authorization:​ Bearer eyJhbGciOiJIUzI1NiIs…. It usually dies after an hour or a day, so you ask for a fresh one — nothing to go and revoke if it leaks.

OAuth 2.0You click a button

Three steps, none of them typed by you: your app sends the person to the company's own login page naming the permission it wants (?​scope=​calendar.​readonly), they tick "Allow", and the company sends back a short code your app trades for a token at POST /​token. The app never sees the person's password — which is why it's the only style that works for "Connect with Google".

The short version: a password travels on every call, a key is a password you can delete, a token expires on its own, and OAuth is the only style where your app never sees the person's password.

Examples of Companies That Publish API Calls for Customers

Click any company to open its API documentation — the list of calls it lets you make.

Where to Go Next

Keep going in order, or jump to any page from the top menu.