APIs & Integrations

Busted

• API DeprecationThe warning period before an API is removed, giving callers a replacement, migration guide, deadline, and time to move.
• API DocumentationThe guide that tells a developer how to authenticate, make a real call, handle failures, and stay within an API's rules.
• API GatewayOne public front door that routes API calls to the right service and applies shared rules like auth, quotas, and logging.
• API ProxyA route on your own server that forwards calls to someone else's API, so the secret key never ships to the browser.
• API VersioningPublishing a frozen shape of your API (v1, v2) so you can keep changing things without breaking the apps already built against it.
• Asynchronous Job PatternInstead of making the caller wait, the API accepts the work, hands back a job ID, and tells you when it is done.
• At-Least-Once DeliveryA delivery promise that keeps retrying so a message arrives, with the tradeoff that the same message can arrive more than once.
• Backend for Frontend (BFF)A small backend tailored to one client, combining services into the exact response shape that web, mobile, or another frontend needs.
• Batch / Bulk EndpointOne API call that handles many records at once, instead of firing a separate request per row until the rate limit cuts you off.
• Circuit BreakerA safety switch that stops calls to a failing service for a while, then sends a small probe to see whether it has recovered.
• Conflict ResolutionThe rules for deciding what survives when two connected systems change the same record differently.
• Content-Type / MIME TypeThe header that tells the other side what format the body is in, like application/json or image/png. Wrong label, unreadable data.
• CRUDCreate, read, update, delete: the four operations behind almost every screen and API. Say 'CRUD' and you have asked for all four.
• Data Mapping / Field MappingDeciding which field on their side becomes which field on yours, so 'MailingStreet' lands in 'address.street' and nothing quietly vanishes.
• Dead Letter QueueA quarantine queue for jobs that kept failing, so good work can continue while operators inspect and safely replay the bad ones.
• DeduplicationRecognizing a request or event you already handled so a retry does not charge, send, or update anything twice.
• EndpointOne specific address on an API: a method plus a path, like POST /v1/customers. The exact thing you call.
• Error ResponseThe predictable JSON an API returns on failure, with a status, stable code, human message, and useful details.
• ETag / Conditional RequestA version tag the client sends back so unchanged data gets a tiny 304 response, and stale updates can be rejected before overwriting newer work.
• Event Bus / Pub-SubA shared channel where services announce events and any interested subscribers receive their own copy and react independently.
• Eventual ConsistencyAn update is accepted now but reaches caches, replicas, search, or partner systems later, so brief stale reads are expected.
• Exponential BackoffRetrying a failed call with a wait that doubles each time (1s, 2s, 4s), plus randomness, so you stop hammering a struggling service.
• Fan-outThe one-to-many pattern where a single event is copied to several downstream consumers, each free to react on its own.
• GraphQLOne endpoint where the client writes a query naming exactly the fields it wants, and gets back JSON shaped like that query.
• gRPCA fast, typed way for services to call each other using generated code, compact protobuf messages, and HTTP/2.
• HTTP MethodsThe verb on an HTTP request: GET reads, POST creates or submits, PUT replaces, PATCH edits, and DELETE removes.
• HTTP Status Codes (2xx/4xx/5xx)The three-digit verdict on every response: 2xx worked, 4xx the server won't take the request as sent, 5xx the server broke.
• Idempotency KeyA unique ID you attach to a request so retrying it does nothing the second time. The reason a retried payment doesn't charge twice.
• Incremental SyncA sync that transfers only records added, changed, or deleted since the last successful run instead of copying everything again.
• Integration Platform as a Service (iPaaS)Hosted glue for wiring SaaS apps together with triggers and actions, so nobody has to write and host the integration code.
• Long PollingPolling where the server keeps each request waiting until new data arrives or a timeout forces the client to reconnect.
• Message QueueA line jobs wait in so producers can hand off work instantly and workers chew through it at their own pace.
• MiddlewareCode every matching request passes through on its way to a handler, useful for shared work like auth, logging, and parsing.
• multipart/form-dataThe request format that lets one form send files and ordinary fields together without turning the file into base64 JSON.
• OpenAPI SpecificationA YAML or JSON file describing every endpoint, input, and response of an API, so tools can generate docs, clients, and mocks from it.
• Pagination (Cursor vs Offset)Fetching a long list in chunks: offset counts how far in you are, cursor hands you a bookmark for where the last chunk stopped.
• PayloadThe actual data in the body of a request or response, as opposed to the URL and headers wrapped around it.
• PollingAsking an API 'anything new?' on a timer instead of waiting to be told. Simple, a bit wasteful, and often the right call.
• Presigned URLA short-lived signed link that lets someone upload or download one object directly without getting your storage credentials.
• Query Parameters vs Path Parameters vs Request BodyThe three places input goes on a request: the path for which thing, after the question mark for how you want it, the body for the data.
• Rate LimitThe cap on how many API calls you get per window. Cross it and you get a 429 instead of your data.
• ReconciliationA scheduled full compare that finds and repairs records which webhooks or incremental syncs left out of step.
• Request HeadersThe small name-value fields attached to a request that carry its token, body format, cache rules, and other instructions.
• Response NormalizationReshaping outside API responses into one schema your app owns, so vendor field names and quirks stop spreading through the codebase.
• REST APIAn API built out of URLs that name things plus HTTP verbs that act on them: GET to read, POST to create, DELETE to remove.
• Retry PolicyThe rulebook for when a failed call gets another try, how long each wait lasts, and when the caller finally gives up.
• RPC-style APIAn API organized around commands like /cancelOrder or chat.postMessage instead of resource URLs like /orders/42.
• Sandbox / Test ModeA parallel copy of a service that behaves like the real thing but touches nothing real: fake charges, fake emails, fake shipments.
• Schema RegistryA shared, versioned catalog of event shapes that stops producers from publishing data their consumers cannot read.
• SDK / Client LibraryThe vendor's package for your language that wraps their API in normal function calls, so you stop hand-building HTTP requests.
• Serialization / DeserializationTurning app values into a sendable format such as JSON, then parsing that format back into values on the other side.
• Server-Sent Events (SSE)A one-way stream from server to browser over a normal HTTP connection: the server keeps sending chunks, the page reacts as they land.
• Sync Cursor / WatermarkThe saved bookmark that tells the next sync where the last successful one stopped, so it can continue instead of starting over.
• TimeoutThe deadline you put on a call you don't control: wait this long, then give up and move on instead of hanging forever.
• UpsertOne integration operation that creates a missing record or updates the existing one matched by a stable external ID.
• WebhookA URL you hand another service so it calls your app as soon as something happens, instead of you asking over and over.
• Webhook ReplaySending an old webhook event through the receiver again so work missed during an outage or bug can catch up.
• Webhook Signature VerificationProving an incoming webhook really came from the sender by recomputing its HMAC signature with a shared secret before trusting the body.
• WebSocketOne connection held open so server and client can both send messages any time, with no new request per message.

