### API Analytics
Build great API products with a deep understanding of API usage and user behavior. Answer critical business and engineering questions around your APIs needed to drive the right outcomes.
### Deeply understand how APIs are used
No more waiting for problems to snowball. Track API usage time series, with performance and metric charts, and more. Segment and aggregate by URI request, endpoints, HTTP headers, body fields, or customer demographics.
### Context-Rich Data at the endpoint level
View the problematic endpoints, their performance and latency distributions, and enough context to debug and resolve issues.
### Zoom into the individual customer requests understand issues
Sometimes, you need to see what payloads customers were sending, to debug why something went wrong, or why there was a performance degradation. You can even see the locations a request was made from, and the latency of that specific request.
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)