System APIs

API Maker provides a set of 19 powerful System APIs that act as ready-to-use utilities for your backend workflows. These APIs handle common but critical tasks such as encryption, caching, validation, token management, and real-time event handling. By offering these features out of the box, API Maker saves you from reinventing the wheel, improves consistency, and keeps your project secure and scalable.

Why Use In-Built System APIs?

System APIs in API Maker are designed to eliminate repetitive backend work and provide ready-made building blocks for common but essential tasks. Instead of writing boilerplate code for encryption, caching, validation, or token handling, you can plug these APIs directly into your workflows and focus on your business logic.

• Faster Development – Skip writing low-level code for common operations.
• Secure by Default – Encryption, hashing, and secret handling follow industry standards.
• High Performance – Built-in caching and Redis integration speed up your apps.
• Seamless Integrations – Easy to work with third-party APIs, tokens, and event systems.
• Consistency & Reliability – Standardized APIs ensure predictable results across environments.
• Scalable Foundations – Helps projects grow without rewriting core utilities.

With System APIs, you don’t just save time, you build more secure, scalable, and maintainable projects from day one.

Below is the complete list of System APIs, each explained with its purpose, benefits, and practical use cases.

Encrypt Data system api

The Encrypt Data API secures sensitive information by converting plain text into encrypted text using strong cryptographic standards. This ensures that confidential data such as passwords, tokens, or personal details remain unreadable to unauthorized users, whether stored in databases or sent across networks.

• Uses AES encryption algorithm as default, other available options include RC4 & TRIPLEDES.
• Protects sensitive values from leaks or unauthorized access.
• Works seamlessly for both stored data and transmitted data.
• Helps with compliance requirements like GDPR and HIPAA.
• Removes the complexity of writing encryption code manually.
• Ideal for securing confidential fields in APIs and databases.

Read docs → Encrypt Data

Decrypt Data system api

The Decrypt Data API restores previously encrypted text into its original readable form. It allows your system to access secured information safely while ensuring that only authorized services with the correct keys can perform decryption.

• Works directly with data encrypted by the Encrypt Data API.
• Ensures decryption only with valid secret keys, maintaining data integrity.
• Prevents raw sensitive data from ever being exposed directly.
• Simplifies secure access for tokens, credentials, and user info.
• Eliminates the need to manage cryptographic libraries manually.
• Useful in scenarios where you must read protected data securely.

Read docs → Decrypt Data

Hash Data

The Hash Data API generates irreversible, one-way hashes for data. Unlike encryption, hashes cannot be decrypted, making them perfect for verifying integrity and storing values like passwords.

• Creates secure hashes using SHA-256 algorithm.
• Ensures sensitive data cannot be retrieved once hashed.
• Ideal for password storage and data integrity checks.
• Lightweight and efficient for frequent operations.
• Provides consistent, reliable hashing across all environments.
• Prevents raw sensitive data from appearing in logs or databases.

Read docs → Hash Data

Get Token system api

The Get Token API creates secure access tokens that can be used for authenticating requests to your APIs. Tokens simplify session handling and ensure only authorized requests are executed.

• Generates valid tokens automatically for API Maker.
• Tokens are used with the x-am-authorization header for secure calls.
• Works seamlessly with instance APIs, custom APIs, and other services.
• Avoids the hassle of building a manual authentication flow.
• Ensures consistency and safety across authentication workflows.

Read docs → Get Token

Call External API system api

The Call External API function lets you integrate directly with third-party services from within API Maker. You can call APIs in sequence or parallel and manage headers, authentication, and timeouts with ease.

• Integrates smoothly with external systems like payment gateways or CRMs.
• Supports parallel and sequential API calls.
• Securely adds headers, tokens, or keys using stored secrets.
• Eliminates the need for separate HTTP libraries.
• Useful for aggregating data from multiple external services.
• Reduces time spent managing API call orchestration manually.

Read docs → Call External API