The territory

30 core terms mapped for this field, ranked by how often builders reach for them. Each one is a future entry. Want to bust one? One entry, one file, one pull request.

• WebhookURL you expose that another service POSTs events to"have it ping my app when something happens" · "reverse API call"
• REST APIResource-based HTTP interface using verbs and URL paths"normal API with URLs" · "the regular kind of API"
• API KeyStatic secret string identifying the caller on each request"the secret code you paste in" · "the token thing from the dashboard"
• Rate LimitCap on requests per window before the API rejects you"it cuts me off if I call too fast" · "429 errors"
• EndpointOne callable URL + method on an API"the specific address you hit" · "the route you call"
• HTTP Status Codes (2xx/4xx/5xx)Numeric result classes signaling success, client error, server error"what does a 404 mean" · "the number it sends back"
• PayloadThe body of data sent or returned in a request"the actual stuff being sent" · "the JSON blob"
• Query Parameters vs Path Parameters vs Request BodyThree places to put input on a request"the bit after the question mark" · "where do I put the inputs"
• Content-Type / MIME TypeHeader declaring the format of the body"the application/json header" · "it says wrong format"
• PollingRepeatedly asking an API whether anything changed"check every few seconds" · "keep asking if it's done yet"
• TimeoutMax wait before abandoning an outbound call"it just hangs forever" · "give up after 30 seconds"
• Idempotency KeyClient-supplied ID so retries don't duplicate an operation"so it doesn't charge them twice" · "safe to retry"
• Exponential BackoffRetry with progressively longer waits after failures"wait longer each time it fails" · "don't hammer it"
• CORSBrowser rule controlling which origins may call an API"blocked by the browser" · "works in Postman but not my site"
• Pagination (Cursor vs Offset)Fetching results in chunks via page tokens or offsets"only gives me 100 at a time" · "how do I get the next batch"
• API ProxyYour server relays calls to hide keys and reshape data"call it from my server instead" · "hide the key behind my backend"
• GraphQLQuery language where the client specifies exact fields returned"ask for only the fields I want" · "one endpoint for everything"
• Webhook Signature VerificationChecking an HMAC header proves the webhook is genuine"make sure it's really from them" · "signing secret"
• OpenAPI SpecificationMachine-readable contract describing an API's endpoints and shapes"the swagger file" · "the openapi spec"
• SDK / Client LibraryLanguage-native wrapper hiding raw HTTP calls"the official package" · "the npm thing instead of curl"
• Sandbox / Test ModeFake-data environment for integrating without real effects"practice mode" · "test keys"
• Message QueueBuffer that holds jobs for workers to consume later"put it in line to process later" · "the backlog pipe"
• Integration Platform as a Service (iPaaS)Hosted service wiring apps together via triggers and actions"the Zapier kind of thing" · "connect app A to app B"
• Server-Sent Events (SSE)One-way streaming push from server to browser over HTTP"stream text as it arrives" · "like ChatGPT typing"
• WebSocketPersistent two-way connection for live bidirectional messages"keep the line open" · "real-time back-and-forth"
• Asynchronous Job PatternReturn immediately with a job ID, notify when done"it takes too long to wait" · "kick it off and tell me later"
• Data Mapping / Field MappingTranslating one system's field names into another's"match their columns to mine" · "the translation table"
• CRUDCreate, read, update, delete: the four basic operations"the basic four things" · "add edit delete list"
• API VersioningFreezing an API shape so upgrades don't break clients"don't break my old code" · "the v1 in the URL"
• Batch / Bulk EndpointOne call that operates on many records at once"send 500 at once" · "avoid a call per row"

