Automate New API daily check-ins with newapi-checkin. Explore Docker deployment, best practices, and the rising trend of self-hosted AI API management automation.
Running a self-hosted AI API gateway gives you control, privacy, and cost efficiency. But it also brings a steady stream of routine tasks. One of the most tedious is logging into your New API dashboard every day to manually trigger check-in rewards. Enter newapi-checkin, an open-source Python utility built to handle that exact chore.
Newapi-checkin automates daily check-ins for New API, the self-hosted AI API management panel used by teams to route and manage access to multiple AI models. This article explores what newapi-checkin does, how to deploy it using Docker, and why automating routine API management tasks has become a defining practice in modern DevOps.
New API is a self-hosted API management panel that aggregates access to various AI models from multiple providers behind one consistent interface. Many administrators use it to control costs, enforce quotas, and centralize API key management.
As part of the platform’s engagement mechanics, New API deployments often include a daily check-in feature. Users can claim a small quota or credit bonus by visiting the dashboard and clicking a button. It’s a small reward, but over time it can meaningfully offset API usage costs—especially for heavy users.
The problem? The check-in must happen every day. If you’re responsible for a single account, that’s annoying but manageable. If you’re running several New API deployments for different teams, clients, or environments, the daily ritual becomes a genuine operational drain. A multi-site administrator might spend 15-30 minutes per day just on check-ins—roughly 90 hours a year.
That’s where newapi-checkin changes the game.
Newapi-checkin is a Python-based automation tool designed specifically to perform daily check-ins on one or more New API instances. The project, available on GitHub under the Luckylos repository, is open-source and built for operators who value scriptable, repeatable infrastructure.
Key capabilities include:
These features make it attractive to DevOps teams that are already comfortable with container orchestration and lifecycle management.
The move toward automation in API operations isn’t new, but it’s accelerating. Between 2024 and 2025, the growth of self-hosted AI gateways has placed new demands on administrators. Tools that eliminate manual toil are becoming increasingly valuable.
Consider the four major benefits of automating a routine task like check-ins:
Automation turns a fragile manual process into a deterministic, observable system.
The tool works by calling the backend endpoints that New API exposes for its daily check-in feature. Rather than simulating a browser session or scraping a UI, it sends the same requests that the dashboard sends when you click the check-in button.
The execution flow is straightforward:
Here’s a minimal configuration example using environment variables:
NEWAPI_SITES=https://api.example.com,https://api-dev.example.com
NEWAPI_ACCESS_TOKENS=token-1,token-2
The tool’s CLI is uncomplicated. Once you’ve set the environment variables, you can run it directly:
python checkin.py
# or
docker run --env-file .env luckylos/newapi-checkin:latest
Suppose you manage a small API gateway service for three external clients. Each client has its own New API instance with multiple user accounts eligible for daily check-in bonuses.
Manually, that means:
That’s potentially 10-15 actions per day.
With newapi-checkin, your Compose file declares all three sites and the associated tokens. A cron job runs the container once daily. The tool iterates through every site and account, performs the check-ins, and logs the results. The difference is dramatic—minutes of work collapse into a single automated event.
Docker remains a standard delivery method for DevOps utilities, and newapi-checkin follows that convention. Here’s a basic Compose deployment:
version: '3.8'
services:
newapi-checkin:
image: luckylos/newapi-checkin:latest
container_name: newapi-checkin
environment:
- NEWAPI_SITES=https://api.example.com
- NEWAPI_ACCESS_TOKENS=your-access-token
restart: unless-stopped
For teams using Kubernetes, a CronJob is the natural fit:
apiVersion: batch/v1
kind: CronJob
metadata:
name: newapi-checkin
spec:
schedule: '0 9 * * *'
jobTemplate:
spec:
template:
spec:
restartPolicy: OnFailure
containers:
- name: newapi-checkin
image: luckylos/newapi-checkin:latest
env:
- name: NEWAPI_SITES
value: 'https://api.example.com'
- name: NEWAPI_ACCESS_TOKENS
value: 'your-access-token'
The pattern is simple but powerful. The container runs, does its job, and exits. Your scheduler handles retries and timing.
If you prefer traditional cron on a Linux host, you can schedule the container with a single line:
0 9 * * * docker run --rm --env-file /etc/newapi-checkin.env luckylos/newapi-checkin:latest
This approach works well for small deployments that don’t justify a full Kubernetes cluster.
Before deploying newapi-checkin in a production environment, work through these considerations.
Because the tool interacts programmatically with New API endpoints, you should verify that automated check-ins are permitted under the terms of service of your API providers. Some providers may restrict automated actions, even benign ones. If you can’t find explicit guidance, ask your provider or the New API maintainers.
Access tokens are credentials. Treat them accordingly:
Run the tool in a staging environment first. Confirm that your endpoint URLs are correct, that the check-in requests succeed, and that the logging captures useful results.
Check-in failures are rarely urgent, but they can accumulate. Add basic monitoring to your scheduler. If the job fails for three consecutive days, you want to know before your quota runs dry.
New API changes over time. The endpoint newapi-checkin depends on may shift in future releases. Check the project’s repository periodically, review the changelog, and test updated versions in staging before rolling them out.
Newapi-checkin is a small tool, but it’s evidence of a much larger movement. Organizations are treating AI infrastructure with the same operational discipline they apply to databases, networking, and CI/CD systems. Since the rapid adoption of AI APIs in 2023-2025, the ecosystem of self-hosted AI infrastructure tools has expanded significantly.
This includes:
The trend toward automation of routine API management tasks is expected to continue rising through 2025 and beyond. As AI model access becomes more commoditized, the tools that manage and optimize that access will only grow in importance.
Newapi-checkin addresses a narrow but meaningful pain point: the daily grind of checking into New API panels to claim quota rewards. With its support for multiple accounts and multiple sites, Docker-first packaging, and easy scheduling, it’s a practical tool for DevOps professionals running self-hosted AI gateways.
To get started:
Automation is a force multiplier in modern DevOps. Even a small win—like reclaiming 30 minutes a day from manual check-ins—compounds over time. If you’re running New API in production and haven’t yet automated your daily check-ins, newapi-checkin is a smart place to start.
newapi-checkin is an open-source Python utility that automates daily check-ins for New API, a self-hosted AI API management panel. It supports multiple accounts and multiple New API sites, and it can be deployed with Docker or Docker Compose.
Use the Docker and Docker Compose packaging included in the newapi-checkin repository. Configure the tool with environment variables for your New API site URLs and account credentials, then run the container as part of your stack. Schedule it to run once per day so the check-in is performed automatically.
Manual check-ins are repetitive and time-consuming, especially for administrators managing multiple deployments. A multi-site administrator can spend 15-30 minutes per day, or about 90 hours per year, just clicking the check-in button. Automation eliminates that overhead and ensures rewards are claimed consistently.
Yes. newapi-checkin was built with multiple account support and multiple site support, so one run can check in across several user accounts and several New API deployments. This makes it well suited for teams managing more than one instance.
Run newapi-checkin in a consistent environment such as Docker, and store credentials in environment variables or a secrets manager instead of hardcoding them. Schedule the job to run once per day at a reliable time, and monitor logs so you can catch failed check-ins before they cost you quota.