Get Secret Key / Keys system api

The Get Secret Key/Keys API securely retrieves sensitive credentials stored in API Maker’s encrypted vault. It ensures that values like API keys, database passwords, or tokens are never hardcoded into your codebase.

• Centralizes secret management with environment awareness.
• Keeps sensitive values out of code and logs.
• Allows seamless rotation of credentials without downtime.
• Protects secrets with strong encryption at rest and in transit.
• Works well with integrations that need dynamic authentication.
• Reduces the risk of accidental leaks or exposures.

Read docs → Get Secret Key(s)

Set Redis Key(s) system api

The Set Redis Key(s) API allows you to store data in the Redis cache for quick access. It is often used for caching results, managing sessions, or reducing database load.

• Stores key-value pairs in Redis instantly.
• Improves application performance by reducing repeated DB queries.
• Supports expiring keys to manage temporary data.
• Useful for session management or rate limiting.
• Works seamlessly across distributed environments.
• Simplifies caching logic with a single API call.

Read docs → Set Redis Key(s)

Get Redis Key(s) system api

The Get Redis Key(s) API retrieves values stored in Redis. It allows fast access to temporary or frequently requested data without hitting the database.

• Retrieves cached results in milliseconds.
• Reduces response times for heavy endpoints.
• Ideal for fetching session data or frequently accessed records.
• Helps scale applications with minimal latency.
• Eliminates redundant database queries.
• Works as part of a complete caching strategy.

Read docs → Get Redis Key(s)

Remove Redis Key(s) system api

The Remove Redis Key(s) API deletes one or more values from Redis. This is essential for keeping the cache updated and ensuring your application reflects the latest data.

• Clears outdated or invalid cache entries.
• Ensures fresh data is served after updates.
• Helps prevent inconsistencies between DB and cache.
• Works for targeted keys without clearing the whole cache.
• Useful for logout, invalidation, or data update flows.
• Supports automation in workflows and schedulers.

Read docs → Remove Redis Key(s)

Reset Database Cache system api

The Reset Database Cache API clears cache entries related to specific database tables. It ensures that when the database changes, your APIs always serve updated results.

• Clears cache only for affected tables.
• Keeps responses accurate after inserts, updates, or deletes.
• Prevents stale data issues in production.
• Works automatically across distributed cache layers.
• Saves developers from manually managing cache refresh logic.
• Essential for keeping applications in sync with live databases.

Read docs → Reset Database Cache

Reset Third-Party API Cache system api

The Reset Third-Party API Cache clears cached results from external APIs integrated into API Maker. This guarantees up-to-date responses when external systems change their data.

• Ensures real-time accuracy from third-party services.
• Works selectively for the required APIs.
• Prevents old or outdated API results from being reused.
• Reduces manual overhead in cache invalidation.
• Keeps integrated services aligned with live data.
• Improves reliability in external data workflows.

Read docs → Reset Third-Party API Cache

Reset Custom APIs Cache system api

The Reset Custom APIs Cache clears cached results for your own custom APIs built inside API Maker. It ensures users always get fresh data after updates or new deployments.

• Targets cache specifically for selected custom APIs.
• Ensures correct results even when logic or DB changes.
• Helps avoid serving outdated results to users.
• Improves debugging and testing workflows.
• Works seamlessly with Redis-based caching layers.
• Keeps API-driven applications consistent and accurate.

Read docs → Reset Custom APIs Cache

Reset System APIs Cache system api

The Reset System APIs Cache clears cached responses for API Maker’s system-level APIs. It helps maintain accurate system behavior when metadata or environment changes.

• Ensures internal API responses remain correct.
• Useful when working with schema or config changes.
• Keeps validation and metadata APIs up-to-date.
• Prevents accidental reliance on old cached results.
• Reduces downtime during schema or environment shifts.
• A must-have for dynamic projects with frequent updates.

Read docs → Reset System APIs Cache

