SDK means software development kit. It is a package of developer tools and resources for building software for a particular service, platform, language, or environment. An SDK might provide libraries, documentation, examples, testing tools, and access to one or more APIs.
For example, an SDK method might package request formatting and documented credential handling needed to update a record. Application code can then call a library function instead of assembling every HTTP request itself. The application still needs to provide valid input, enforce business rules, handle errors, and decide whether the action is authorized.
An SDK is a developer toolkit, not an automatic integration or a guarantee that every operation is supported. The practical question is whether a specific SDK covers the operation you need in your language and runtime, and whether your team can maintain it.
What is an SDK?
A software development kit typically includes some combination of libraries, API access, documentation, sample code, and tools for testing or debugging. Some SDKs also provide command line tools, starter projects, plugins, emulators, or other development resources. There is no universal checklist that every SDK must satisfy.
A library call illustrates the convenience. Your application might call a method to upload a file. The library could format the service request and apply its documented authentication behavior. Your application still needs to provide valid input, handle the result or error, and determine whether the user or process is allowed to make that change.
AWS SDK documentation is one concrete example of vendor specific SDK guidance. It covers SDK configuration, authentication, supported runtimes, maintenance, and version lifecycle. Those details are not a specification for every vendor’s SDK.
SDK vs. API: what is the difference?
An API defines an interface or communication contract: how a program requests an operation and what response it can expect. An SDK may wrap one or more APIs in language specific methods and add supporting resources. Whether it handles authentication helpers, retries, types, pagination, or other tasks depends on that SDK and version.
| Choice | Use it when | Tradeoff |
|---|---|---|
| SDK | It supports the required operations, language, and runtime. | It can reduce request plumbing, but adds a dependency and upgrade schedule. |
| Direct API | The SDK is missing, incomplete, behind the API, or unavailable for your language. | Your team owns more request, authentication, error, and version handling. |
| Integration platform | You need to connect business applications without building a custom product integration. | Actions, controls, and behavior depend on the platform and connected apps. |
An API can be used without an official SDK. Conversely, an SDK is useful only if its supported surface fits the job. Check endpoint or operation coverage and language support before choosing based on installation convenience.
An SDK is a convenience layer around interfaces. Adopt it only when its supported operations, lifecycle, and operating controls fit the work you need to do.
What an SDK does in an application
A typical request and response sequence looks like this:
- Application code calls an SDK method with input values.
- The SDK builds a request and may apply documented credential, retry, or response handling behavior.
- The service returns a response or error.
- The application checks the result, applies business rules, records the outcome, and decides what to show or do next.
This is an illustrative model, not a guarantee about a particular library. For example, AWS credential provider guidance explains credential behavior for AWS environments. It does not establish how another vendor’s SDK handles credentials. Confirm request, retry, pagination, and error behavior in the reference documentation for the SDK and version you plan to use.
Keep application responsibilities explicit. An SDK can help communicate with a service, but it does not decide whether a particular employee may change a particular record, whether a value meets your business rules, or whether the user has consented to the action.
Common SDK categories and what they help build
- Mobile and web platform SDKs support development for a device or application environment. Check which platforms, runtimes, and operations the specific package supports.
- Cloud SDKs let application code work with a cloud provider’s services. AWS publishes language specific SDK resources and guidance for configuration and lifecycle.
- Payment and identity SDKs are categories for building software around payment or identity services. Vendors may provide different combinations of sign in, session, payment, or policy functionality, so verify the exact product documentation.
- AI and agent SDKs provide developer interfaces for model or agent workflows. The OpenAI Agents SDK documentation describes agents, tools, handoffs, guardrails, sessions, and structured output. These capabilities are specific to that SDK and require configuration.
A category identifies the development problem an SDK may address, not a standard feature set. Verify supported platforms, permissions, operations, and lifecycle for the exact product.
How to evaluate an SDK before adopting it
Installation speed is not enough to judge whether an SDK will work in production. Check its official reference material, release notes, version policy, security advisories, and behavior on the operations your system actually needs.
- Is the SDK official, or does it have a named maintainer and a clear support channel?
- Does it support your language, runtime, and required version?
- Can you find every required read and write operation in the reference documentation?
- Are authentication, errors, retries, pagination, and rate limits explained?
- Are release notes, security advisories, deprecations, and a version support policy available?
- Can you test a small change, including permission failure and invalid input, before production?
Build a proof of fit around one important read and one important write. Record expected inputs and outputs, then test a missing permission, malformed input, and failed request. Include dependency and upgrade effort in the decision. A wrapper can reduce boilerplate, but it also becomes part of your maintenance surface.
Using an SDK for app workflows: a current Zapier example
Zapier’s current SDK documentation advertises access to 9,000+ app integrations and describes the product as being in open beta. Counts and product status can change. Its Code step guide documents a JavaScript only surface, requires at least one connected app, and describes discovering app keys and action fields, looking up connections, and invoking read, search, or write actions. It is not a Python Code step workflow.
The documented Zapier SDK surface also includes authenticated requests and connection lookup, but governance differs by method. Zapier documents organization app and action restrictions for pre-built actions. Direct .fetch() calls are not currently covered by those same restrictions. Review the current Zapier SDK documentation before routing sensitive operations through it.
Zapier documentation shows a pattern that searches for a Google Calendar event, updates it, looks up attendees in Slack, and sends messages to matched users. Treat that documentation as an example pattern requiring connected accounts and account specific fields, not as a copy and run template.
- Resolve the event: search using the calendar and supplied search text. Verify that the returned event ID, title, organizer, and date identify the intended event.
- Apply the update: pass the target start and end times to the documented write action. Record the returned event identifier and update outcome.
- Resolve recipients: search Slack for each attendee email. Send a direct message only when the result is unambiguous. Route missing or multiple matches to the workflow owner.
- Track partial success: record whether the calendar update and each notification succeeded. If the update worked but a message failed, retry the notification only, subject to duplicate prevention.
Before invoking a write, verify that connections exist and are usable, required fields are present, identifiers belong to the expected account, and the search result is exact enough for the intended change. A durable record of event ID, target update, notification status, and side effect attempt can help the owner recover from partial completion.
For teams planning operational app connections, see Zapier automation services.
AI agents and SDK actions: keep the model inside a controlled boundary
An agent SDK can provide tools, workflow mechanisms, guardrails, approval interruptions, and tracing, but it does not make an AI generated action safe by default. In the OpenAI Agents SDK, developers can configure tool guardrails and approval interruptions for selected calls, and use tracing for model generations, tools, handoffs, and guardrails. Those controls must be applied to the relevant tools and workflow. Making a tool visible to an agent is not authorization.
Use AI for work that depends on meaning, such as classifying an ambiguous request or extracting candidate fields from narrative text. Use deterministic code for required fields, allowed values, permissions, amount limits, destination allowlists, freshness checks, sensitive data rules, and duplicate prevention. If downstream code relies on the model response, require structured output and validate its schema and business rules before any write.
The following is an illustrative application contract, not a vendor schema:
{
"classification": "reschedule",
"source_record_id": "evt_4821",
"needs_review": true,
"policy_version": "calendar-write-v3"
}
Application code should reject unknown classifications, missing source IDs, invalid dates, stale records, and disallowed destinations before considering a write. It should separately check actor and record permissions. A confidence value is not a substitute for those checks.
For workflows that write to customer records, the CRM or other designated system of record should retain the resulting record ID and status. Define an exception owner for rejected, ambiguous, or failed operations. Teams considering this operating model can review AI agent services or CRM systems consulting.
Retries, duplicate writes, and ownership
A retry does not make a write safe to repeat. If a request creates a message or record and the response is lost, a second attempt may create another side effect. Use a stable event or request identifier and, where supported, a destination idempotency key.
When maintaining data in your own database, enforce uniqueness with a database constraint and use a transactional upsert where appropriate. A lookup followed by create is not race safe: two workers can both find no record and then create one. A unique constraint or atomic upsert closes that gap more reliably than a read then insert check by itself.
Keep different data grains separate. One source event row should represent one source event, keyed by its stable source event ID where available. A model run observation is a separate record for one execution. A citation is a separate record for one citation attached to one answer. An aggregate metric is a summary for a defined entity, model or engine, geography, and period.
For example, an illustrative deduplication design might use (source_system, source_event_id) for source events, (workflow_id, run_id, prompt_id) for model observations, and (run_id, answer_id, citation_position) for citation records. An aggregate could use (entity_id, engine, model, region, period_start, period_end, aggregation_version). These are proposed keys, not vendor schemas. Do not deduplicate all of these grains using only a date.
A practical decision rule
Start with the operation and the team that will own its outcome. Confirm that the SDK covers the operation in your runtime and has a credible version and maintenance policy. Test success, permission failure, invalid input, rate limiting, and retry paths.
Use the raw API if the SDK blocks a real requirement or lags behind the interface. Choose an integration platform when custom application code is unnecessary. Run a small pilot and measure implementation effort, failure and retry rate, upgrade effort, and time to resolve errors.
Adopt the SDK when its actual coverage and operating requirements fit the workflow, not because SDKs are inherently faster, safer, or easier to maintain.
