API & SDK. The order counter and the toolbox

As soon as someone explains how an AI works inside a product, two letter salads almost always come up: API and SDK. Both sound technical, and both mean something very down-to-earth at their core. Let's take this slowly, with two everyday images you can hold on to.

API, the order counter

The abbreviation API stands for Application Programming Interface, roughly "programming interface" in plain English. That's a term that looks more complicated on paper than it is in everyday use.

Concretely, in the AI context: companies like Anthropic, OpenAI, or Google run huge data centers where their models operate. These models are so large that you can't run them on your laptop. Instead, the companies provide an API, an order counter on the internet where you send your request.

For example, you send "Write me a poem about Hamburg" to a particular web address. On the other end, the model runs, responds, and sends the text back to you. You never touched the model itself. You just placed an order.

REST API and JSON. The format of the order

In the vast majority of cases, the AI API works as a so-called REST API. That's a very specific way of sending orders over the internet, following fixed rules, with a fixed address and fixed commands like "fetch this" or "send that".

And the format the order is packaged in is called JSON, pronounced like "Jason". This is basically just a particular way of writing down structured data: keys and values inside curly brackets. You don't need to memorize the exact syntax; the important image is just this: JSON is the order slip the request is written on.

The API key, your ID card

So the API knows who's ordering, you need an API key. That's a long, secret string of characters you get when you sign up with the provider. You send this key along with every order.

SDK, the toolbox

Now for the second term. SDK stands for Software Development Kit. Again, a word that sounds scarier than it needs to be.

Concretely: if you want to write a program in Python or JavaScript that talks to the Anthropic AI, you could in theory painstakingly assemble a JSON order slip every single time, send it to the API address, receive the response, unpack the JSON again, and catch errors. That's tedious.

Instead, you install the Anthropic SDK, a ready-made library for your programming language. Then you simply write client.messages.create(...), and the SDK takes care of all the order-slip busywork in the background.

What does that look like?

Here's a tiny example in Python. Don't worry, you don't need to understand it, just take a look:

from anthropic import Anthropic

client = Anthropic(api_key="your-key-here")

answer = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=200,
    messages=[{"role": "user", "content": "Write a poem about Hamburg."}]
)

print(answer.content[0].text)

Five lines of proper code, and you have a finished AI answer. Without the SDK, that would easily be 30 lines full of connection code, JSON fiddling, and error handling.

API vs. SDK, side by side

So which one do I use?

The rule of thumb is pleasantly short:

In practice, that means: Python and JavaScript developers use the SDK almost every time. Anyone working in a more exotic language like Rust, Elixir, or Crystal often builds their own small API wrapper. And if you just want to quickly test something from the terminal, you use a tool called curl to send an order slip straight to the API.

The SDK is the friendly shell. The API is the actual counter. Both talk to the same model.

What the API can do

The AI API isn't just "question in, answer out". Through the same interface you can also:

• Send images along, and the AI tells you what's in them.
• Attach documents, e.g. a PDF the AI should talk about.
• Define tools the AI is allowed to use (more on that in the chapter on Agents).
• Stream responses ("streaming"). Word by word, instead of the whole block at the end.
• Give system instructions, such as "You are a polite customer service assistant."

All of this works both directly via the API and via the SDK, it's just that the SDK makes it more pleasant.

And the costs?

One point many beginners overlook: using the API costs money. You pay per token, meaning per small chunk of text that goes in and out. A few cents per thousand words, depending on the model. Barely noticeable for a single hobby script, but a real cost item for a production application with thousands of users.

Which is why: think first, then order. Are you really sending necessary context? Do you need the full 200,000-word model, or is a smaller one enough? Questions like these suddenly become relevant.