Get Table Meta Data system api

The Get Table Meta Data API retrieves structural details of a database table, such as fields, types, and constraints. It helps developers build dynamic and accurate workflows.

• Fetches live schema directly from the database.
• Reduces duplication of schema definitions.
• Useful for dynamic form generation or schema validation.
• Ensures compatibility across different environments.
• Helps automate database-driven workflows.
• Simplifies development by exposing clear table metadata.

Read docs → Get Table Meta Data

Emit Event system api

The Emit Event API triggers an internal event within API Maker, which can then activate workflows, custom APIs, or notification systems. It enables event-driven architectures with minimal effort.

• Sends domain-specific events across your project.
• Helps decouple logic by shifting to event-driven flows.
• Useful for notifications, background jobs, or triggers.
• Works seamlessly with schedulers and workflows.
• Improves modularity of application design.
• Scales easily as more event consumers are added.

Read docs → Emit Event

Emit Event (WebSocket) system api

The Emit Event (WebSocket) API pushes real-time updates to connected clients. It is ideal for building interactive apps like live dashboards, chats, or notifications.

• Enables instant communication between server and clients.
• Avoids the need for constant polling.
• Perfect for live updates in dashboards or applications.
• Reduces latency for critical user-facing events.
• Scales to multiple connected clients at once.
• Simplifies real-time functionality within applications.

Read docs → Emit Event (WebSocket)

Is Valid Data for Table system api

The Is Valid Data for Table API checks whether a given payload matches the schema of a specific database table. It ensures that only valid data is saved.

• Validates field names, types, and constraints.
• Prevents bad data from being inserted into tables.
• Helps maintain database consistency.
• Useful in forms and APIs for real-time validation.
• Reduces debugging effort by catching errors early.
• Automates data verification in workflows.

Read docs → Is Valid Data for Table

Is Valid Data for Custom API system api

The Is Valid Data for Custom API validates payloads against the expected schema of a custom API. This prevents failures during execution by ensuring correct inputs.

• Ensures requests contain the right fields and formats.
• Reduces runtime errors in custom APIs.
• Improves API reliability for client applications.
• Useful for dynamic frontends and testing tools.
• Prevents incorrect calls from reaching execution.
• Makes APIs more predictable and robust.

Read docs → Is Valid Data for Custom API

Is Valid Data for Third-Party API system api

The Is Valid Data for Third-Party API validates requests before sending them to external services. It reduces wasted calls and ensures compatibility with third-party requirements.

• Checks payloads against the target third-party API schema.
• Prevents malformed or incomplete requests.
• Saves costs by avoiding unnecessary failed API calls.
• Ensures smoother integration with external platforms.
• Useful in automation and workflow systems.
• Improves resilience in multi-service environments.

Read docs → Is Valid Data for Third-Party API

FAQ's

How are System APIs different from Custom APIs?

Custom APIs are created and designed by developers for specific business logic, while System APIs are built-in services provided by API Maker that handle standardized operations like data validation, cache reset, or token generation.

Do I need to configure System APIs separately?

No, System APIs are ready to use out of the box. You just need to call them within your workflows, custom APIs, or events. Some APIs may require inputs like table names, secrets, or payloads depending on the use case.

Are System APIs secure?

Yes, security is built into System APIs. Features like encryption, decryption, and token management follow industry-standard security practices. Sensitive data and keys are stored securely and never exposed in plain text.

Can I use System APIs with third-party integrations?

Yes, many System APIs like Call External API, Is Valid Data for Third-Party API, and Reset Third-Party API Cache are specifically designed to simplify external integrations and ensure smooth communication.

Can I test System APIs in development before using them in production?

Yes, System APIs work across environments. You can safely test them in development or staging environments before moving to production.

Where can I find detailed usage examples for each System API?

Each API has dedicated documentation with usage details, input/output formats, and code examples. You can check them in the official API Maker Docs for hands-on guidance.