Deeper in the field

• HTTP Methods Request verbs such as GET, POST, PUT, PATCH, and DELETE
• Request Headers Metadata controlling format, authentication, caching, and request behavior
• Error Response Structured failure body with a stable code, message, and details
• API Documentation Human-readable instructions, examples, limits, and authentication requirements
• multipart/form-data Encoding for uploading files alongside fields
• Presigned URL Temporary link authorizing a direct upload or download
• Serialization / Deserialization Converting application data to and from formats such as JSON
• Long Polling Holding a request open until data arrives or timeout
• Fan-out One event dispatched to many downstream consumers
• Event Bus / Pub-Sub Publishers emit events, subscribers react independently
• At-Least-Once Delivery Guarantee that messages arrive, possibly duplicated
• Deduplication Detecting repeated requests or events so effects happen only once
• Retry Policy Rules for which failures retry, how often, and how long
• Circuit Breaker Stop calling a failing dependency until it recovers
• Dead Letter Queue Holding pen for messages that repeatedly failed processing
• Middleware Code that intercepts requests before your handler runs
• API Gateway Front door that routes, authenticates, and throttles API traffic
• Backend for Frontend (BFF) Backend built for one client, serving exactly what it needs
• Response Normalization Reshaping third-party output into your own schema
• ETag / Conditional Request Cache validator letting servers reply "not modified"
• gRPC Fast binary RPC protocol using protobuf contracts
• RPC-style API Endpoints named as actions rather than resources
• Webhook Replay Re-sending past events to recover from downtime
• Sync Cursor / Watermark Saved position marking where the last sync stopped
• Incremental Sync Transfer only records changed since the previous successful synchronization
• Upsert Create a record when absent; otherwise update the existing record
• Conflict Resolution Rules deciding which system wins when synchronized records diverge
• Reconciliation Periodic full compare to fix drift between two systems
• Eventual Consistency Connected systems may reflect the same update at different times
• Schema Registry Central store of agreed data schemas producers and consumers validate against
• API Deprecation Retiring an endpoint while giving clients time and guidance to migrate