### API Management
APItoolkit isn’t just another API management tool. It’s the most feature-rich solution available, offering everything you need to manage your APIs effectively.
### API Monitoring
With comprehensive metrics tracking, you gain deep insights into how your API interacts with your system. Monitor every call and leverage alerting and notification to ensure you catch errors before they reach your customers.
### Maintain API Quality and Reliability
By leveraging API documentation tools for clear instructions, API testing tools to identify and fix issues early, and API monitoring tools to catch problems before they impact users, you can deliver the dependable experience your customers deserve.
### Advanced generated tests and monitors
Test in both staging and production environments. Be aware of issues before they escalate. Perform rigorous tests effortlessly.
### Analytics and Reporting
Monitor and pinpoint every single error. Understand the “Why,” “How,” and “When” these errors occur. Get a fully informative analytics dashboard. It applies to all use cases, including yours!
Watch Errors, Performance, and any numbers that matter over time
Track errors, stack traces, and also record the incoming and outgoing requests which triggered the error. Get all information you need to reproduce a bug.
An openAPI schema and spec is automatically generated from your live traffic. Approve and acknowlege endpoints and fields
Write powerful queries against your realtime data using our visual query builder or our query language for more complex queries.
Set up custom monitors and receive alerts when things go wrong via slack or email
Get daily or weekly reports about errors and performance of your entire application
Quickly integrate APIToolkit into your express js application
npm install apitoolkit-express
import express from 'express';
import { APIToolkit } from 'apitoolkit-express';
const app = express();
const apitoolkitClient = APIToolkit.NewClient({ apiKey: '' });
app.use(apitoolkitClient.expressMiddleware)
// All controllers should live here
app.get("/", (req, res) => {
});
// ...
// The error handler must be before any other error middleware
// and after all controllers
app.use(apitoolkitClient.errorHandler)
Quickly integrate APIToolkit into your elixir application
{:apitoolkit_phoenix, "~> 0.1.1"}
// route.ex file
defmodule HelloWeb.Router do
import ApitoolkitPhoenix
pipeline :api do
plug ApitoolkitPhoenix,
config: %{
api_key: "",
}
end
// Automatic error handling
@impl Plug.ErrorHandler
def handle_errors(conn, err) do
conn = report_error(conn, err)
json(conn, %{message: "Something went wrong"})
end
end
Quickly integrate APIToolkit into your laravel application
composer require apitoolkit/apitoolkit-laravel
APITOOLKIT_KEY=xxxxxx-xxxxx-xxxxxx-xxxxxx-xxxxxx
[
\APIToolkit\Http\Middleware\APIToolkit::class,
],
];
}
Quickly integrate APIToolkit into your .NET application
dotnet add package ApiToolkit.Net
var config = new Config
{
Debug = true, # Set debug flags to false in production
ApiKey = "{Your_APIKey}"
};
var client = await APIToolkit.NewClientAsync(config);
# Register the middleware to use the initialized client
app.Use(async (context, next) =>
{
var apiToolkit = new APIToolkit(next, client);
await apiToolkit.InvokeAsync(context);
});
Quickly integrate APIToolkit into your Django application
pip install apitoolkit-django
APITOOLKIT_KEY = "< YOUR_API_KEY >"
MIDDLEWARE = [
...,
'apitoolkit_django.APIToolkit',
...,
]
var config = new Config
{
Debug = true, # Set debug flags to false in production
ApiKey = "{Your_APIKey}"
};
Quickly integrate APIToolkit into your fastapi application
pip install apitoolkit-fastapi
from fastapi import FastAPI
from apitoolkit_fastapi import APIToolkit
app = FastAPI()
apitoolkit = APIToolkit(api_key='')
app.middleware('http')(apitoolkit.middleware)
Quickly integrate APIToolkit into your flask application
pip install apitoolkit-flask
from flask import Flask
from apitoolkit_flask import APIToolkit
app = Flask(**name**)
apitoolkit = APIToolkit(api_key="", debug=True)
@app.before_request
def before_request():
apitoolkit.beforeRequest()
@app.after_request
def after_request(response):
apitoolkit.afterRequest(response)
return response
Quickly integrate APIToolkit into your gin application
go get github.com/apitoolkit/apitoolkit-go
package main
import (
"context"
apitoolkit "github.com/apitoolkit/apitoolkit-go"
"github.com/gin-gonic/gin"
)
func main() {
// Initialize the client using your apitoolkit.io generated apikey
apitoolkitClient, err := apitoolkit.NewClient(context.Background(), apitoolkit.Config{APIKey: "YOUR GENERATED API KEY"})
if err != nil {
panic(err)
}
router := gin.New()
// Register with the corresponding middleware of your choice. For Gin router, we use the GinMiddleware method.
router.Use(apitoolkitClient.GinMiddleware)
}
Quickly integrate APIToolkit into your adonis js application
npm install apitoolkit-adonis
node ace configure apitoolkit-adonis
/conf/apitoolkit
export const apitoolkitConfig = {
apiKey: "",
};
Server.middleware.register([
() => import("@ioc:Adonis/Core/BodyParser"),
() => import("@ioc:APIToolkit"),
]);
Quickly integrate APIToolkit into your Fastify js application
npm install apitoolkit-fastify
import APIToolkit from 'apitoolkit-fastify';
import Fastify from 'fastify';
const fastify = Fastify();
// Create and initialize an instance of the APIToolkit
const apittoolkitClient = APIToolkit.NewClient({
apiKey: 'YOUR_API_KEY',
fastify,
});
apitoolkitClient.init();
Quickly integrate APIToolkit into your nest js application
npm install apitoolkit-express
import { NestFactory } from '@nestjs/core';
import { APIToolkit } from 'apitoolkit-express';
import { AppModule } from './app.module';
//
async function bootstrap() {
const apiToolkitClient = APIToolkit.NewClient({
apikey: '',
});
const app = await NestFactory.create(AppModule);
app.use(apiToolkitClient.expressMiddleware);
await app.listen(3000);
}
//
bootstrap();
Quickly integrate APIToolkit into your Golang Gorilla Mux application
go get -u github.com/gorilla/mux
package main
import (
"context"
"net/http"
"github.com/gorilla/mux"
apitoolkit "github.com/apitoolkit/apitoolkit-go"
)
func main() {
ctx := context.Background()
// Initialize the client using your generated apikey
apitoolkitClient, err := apitoolkit.NewClient(ctx, apitoolkit.Config{APIKey: ""})
if err != nil {
panic(err)
}
r := mux.NewRouter()
// Register middleware
r.Use(apitoolkitClient.GorillaMuxMiddleware)
}
Quickly integrate APIToolkit into your Symfony PHP application
composer require apitoolkit/apitoolkit-symfony
APITOOLKIT_KEY=xxxxxx-xxxxx-xxxxxx-xxxxxx-xxxxxx
services:
APIToolkit\EventSubscriber\APIToolkitService:
arguments:
$apiKey: '%env(APITOOLKIT_KEY)%'
# Optional: if you want to cache login result add this cache poll instance via setter injection
calls:
- setCachePool: ['@PutYourCachePoolServiceHere']
tags:
- { name: 'kernel.event_subscriber' }
Quickly integrate APIToolkit into your native Golang application
go get -u github.com/apitoolkit/apitoolkit-go
package main
import (
"net/http"
"context"
apitoolkit "github.com/apitoolkit/apitoolkit-go"
)
func main() {
// Initialize APIToolkit client with your generated API key
ctx := context.Background()
apitoolkitClient, err := apitoolkit.NewClient(ctx, apitoolkit.Config{APIKey: "YOUR_GENERATED_API_KEY"})
if err != nil {
panic(err)
}
http.Handle("/", apitoolkitClient.Middleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("Hello, World!"))
})))
http.ListenAndServe(":8080", nil)
}
We support 14+ web frameworks (if we don't support your framework, email [email protected] and we'll create an SDK for you ASAP)